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/app.js

@@ -12,6 +12,7 @@ import { mapLidarrSearch } from './mapping.js'
 import { settingsStore } from './settings.js'
 import { makeTesters } from './testers.js'
 import { ytmusicFlow } from './ytmusic.js'
+import { suggestEngine } from './suggest.js'
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url))
 
@@ -30,6 +31,7 @@ export function buildApp(config, deps = {}) {
   const store = deps.store ?? settingsStore(config.dataDir ?? '/data')
   const testers = deps.testers ?? makeTesters({ config, store })
   const ytmusic = deps.ytmusic ?? ytmusicFlow({ config, store })
+  const suggest = deps.suggest ?? suggestEngine({ config, store, lidarr })
   const app = Fastify({ logger: true, trustProxy: true })
 
   app.register(fastifyCookie)
@@ -164,6 +166,9 @@ export function buildApp(config, deps = {}) {
         clientSecretSet: Boolean(s.ytmusic?.clientSecret),
         connected: existsSync(ytmusic.oauthPath),
       },
+      suggest: {
+        intervalHours: s.suggest?.intervalHours ?? 24,
+      },
     }
   })
 
@@ -182,10 +187,51 @@ export function buildApp(config, deps = {}) {
         clientId: body.ytmusic?.clientId,
         clientSecret: body.ytmusic?.clientSecret,
       },
+      suggest: {
+        intervalHours:
+          body.suggest?.intervalHours === undefined || body.suggest?.intervalHours === null
+            ? undefined
+            : Math.max(0, Number(body.suggest.intervalHours) || 0),
+      },
     })
     return { ok: true }
   })
 
+  app.post('/api/suggest/run', async (req, reply) => {
+    try {
+      const batch = await suggest.run('manuell')
+      return { ok: true, batchId: batch.id, count: batch.items.length }
+    } catch (err) {
+      req.log.error({ err }, 'förslagsgenerering misslyckades')
+      return reply.code(502).send({ error: err.message })
+    }
+  })
+
+  app.get('/api/suggest/latest', async () => {
+    const s = store.load()
+    return {
+      items: suggest.latest(10),
+      lastRun: suggest.lastRun(),
+      intervalHours: s.suggest?.intervalHours ?? 24,
+    }
+  })
+
+  app.get('/api/suggest/batches', async () => {
+    return suggest.loadBatches().map((b) => ({
+      id: b.id,
+      createdAt: b.createdAt,
+      trigger: b.trigger,
+      count: b.items.length,
+      signalCounts: b.signalCounts,
+    }))
+  })
+
+  app.get('/api/suggest/batches/:id', async (req, reply) => {
+    const batch = suggest.loadBatches().find((b) => b.id === Number(req.params.id))
+    if (!batch) return reply.code(404).send({ error: 'batchen finns inte' })
+    return batch
+  })
+
   app.post('/api/ytmusic/start', async (req, reply) => {
     try {
       const out = await ytmusic.start()
@@ -226,5 +272,8 @@ export function buildApp(config, deps = {}) {
     })
   }
 
+  app.decorate('suggest', suggest)
+  app.decorate('settingsStore', store)
+
   return app
 }

backend/src/lidarr.js

@@ -26,6 +26,7 @@ export function lidarrClient(config) {
 
   return {
     search: (term) => req('GET', `/api/v1/search?term=${encodeURIComponent(term)}`),
+    artists: () => req('GET', '/api/v1/artist'),
     addArtist: (payload) => req('POST', '/api/v1/artist', payload),
     addAlbum: (payload) => req('POST', '/api/v1/album', payload),
   }

backend/src/server.js

@@ -14,3 +14,21 @@ app.listen({ port: config.port, host: config.host }).catch((err) => {
   app.log.error(err)
   process.exit(1)
 })
+
+// Schemaläggaren: var 10:e minut, kolla om det är dags för en ny
+// förslags-batch (intervall i timmar från inställningarna; 0 = av).
+const CHECK_MS = 10 * 60 * 1000
+setInterval(async () => {
+  try {
+    const hours = app.settingsStore.load().suggest?.intervalHours ?? 24
+    if (!hours) return
+    const last = app.suggest.lastRun()
+    const due = !last || Date.now() - Date.parse(last) >= hours * 3600 * 1000
+    if (!due) return
+    app.log.info('schemalagd förslagsgenerering startar')
+    const batch = await app.suggest.run('schemalagd')
+    app.log.info(`schemalagd batch #${batch.id} klar med ${batch.items.length} förslag`)
+  } catch (err) {
+    app.log.warn({ err }, 'schemalagd förslagsgenerering misslyckades')
+  }
+}, CHECK_MS)

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
+    },
+  }
+}