feat(bot): intelligent autoplay — skip/completion signals, loved tracks, artist frequency, mood matching

packages/bot/src/handlers/player/trackHandlers.spec.ts

@@ -29,6 +29,7 @@ const infoLogMock = jest.fn()
 const debugLogMock = jest.fn()
 const errorLogMock = jest.fn()
 const warnLogMock = jest.fn()
+const recordImplicitFeedbackMock = jest.fn()
 
 jest.mock('discord-player', () => ({
     QueueRepeatMode: {
@@ -100,6 +101,18 @@ jest.mock('@lucky/shared/utils', () => ({
     warnLog: (...args: unknown[]) => warnLogMock(...args),
 }))
 
+jest.mock('../../services/musicRecommendation/feedbackService', () => ({
+    recommendationFeedbackService: {
+        recordImplicitFeedback: (...args: unknown[]) =>
+            recordImplicitFeedbackMock(...args),
+    },
+}))
+
+jest.mock('../../utils/music/searchQueryCleaner', () => ({
+    cleanTitle: (title: string) => title,
+    cleanAuthor: (author: string) => author,
+}))
+
 type PlayerEventHandler = (queue: GuildQueue, track?: Track) => Promise<void>
 
 function createTrack(requestedById = 'listener-1'): Track {
@@ -177,6 +190,7 @@ describe('trackHandlers autoplay replenishment', () => {
         updateLastFmNowPlayingMock.mockResolvedValue(undefined)
         scrobbleCurrentTrackIfLastFmMock.mockResolvedValue(undefined)
         saveSnapshotMock.mockResolvedValue(undefined)
+        recordImplicitFeedbackMock.mockResolvedValue(undefined)
     })
 
     afterEach(() => {
@@ -483,4 +497,132 @@ describe('trackHandlers autoplay replenishment', () => {
             message: 'Added "Test Song" to queue in Guild One',
         })
     })
+
+    it('records implicit like on playerFinish when track played > 80%', async () => {
+        jest.useFakeTimers()
+        const handlers = setupHandlers()
+        const playerStart = handlers.playerStart
+        const playerFinish = handlers.playerFinish
+        const queue = createQueue(QueueRepeatMode.AUTOPLAY)
+        const finishedTrack = {
+            ...createTrack('listener-finish-1'),
+            durationMS: 100000,
+        }
+
+        await playerStart(queue, finishedTrack)
+        jest.advanceTimersByTime(85000)
+        await playerFinish(queue, finishedTrack)
+
+        expect(recordImplicitFeedbackMock).toHaveBeenCalledWith(
+            'listener-finish-1',
+            'testsong::testartist',
+            'implicit_like',
+        )
+    })
+
+    it('does not record feedback on playerFinish when track played < 80%', async () => {
+        jest.useFakeTimers()
+        const handlers = setupHandlers()
+        const playerStart = handlers.playerStart
+        const playerFinish = handlers.playerFinish
+        const queue = createQueue(QueueRepeatMode.AUTOPLAY)
+        const finishedTrack = {
+            ...createTrack('listener-finish-2'),
+            durationMS: 100000,
+        }
+
+        await playerStart(queue, finishedTrack)
+        jest.advanceTimersByTime(60000)
+        await playerFinish(queue, finishedTrack)
+
+        expect(recordImplicitFeedbackMock).not.toHaveBeenCalled()
+    })
+
+    it('records implicit dislike on playerSkip when track played < 30%', async () => {
+        jest.useFakeTimers()
+        const handlers = setupHandlers()
+        const playerStart = handlers.playerStart
+        const playerSkip = handlers.playerSkip
+        const queue = createQueue(QueueRepeatMode.AUTOPLAY)
+        const skippedTrack = {
+            ...createTrack('listener-skip-1'),
+            durationMS: 100000,
+        }
+
+        await playerStart(queue, skippedTrack)
+        jest.advanceTimersByTime(20000)
+        await playerSkip(queue, skippedTrack)
+
+        expect(recordImplicitFeedbackMock).toHaveBeenCalledWith(
+            'listener-skip-1',
+            'testsong::testartist',
+            'implicit_dislike',
+        )
+    })
+
+    it('does not record feedback on playerSkip when track < 20 seconds duration', async () => {
+        jest.useFakeTimers()
+        const handlers = setupHandlers()
+        const playerStart = handlers.playerStart
+        const playerSkip = handlers.playerSkip
+        const queue = createQueue(QueueRepeatMode.AUTOPLAY)
+        const shortTrack = {
+            ...createTrack('listener-skip-2'),
+            durationMS: 10000,
+        }
+
+        await playerStart(queue, shortTrack)
+        jest.advanceTimersByTime(5000)
+        await playerSkip(queue, shortTrack)
+
+        expect(recordImplicitFeedbackMock).not.toHaveBeenCalled()
+    })
+
+    it('does not record feedback on playerSkip when track played > 30%', async () => {
+        jest.useFakeTimers()
+        const handlers = setupHandlers()
+        const playerStart = handlers.playerStart
+        const playerSkip = handlers.playerSkip
+        const queue = createQueue(QueueRepeatMode.AUTOPLAY)
+        const skippedTrack = {
+            ...createTrack('listener-skip-3'),
+            durationMS: 100000,
+        }
+
+        await playerStart(queue, skippedTrack)
+        jest.advanceTimersByTime(50000)
+        await playerSkip(queue, skippedTrack)
+
+        expect(recordImplicitFeedbackMock).not.toHaveBeenCalled()
+    })
+
+    it('records implicit like for track with metadata requestedById on playerFinish', async () => {
+        jest.useFakeTimers()
+        const handlers = setupHandlers()
+        const playerStart = handlers.playerStart
+        const playerFinish = handlers.playerFinish
+        const queue = createQueue(QueueRepeatMode.AUTOPLAY)
+        const metadataTrack = {
+            id: 'track-3',
+            title: 'Metadata Track',
+            author: 'Metadata Artist',
+            url: 'https://example.com/track-3',
+            source: 'youtube',
+            requestedBy: undefined,
+            metadata: {
+                requestedById: 'listener-finish-3',
+            },
+            durationMS: 100000,
+        } as unknown as Track
+
+        await playerStart(queue, metadataTrack)
+        jest.advanceTimersByTime(85000)
+        await playerFinish(queue, metadataTrack)
+
+        expect(recordImplicitFeedbackMock).toHaveBeenCalledWith(
+            'listener-finish-3',
+            'metadatatrack::metadataartist',
+            'implicit_like',
+        )
+    })
 })

packages/bot/src/handlers/player/trackHandlers.ts

@@ -20,11 +20,15 @@ import {
     clearIdleTimer,
 } from '../../utils/music/idleDisconnect'
 import { clearVotes } from '../../utils/music/voteSkipStore'
+import { recommendationFeedbackService } from '../../services/musicRecommendation/feedbackService'
+import { cleanTitle, cleanAuthor } from '../../utils/music/searchQueryCleaner'
 
 const MAX_GUILD_ENTRIES = 500
 
 export const lastPlayedTracks = new Map<string, Track>()
 
+const guildTrackStartTimes = new Map<string, number>()
+
 export type TrackHistoryEntry = {
     url: string
     title: string
@@ -47,6 +51,48 @@ function isAutoplayTrack(track: Track, clientUserId?: string): boolean {
     )
 }
 
+function normalizeTrackKeyForFeedback(title: string, author: string): string {
+    const normalizedTitle = cleanTitle(title)
+        .toLowerCase()
+        .replaceAll(/[^a-z0-9]+/g, '')
+        .trim()
+    const normalizedAuthor = cleanAuthor(author)
+        .toLowerCase()
+        .replaceAll(/[^a-z0-9]+/g, '')
+        .trim()
+    return `${normalizedTitle}::${normalizedAuthor}`
+}
+
+async function recordPlayBehavior(
+    guildId: string,
+    track: Track | undefined,
+    requestedById: string | undefined,
+    minDurationMs: number,
+    ratioThreshold: number,
+    feedbackType: 'implicit_like' | 'implicit_dislike',
+): Promise<void> {
+    if (!track || !requestedById) return
+    const startTime = guildTrackStartTimes.get(guildId)
+    if (!startTime || !track.durationMS || track.durationMS < minDurationMs) {
+        guildTrackStartTimes.delete(guildId)
+        return
+    }
+    const playedMs = Date.now() - startTime
+    const ratio = playedMs / track.durationMS
+    guildTrackStartTimes.delete(guildId)
+    const shouldRecord =
+        (feedbackType === 'implicit_like' && ratio > ratioThreshold) ||
+        (feedbackType === 'implicit_dislike' && ratio < ratioThreshold)
+    if (shouldRecord) {
+        const trackKey = normalizeTrackKeyForFeedback(track.title, track.author)
+        await recommendationFeedbackService.recordImplicitFeedback(
+            requestedById,
+            trackKey,
+            feedbackType,
+        )
+    }
+}
+
 function evictOldEntries(): void {
     if (lastPlayedTracks.size > MAX_GUILD_ENTRIES) {
         const oldest = lastPlayedTracks.keys().next().value
@@ -162,6 +208,7 @@ const handlePlayerStart = async (
 ): Promise<void> => {
     try {
         evictOldEntries()
+        guildTrackStartTimes.set(queue.guild.id, Date.now())
         infoLog({
             message: `Started playing "${track.title}" in ${queue.guild.name}`,
         })
@@ -216,6 +263,21 @@ const handlePlayerFinish = async (
 ): Promise<void> => {
     try {
         await scrobbleAndRecord(queue, track)
+
+        if (track) {
+            const requesterId = track.requestedBy?.id
+                ?? (track.metadata as { requestedById?: string } | undefined)
+                    ?.requestedById
+            await recordPlayBehavior(
+                queue.guild.id,
+                track,
+                requesterId,
+                0,
+                0.8,
+                'implicit_like',
+            )
+        }
+
         if (musicWatchdogService.isIntentionalStop(queue.guild.id)) return
         await replenishIfAutoplay(queue, track)
         await musicSessionSnapshotService.saveSnapshot(queue)
@@ -248,6 +310,21 @@ const handlePlayerSkip = async (
             },
         })
         await scrobbleAndRecord(queue, track)
+
+        if (track) {
+            const requesterId = track.requestedBy?.id
+                ?? (track.metadata as { requestedById?: string } | undefined)
+                    ?.requestedById
+            await recordPlayBehavior(
+                queue.guild.id,
+                track,
+                requesterId,
+                20_000,
+                0.3,
+                'implicit_dislike',
+            )
+        }
+
         if (musicWatchdogService.isIntentionalStop(queue.guild.id)) return
         await replenishIfAutoplay(queue, track)
         await musicSessionSnapshotService.saveSnapshot(queue)

packages/bot/src/lastfm/index.ts

@@ -5,6 +5,7 @@ export {
     getRecentTracks,
     getSimilarTracks,
     getTagTopTracks,
+    getLovedTracks,
     isLastFmInvalidSessionError,
     normalizeLastFmArtist,
     normalizeLastFmTitle,

packages/bot/src/lastfm/lastFmApi.spec.ts

@@ -16,6 +16,7 @@ import {
     getRecentTracks,
     getSimilarTracks,
     getTagTopTracks,
+    getLovedTracks,
 } from './lastFmApi'
 
 const getSessionKeyMock =
@@ -494,4 +495,45 @@ describe('lastFmApi', () => {
             expect(tracks).toEqual([])
         })
     })
+
+    describe('getLovedTracks', () => {
+        it('returns loved tracks array on success', async () => {
+            fetchMock.mockResolvedValueOnce({
+                ok: true,
+                json: async () => ({
+                    lovedtracks: {
+                        track: [
+                            { name: 'Loved Song', artist: { name: 'Artist A' } },
+                            { name: 'Another Fave', artist: { name: 'Artist B' } },
+                        ],
+                    },
+                }),
+            })
+
+            const result = await getLovedTracks('testuser', 10)
+
+            expect(result).toEqual([
+                { artist: 'Artist A', title: 'Loved Song' },
+                { artist: 'Artist B', title: 'Another Fave' },
+            ])
+        })
+
+        it('returns empty array on non-ok response', async () => {
+            fetchMock.mockResolvedValueOnce({ ok: false })
+            const result = await getLovedTracks('testuser')
+            expect(result).toEqual([])
+        })
+
+        it('returns empty array when lovedtracks missing', async () => {
+            fetchMock.mockResolvedValueOnce({ ok: true, json: async () => ({}) })
+            const result = await getLovedTracks('testuser')
+            expect(result).toEqual([])
+        })
+
+        it('returns empty array on fetch error', async () => {
+            fetchMock.mockRejectedValueOnce(new Error('network'))
+            const result = await getLovedTracks('testuser')
+            expect(result).toEqual([])
+        })
+    })
 })

packages/bot/src/lastfm/lastFmApi.ts

@@ -279,3 +279,30 @@ export async function getTagTopTracks(
         return []
     }
 }
+
+export async function getLovedTracks(
+    username: string,
+    limit = 50,
+): Promise<{ artist: string; title: string }[]> {
+    const config = getApiConfig()
+    if (!config) return []
+    try {
+        const response = await fetch(
+            `${API_BASE}?method=user.getlovedtracks&user=${encodeURIComponent(username)}&limit=${limit}&format=json&api_key=${config.apiKey}`,
+        )
+        const data = (await response.json()) as {
+            lovedtracks?: {
+                track?: Array<{
+                    name: string
+                    artist: { name: string }
+                }>
+            }
+        }
+        return (data.lovedtracks?.track ?? []).map((t) => ({
+            artist: t.artist.name,
+            title: t.name,
+        }))
+    } catch {
+        return []
+    }
+}