@doitian/dsh-music 0.1.4 → 0.1.5

package/lib/index.js

@@ -187,6 +187,14 @@ export function apply(ctx, config = {}) {
     },
   });
   player.onLowQueue = () => dj.topUp();
+  player.onSkip = (track) => {
+    // The panel's ✕ records the dislike and then presses next, so an early
+    // dislike would also count as a skip — but only inside the skip window,
+    // which would make the same judgement weigh differently by when it came.
+    if (store.taste(track.id) === 'disliked') return;
+    store.recordSkip(track.id);
+    logger.debug(`[music] skip recorded for ${track.id}`);
+  };
 
   /** Tool names that registered successfully; surfaced by `/music/health`. */
   const registeredTools = [];
@@ -503,8 +511,8 @@ export function apply(ctx, config = {}) {
       title: 'AI DJ (NetEase Cloud Music)',
       description:
         'Run or configure the continuous AI DJ for the user\'s NetEase Cloud Music panel. ' +
-        'With `enabled: true` the DJ keeps the queue stocked: it gathers candidates from similar songs, the daily ' +
-        'recommendations, the charts and any mood brief, then either asks the model to choose or scores them by the ' +
+        'With `enabled: true` the DJ keeps the queue stocked: it gathers candidates from similar songs, personal FM, ' +
+        'liked songs not heard lately, the daily recommendations, the charts and any mood brief, then either asks the model to choose or scores them by the ' +
         'listener\'s liked artists, novelty and feedback. Pass `prompt` for a mood or vibe, and `replan` to refill now.',
       parameters: {
         type: 'object',
@@ -513,7 +521,10 @@ export function apply(ctx, config = {}) {
           enabled: { type: 'boolean', description: 'Turn continuous queue topping-up on or off.' },
           prompt: { type: 'string', description: 'Mood or request, e.g. "rainy afternoon jazz", "90s cantopop".' },
           replan: { type: 'boolean', description: 'Plan and queue a fresh batch immediately.' },
-          count: { type: 'integer', description: 'How many tracks to plan (1-25, default 8 for `replan`).' },
+          count: {
+            type: 'integer',
+            description: 'How many tracks to plan (1-25; default 8 for `start`, the player\'s batch size for `replan`).',
+          },
           start: { type: 'boolean', description: 'Replace the queue with a freshly planned batch (a full DJ session).' },
         },
       },
@@ -524,6 +535,7 @@ export function apply(ctx, config = {}) {
             `AI DJ is ${value.enabled ? 'on' : 'off'} (${value.source}${value.route ? ` via ${value.route}` : ''}). ` +
             (value.modelError ? `Model tier unavailable: ${value.modelError}. ` : '') +
             (value.vibe ? `Vibe: ${value.vibe}. ` : '') +
+            (value.searchedAs.length ? `Brief searched as: ${value.searchedAs.join('; ')}. ` : '') +
             (value.names.length
               ? `Queued ${value.added} track(s):\n${value.names.map((entry, index) => `${index + 1}. ${entry}`).join('\n')}`
               : value.note || 'No new tracks were queued.') +
@@ -540,7 +552,7 @@ export function apply(ctx, config = {}) {
         if (args.start) {
           plan = await dj.start({ prompt, count });
         } else if (args.replan || (enabled === true && player.queue.length === 0)) {
-          plan = await dj.topUp({ force: true });
+          plan = await dj.topUp({ force: true, count: args.count === undefined ? undefined : count });
         }
 
         const summary = player.summary();
@@ -550,6 +562,7 @@ export function apply(ctx, config = {}) {
           route: plan?.route ?? summary.dj.lastPlan?.route ?? null,
           modelError: player.dj.modelError ?? null,
           vibe: plan?.vibe ?? summary.dj.lastPlan?.vibe ?? '',
+          searchedAs: plan?.searchedAs ?? summary.dj.lastPlan?.searchedAs ?? [],
           note: plan?.note ?? (plan && plan.tracks.length === 0 ? 'no candidates were available' : ''),
           added: plan?.tracks.length ?? 0,
           names: (plan?.tracks ?? []).map((track) => `${track.name} — ${(track.artists ?? []).join('/')}`),

package/lib/netease.js

@@ -372,6 +372,21 @@ export class Netease {
     return data?.result ?? {};
   }
 
+  /**
+   * Playlists matching a keyword. Listeners name and tag playlists by mood
+   * (雨天, 爵士, 深夜…), so this is how a mood finds music, where a song search
+   * only matches titles and lyrics.
+   */
+  async searchPlaylists(keyword, { limit = 10 } = {}) {
+    const result = await this.search(keyword, { type: 1000, limit });
+    return (result.playlists ?? []).map((item) => ({
+      id: item.id,
+      name: item.name,
+      trackCount: item.trackCount ?? 0,
+      playCount: item.playCount ?? 0,
+    }));
+  }
+
   /** Track metadata, including cover art and the VIP fee code. */
   async songDetail(ids) {
     const list = [...ids].map(Number).filter(Number.isFinite);
@@ -476,6 +491,12 @@ export class Netease {
       playCount: playlist.playCount ?? 0,
       creator: playlist.creator?.nickname ?? '',
       tracks: normalizeTracks(playlist.tracks),
+      /**
+       * Every track id, in order. For a playlist the account does not own,
+       * `tracks` stops at the first 20 while this list is complete, so it is
+       * the only way to reach the rest.
+       */
+      trackIds: (playlist.trackIds ?? []).map((entry) => entry.id).filter(Number.isFinite),
     };
   }
 
@@ -524,6 +545,18 @@ export class Netease {
     return normalizeTracks(result?.dailySongs ?? result?.recommend);
   }
 
+  /**
+   * 私人FM (personal FM): a few tracks NetEase picks for this account, a
+   * different few on every call. Requires a session.
+   *
+   * This is the personalised feed the plain API still serves; heartbeat mode
+   * ({@link intelligenceList}) answers `code 500` there for every seed.
+   */
+  async personalFm() {
+    const data = await this.call('/api/v1/radio/get');
+    return normalizeTracks(data?.data);
+  }
+
   /**
    * 心动模式 (heartbeat mode): a personalised continuation of a seed track
    * inside a playlist context. Requires a session.

package/lib/session.js

@@ -196,10 +196,11 @@ export class SessionStore {
     return this.state.history.slice(0, limit).map((entry) => entry.id);
   }
 
-  /** Most-played artists, most frequent first. */
+  /** Most-played artists, most frequent first. A skipped play is not a play. */
   topArtists(limit = 8) {
     const counts = new Map();
     for (const entry of this.state.history.slice(0, 150)) {
+      if (entry.skipped) continue;
       for (const artist of entry.artists) counts.set(artist, (counts.get(artist) ?? 0) + 1);
     }
     return [...counts.entries()]
@@ -272,19 +273,34 @@ export class SessionStore {
   recordFeedback(kind, trackId) {
     const id = Number(trackId);
     if (!Number.isFinite(id)) return this.state.feedback;
-    if (kind === 'skips') {
-      // Skips are counters, not membership: keep the newest occurrence.
-      const skips = this.state.feedback.skips;
-      skips.unshift(id);
-      if (skips.length > MAX_FEEDBACK) skips.length = MAX_FEEDBACK;
-      this.touch();
-      return this.state.feedback;
-    }
+    if (kind === 'skips') return this.recordSkip(id);
     const level = kind === 'likes' ? 'liked' : kind === 'dislikes' ? 'disliked' : null;
     if (!level) return this.state.feedback;
     return this.setTaste(id, this.taste(id) === level ? 'none' : level);
   }
 
+  /**
+   * Count a skip: the listener moved past the track early.
+   *
+   * Skips are counters, not membership, so each one is kept as an occurrence.
+   * The play it cut short is marked as well, because the history is what the
+   * DJ reads artist affinity from, and a track abandoned after ten seconds
+   * would otherwise count as one more play of that artist.
+   *
+   * @param {number|string} trackId
+   */
+  recordSkip(trackId) {
+    const id = Number(trackId);
+    if (!Number.isFinite(id)) return this.state.feedback;
+    const skips = this.state.feedback.skips;
+    skips.unshift(id);
+    if (skips.length > MAX_FEEDBACK) skips.length = MAX_FEEDBACK;
+    const play = this.state.history.find((entry) => entry.id === id);
+    if (play) play.skipped = true;
+    this.touch();
+    return this.state.feedback;
+  }
+
   get feedback() {
     return this.state.feedback;
   }
@@ -297,13 +313,26 @@ export class SessionStore {
     const name = (entry) =>
       typeof entry === 'object' ? `${entry.name} — ${(entry.artists ?? []).join('/')}` : `#${entry}`;
     const byId = new Map(this.state.history.map((entry) => [entry.id, entry]));
+    const skipCounts = new Map();
+    for (const id of this.state.feedback.skips) skipCounts.set(id, (skipCounts.get(id) ?? 0) + 1);
+    const skippedArtists = new Map();
+    for (const entry of this.state.history.slice(0, 150)) {
+      if (!entry.skipped) continue;
+      for (const artist of entry.artists ?? []) skippedArtists.set(artist, (skippedArtists.get(artist) ?? 0) + 1);
+    }
     return {
       recentlyPlayed: this.state.history.slice(0, history).map(name),
       topArtists: this.topArtists(8),
       liked: this.state.feedback.likes.slice(0, 15).map((id) => byId.get(id)).filter(Boolean).map(name),
       disliked: this.state.feedback.dislikes.slice(0, 15).map((id) => byId.get(id)).filter(Boolean).map(name),
+      // Newest first, one line per track however often it was skipped.
+      skipped: [...skipCounts.keys()].slice(0, 15).map((id) => byId.get(id)).filter(Boolean).map(name),
       dislikedIds: this.state.feedback.dislikes.slice(0, 80),
       recentIds: this.recentIds(60),
+      /** Track id → how many times it was skipped. */
+      skipCounts,
+      /** Artist → skipped plays among the recent history. */
+      skippedArtists,
     };
   }
 }

package/lib/state.js

@@ -25,6 +25,14 @@ export const MODES = ['list', 'single', 'shuffle'];
 /** A pending seek is delivered once and then cleared. */
 const SEEK_EPSILON_MS = 1_000;
 
+/**
+ * A manual "next" before this much of a track has played is a skip: the
+ * listener rejected the track rather than finished with it. The window is 30 s,
+ * or a quarter of the track when that is longer.
+ */
+const SKIP_WINDOW_MS = 30_000;
+const SKIP_WINDOW_FRACTION = 0.25;
+
 export class Player {
   /**
    * @param {object} [options]
@@ -69,6 +77,11 @@ export class Player {
      * @type {(() => Promise<void>) | undefined}
      */
     this.onLowQueue = undefined;
+    /**
+     * Called with a track the listener moved past early, for the taste record.
+     * @type {((track: object) => void) | undefined}
+     */
+    this.onSkip = undefined;
   }
 
   /** Subscribe to state changes. @returns {() => void} unsubscribe */
@@ -220,15 +233,42 @@ export class Player {
    */
   move(step, { auto = false } = {}) {
     if (this.queue.length === 0) return this.snapshot();
+    const left = this.current();
+    const skipped = !auto && step > 0 && this.#heardBriefly();
     this.index = this.#nextIndex(step);
     this.pendingSeek = 0;
     this.playing = true;
     this.reported = { ...this.reported, position: 0, duration: 0, error: null, at: Date.now() };
     this.bump({ transport: true });
+    if (skipped && this.current() !== left) this.#notifySkip(left);
     if (auto) this.#maybeExtend();
     return this.snapshot();
   }
 
+  /**
+   * Whether the current track was heard, but only briefly.
+   *
+   * Only a reported position counts: a track the panel never started (paused,
+   * blocked by autoplay, still loading) was not listened to, so moving past it
+   * says nothing about it.
+   */
+  #heardBriefly() {
+    const current = this.current();
+    if (!current || this.reported.trackId !== current.id) return false;
+    const position = Number(this.reported.position) || 0;
+    if (position <= 0) return false;
+    const duration = Number(this.reported.duration) || Number(current.duration) || 0;
+    return position < Math.max(SKIP_WINDOW_MS, duration * SKIP_WINDOW_FRACTION);
+  }
+
+  #notifySkip(track) {
+    try {
+      this.onSkip?.(track);
+    } catch (error) {
+      this.logger?.warn?.(`[music] skip listener failed: ${error.message}`);
+    }
+  }
+
   /** Jump to an explicit queue position. */
   jump(index) {
     if (index < 0 || index >= this.queue.length) return this.snapshot();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@doitian/dsh-music",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "description": "NetEase Cloud Music (music.163.com) player and AI DJ for DeepSeek Harness: a sidebar page with in-app playback, QR sign-in, and agent tools that curate the queue.",
   "keywords": [
     "dsh",
@@ -39,6 +39,7 @@
     "lib/session.js",
     "lib/state.js",
     "lib/dj.js",
+    "lib/cache.js",
     "lib/likes.js",
     "lib/router.js",
     "lib/panel.html",
@@ -54,8 +55,8 @@
     "access": "public"
   },
   "scripts": {
-    "check": "node --check lib/index.js && node --check lib/client.js && node --check lib/netease.js && node --check lib/session.js && node --check lib/state.js && node --check lib/dj.js && node --check lib/likes.js && node --check lib/router.js",
-    "test": "node test/netease.test.mjs && node test/likes.test.mjs && node test/dj.test.mjs && node test/client.test.mjs",
+    "check": "node --check lib/index.js && node --check lib/client.js && node --check lib/netease.js && node --check lib/session.js && node --check lib/state.js && node --check lib/dj.js && node --check lib/cache.js && node --check lib/likes.js && node --check lib/router.js",
+    "test": "node test/netease.test.mjs && node test/cache.test.mjs && node test/likes.test.mjs && node test/dj.test.mjs && node test/client.test.mjs",
     "probe:headers": "node scripts/probe-headers.mjs",
     "test:live": "node test/host.test.mjs",
     "test:all": "npm test && npm run test:live"