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

@@ -168,6 +168,7 @@ export function buildApp(config, deps = {}) {
       },
       suggest: {
         intervalHours: s.suggest?.intervalHours ?? 24,
+        trackIntervalDays: s.suggest?.trackIntervalDays ?? 7,
       },
     }
   })
@@ -192,14 +193,19 @@ export function buildApp(config, deps = {}) {
           body.suggest?.intervalHours === undefined || body.suggest?.intervalHours === null
             ? undefined
             : Math.max(0, Number(body.suggest.intervalHours) || 0),
+        trackIntervalDays:
+          body.suggest?.trackIntervalDays === undefined || body.suggest?.trackIntervalDays === null
+            ? undefined
+            : Math.max(0, Number(body.suggest.trackIntervalDays) || 0),
       },
     })
     return { ok: true }
   })
 
   app.post('/api/suggest/run', async (req, reply) => {
+    const type = req.body?.type === 'tracks' ? 'tracks' : 'mix'
     try {
-      const batch = await suggest.run('manuell')
+      const batch = await suggest.run('manuell', type)
       return { ok: true, batchId: batch.id, count: batch.items.length }
     } catch (err) {
       req.log.error({ err }, 'förslagsgenerering misslyckades')
@@ -210,15 +216,19 @@ export function buildApp(config, deps = {}) {
   app.get('/api/suggest/latest', async () => {
     const s = store.load()
     return {
-      items: suggest.latest(10),
-      lastRun: suggest.lastRun(),
+      items: suggest.latest(10, 'mix'),
+      tracks: suggest.latest(10, 'tracks'),
+      lastRun: suggest.lastRun('mix'),
+      lastTrackRun: suggest.lastRun('tracks'),
       intervalHours: s.suggest?.intervalHours ?? 24,
+      trackIntervalDays: s.suggest?.trackIntervalDays ?? 7,
     }
   })
 
   app.get('/api/suggest/batches', async () => {
     return suggest.loadBatches().map((b) => ({
       id: b.id,
+      type: b.type ?? 'mix',
       createdAt: b.createdAt,
       trigger: b.trigger,
       count: b.items.length,

backend/src/server.js

@@ -15,20 +15,30 @@ app.listen({ port: config.port, host: config.host }).catch((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).
+// Schemaläggaren: var 10:e minut, kolla om det är dags för nya
+// förslags-batcher. Artist/album-mixen styrs av intervalHours (0 = av),
+// låtförslagen av trackIntervalDays (default veckovis, 0 = av).
 const CHECK_MS = 10 * 60 * 1000
+
+async function runIfDue(type, ms) {
+  if (!ms) return
+  const last = app.suggest.lastRun(type)
+  if (last && Date.now() - Date.parse(last) < ms) return
+  app.log.info(`schemalagd förslagsgenerering (${type}) startar`)
+  const batch = await app.suggest.run('schemalagd', type)
+  app.log.info(`schemalagd batch #${batch.id} (${type}) klar med ${batch.items.length} förslag`)
+}
+
 setInterval(async () => {
+  const s = app.settingsStore.load().suggest ?? {}
   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`)
+    await runIfDue('mix', (s.intervalHours ?? 24) * 3600 * 1000)
   } catch (err) {
-    app.log.warn({ err }, 'schemalagd förslagsgenerering misslyckades')
+    app.log.warn({ err }, 'schemalagd mix-generering misslyckades')
+  }
+  try {
+    await runIfDue('tracks', (s.trackIntervalDays ?? 7) * 24 * 3600 * 1000)
+  } catch (err) {
+    app.log.warn({ err }, 'schemalagd låt-generering misslyckades')
   }
 }, CHECK_MS)

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

backend/test/suggest.test.js

@@ -11,14 +11,16 @@ function makeYoutubarrDb(dir) {
   const p = path.join(dir, 'db.sqlite3')
   const db = new Database(p)
   db.exec(`
-    CREATE TABLE youtubarr_playlist (id INTEGER PRIMARY KEY, title TEXT);
+    CREATE TABLE youtubarr_playlist (id INTEGER PRIMARY KEY, playlist_id TEXT, title TEXT);
     CREATE TABLE youtubarr_trackitem (
       id INTEGER PRIMARY KEY, playlist_id INTEGER, title TEXT,
       artist_name_guess TEXT, blacklisted INTEGER DEFAULT 0
     );
-    INSERT INTO youtubarr_playlist VALUES (1, 'lefu-Musick');
+    INSERT INTO youtubarr_playlist VALUES (1, 'PLC0x', 'lefu-Musick');
+    INSERT INTO youtubarr_playlist VALUES (2, 'LM', 'Liked Music');
     INSERT INTO youtubarr_trackitem VALUES (1, 1, 'Amaranth', 'Nightwish', 0);
     INSERT INTO youtubarr_trackitem VALUES (2, 1, 'Svart', 'Hemligt Band', 1);
+    INSERT INTO youtubarr_trackitem VALUES (3, 2, 'Gimme! Gimme! Gimme!', 'ABBA', 0);
   `)
   db.close()
   return p
@@ -109,6 +111,29 @@ test('run: markdown-staket runt JSON hanteras', async () => {
   assert.equal(batch.items[0].name, 'Ghost')
 })
 
+test('run(tracks): gillade + mest spelade in i prompten, egen batch-typ', async () => {
+  const { engine, fetchImpl } = setup({
+    geminiResponse: JSON.stringify([
+      { name: 'Dancing Queen', artist: 'ABBA', motivation: 'Klassiker.' },
+    ]),
+  })
+  const batch = await engine.run('manuell', 'tracks')
+
+  assert.match(fetchImpl.prompt, /ENSKILDA LÅTAR/)
+  assert.match(fetchImpl.prompt, /ABBA – Gimme! Gimme! Gimme!/, 'Liked Music-låtar ska in')
+  assert.match(fetchImpl.prompt, /1000mods – Zenit/, 'mest spelade ska in')
+
+  assert.equal(batch.type, 'tracks')
+  assert.equal(batch.items[0].kind, 'track')
+  assert.equal(batch.items[0].secondary, 'ABBA')
+  assert.equal(batch.items[0].artistMbid, 'mbid-x', 'artist-mbid berikas för Hämta')
+
+  assert.equal(engine.latest(10, 'tracks').length, 1)
+  assert.equal(engine.latest(10, 'mix').length, 0, 'låt-batcher ska inte blandas in i mixen')
+  assert.equal(engine.lastRun('tracks'), batch.createdAt)
+  assert.equal(engine.lastRun('mix'), null)
+})
+
 test('run utan Gemini-nyckel ger begripligt fel', async () => {
   const { engine, dataDir } = setup()
   const store = settingsStore(dataDir)

frontend/src/components/MusicCard.vue

@@ -1,9 +1,17 @@
 <script setup>
-import { ref } from 'vue'
+import { computed, ref } from 'vue'
 
 const props = defineProps({ item: { type: Object, required: true } })
 const state = ref('') // '' | 'busy' | 'done' | 'fanns' | 'fel'
 
+const ytUrl = computed(() => {
+  const q =
+    props.item.kind === 'artist'
+      ? props.item.name
+      : `${props.item.secondary ?? ''} ${props.item.name}`.trim()
+  return `https://music.youtube.com/search?q=${encodeURIComponent(q)}`
+})
+
 async function grab() {
   state.value = 'busy'
   try {
@@ -43,12 +51,15 @@ async function grab() {
       </span>
       <p v-if="item.motivation" class="motivation">{{ item.motivation }}</p>
     </div>
+    <div class="buttons">
       <button v-if="item.inLibrary || state === 'fanns'" class="have" disabled>✓ I biblioteket</button>
       <button v-else-if="state === 'done'" class="have" disabled>✓ Hämtas</button>
       <button v-else-if="!item.mbid" class="have" disabled title="hittades inte i Lidarrs metadata">går ej att hämta</button>
       <button v-else :disabled="state === 'busy'" @click="grab">
         {{ state === 'busy' ? 'Lägger till…' : state === 'fel' ? 'Försök igen' : '⤓ Hämta' }}
       </button>
+      <a class="yt" :href="ytUrl" target="_blank" rel="noopener" title="Öppna i YouTube Music">▶ YT</a>
+    </div>
   </article>
 </template>
 
@@ -134,4 +145,33 @@ async function grab() {
   color: var(--text-dim);
   cursor: default;
 }
+
+.buttons {
+  display: flex;
+  gap: 0.4rem;
+}
+
+.buttons button {
+  flex: 1;
+  min-width: 0;
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+
+.yt {
+  flex: 0 0 auto;
+  display: grid;
+  place-items: center;
+  padding: 0.55rem 0.7rem;
+  border-radius: 0.5rem;
+  border: 1px solid rgba(255, 60, 60, 0.45);
+  color: #ff8080;
+  font-size: 0.85rem;
+  white-space: nowrap;
+}
+
+.yt:hover {
+  background: rgba(255, 60, 60, 0.12);
+}
 </style>

frontend/src/pages/DiscoverPage.vue

@@ -3,24 +3,34 @@ import { onMounted, ref } from 'vue'
 import MusicCard from '../components/MusicCard.vue'
 
 const items = ref([])
+const tracks = ref([])
 const lastRun = ref(null)
+const lastTrackRun = ref(null)
 const intervalHours = ref(24)
-const busy = ref(false)
+const trackIntervalDays = ref(7)
+const busy = ref({})
 const error = ref('')
 
 async function load() {
   const res = await fetch('/api/suggest/latest')
   const body = await res.json()
   items.value = body.items
+  tracks.value = body.tracks
   lastRun.value = body.lastRun
+  lastTrackRun.value = body.lastTrackRun
   intervalHours.value = body.intervalHours
+  trackIntervalDays.value = body.trackIntervalDays
 }
 
-async function generate() {
-  busy.value = true
+async function generate(type) {
+  busy.value = { ...busy.value, [type]: true }
   error.value = ''
   try {
-    const res = await fetch('/api/suggest/run', { method: 'POST' })
+    const res = await fetch('/api/suggest/run', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ type }),
+    })
     const body = await res.json()
     if (!res.ok) {
       error.value = body.error ?? 'genereringen misslyckades'
@@ -30,7 +40,7 @@ async function generate() {
   } catch {
     error.value = 'genereringen misslyckades'
   } finally {
-    busy.value = false
+    busy.value = { ...busy.value, [type]: false }
   }
 }
 
@@ -53,8 +63,8 @@ onMounted(load)
           <template v-else> · schema: av</template>
         </span>
         <router-link class="link" :to="{ name: 'suggestions' }">Alla förslag →</router-link>
-        <button :disabled="busy" @click="generate">
-          {{ busy ? 'Genererar… (kan ta en halv minut)' : '✨ Generera nya förslag' }}
+        <button :disabled="busy.mix" @click="generate('mix')">
+          {{ busy.mix ? 'Genererar… (kan ta en halv minut)' : '✨ Generera nya förslag' }}
         </button>
       </div>
     </div>
@@ -74,6 +84,31 @@ onMounted(load)
         lagt till på YouTube Music.
       </p>
     </div>
+
+    <div class="head tracks-head">
+      <h2>Veckans låtar</h2>
+      <div class="actions">
+        <span class="dim">
+          Senaste körning: {{ fmt(lastTrackRun) }}
+          <template v-if="trackIntervalDays"> · schema: var {{ trackIntervalDays }}:e dag</template>
+          <template v-else> · schema: av</template>
+        </span>
+        <button :disabled="busy.tracks" @click="generate('tracks')">
+          {{ busy.tracks ? 'Genererar…' : '🎵 Generera låtförslag' }}
+        </button>
+      </div>
+    </div>
+
+    <div v-if="tracks.length" class="grid">
+      <MusicCard v-for="(r, i) in tracks" :key="`t-${r.mbid ?? r.name}-${i}`" :item="r" />
+    </div>
+    <div v-else class="empty small">
+      <p class="dim">
+        Inga låtförslag ännu — genereras automatiskt varje vecka utifrån dina
+        senast gillade låtar (YT Music) och mest spelade (Jellyfin), eller
+        direkt via knappen.
+      </p>
+    </div>
   </section>
 </template>
 
@@ -117,6 +152,14 @@ h2 {
   gap: 1rem;
 }
 
+.tracks-head {
+  margin-top: 2rem;
+}
+
+.empty.small {
+  padding: 2rem 1rem;
+}
+
 .empty {
   display: grid;
   place-items: center;

frontend/src/pages/SettingsPage.vue

@@ -6,6 +6,7 @@ const jellyfin = ref({ url: '', apiKey: '', userId: '' })
 const ytmusic = ref({ clientId: '', clientSecret: '' })
 const saved = ref({ gemini: {}, jellyfin: {}, ytmusic: {}, suggest: {} })
 const intervalHours = ref(24)
+const trackIntervalDays = ref(7)
 const results = ref({}) // service -> {ok, message}
 const busy = ref({})
 const jfUsers = ref([])
@@ -18,23 +19,21 @@ onMounted(async () => {
   jellyfin.value.url = saved.value.jellyfin.url
   jellyfin.value.userId = saved.value.jellyfin.userId
   intervalHours.value = saved.value.suggest?.intervalHours ?? 24
+  trackIntervalDays.value = saved.value.suggest?.trackIntervalDays ?? 7
 })
 
 async function saveInterval() {
   await fetch('/api/settings', {
     method: 'PUT',
     headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify({ suggest: { intervalHours: Number(intervalHours.value) } }),
-  })
-  results.value = {
-    ...results.value,
+    body: JSON.stringify({
       suggest: {
-      ok: true,
-      message: Number(intervalHours.value)
-        ? `sparat — nya förslag var ${intervalHours.value}:e timme`
-        : 'sparat — schemat är avstängt',
+        intervalHours: Number(intervalHours.value),
+        trackIntervalDays: Number(trackIntervalDays.value),
       },
-  }
+    }),
+  })
+  results.value = { ...results.value, suggest: { ok: true, message: 'sparat ✓' } }
 }
 
 async function saveAndTest(service) {
@@ -205,9 +204,12 @@ async function connectYtMusic() {
         Hur ofta nya Gemini-förslag hämtas automatiskt. Sätt 0 för att stänga
         av — du kan alltid klicka "Generera nya förslag" på Upptäck-sidan.
       </p>
-      <label>Intervall (timmar)
+      <label>Artist/album-förslag — intervall (timmar)
         <input v-model="intervalHours" type="number" min="0" step="1" />
       </label>
+      <label>Låtförslag ("Veckans låtar") — intervall (dagar)
+        <input v-model="trackIntervalDays" type="number" min="0" step="1" />
+      </label>
       <div class="row">
         <button @click="saveInterval">Spara</button>
         <span v-if="results.suggest" :class="results.suggest.ok ? 'ok' : 'fail'">{{ results.suggest.message }}</span>

frontend/src/pages/SuggestionsPage.vue

@@ -42,7 +42,7 @@ onMounted(load)
         @click="pick(b.id)"
       >
         <strong>#{{ b.id }}</strong> — {{ fmt(b.createdAt) }}
-        <span class="dim">{{ b.count }} förslag · {{ b.trigger }}</span>
+        <span class="dim">{{ b.type === 'tracks' ? 'låtar' : 'artister/album' }} · {{ b.count }} förslag · {{ b.trigger }}</span>
       </button>
     </aside>