@linxin666/dsh-pet 0.3.4 → 0.3.5

package/lib/types/voice-pack.js

@@ -27,7 +27,7 @@
  * TypeScript mode: keep it erasable-syntax-only.
  * @module @linxin666/dsh-pet/voice-pack
  */
-import { STATUS_SCENES, TOOL_CATEGORIES, } from "./chatter.js";
+import { STATUS_SCENES, TOOL_CATEGORIES, WHISPER_CATEGORIES, WHISPER_RESULTS, } from "./chatter.js";
 /** Schema version this module normalizes (optional field; missing = 1). */
 export const VOICE_PACK_V1 = 1;
 /** Hover-panel action buttons a pack can show or hide (canonical order). */
@@ -39,9 +39,6 @@ export const PANEL_STAT_KEYS = ['rank', 'treats', 'points'];
 /** Hard caps shared by every pool slot (mirrors the remarks discipline). */
 export const VOICE_POOL_LINES_MAX = 64;
 export const VOICE_LINE_MAX = 160;
-export const VOICE_KEYWORDS_PER_RULE_MAX = 16;
-export const VOICE_KEYWORD_MAX = 40;
-export const VOICE_RULES_MAX = 32;
 export const VOICE_LABEL_MAX = 40;
 export const VOICE_STAT_MAX = 80;
 /** Any '{token}' placeholder (no nesting, no newlines). */
@@ -112,51 +109,45 @@ export function normalizePool(raw, kind, onWarning = () => { }) {
     }
     return pool;
 }
-/** Normalize the ordered keyword-rule list ([] disables the keyword channel). */
-export function normalizeWhisperRules(raw, onWarning = () => { }) {
+/** Normalize whisper category pools; a key replaces that category's built-in pool (an explicit empty pool mutes it). */
+export function normalizeWhisperCategories(raw, onWarning = () => { }) {
     if (raw === undefined)
         return undefined;
-    if (!Array.isArray(raw)) {
-        onWarning('whispers.rules must be an array');
+    if (!isRecord(raw)) {
+        onWarning('whispers.categories must be an object');
         return undefined;
     }
-    if (raw.length > VOICE_RULES_MAX) {
-        onWarning('whispers.rules has more than ' + VOICE_RULES_MAX + ' rules; extra rules are ignored');
-    }
-    const rules = [];
-    for (const item of raw.slice(0, VOICE_RULES_MAX)) {
-        if (!isRecord(item)) {
-            onWarning('whisper rule must be an object');
+    const pools = {};
+    for (const key of Object.keys(raw)) {
+        if (!WHISPER_CATEGORIES.includes(key)) {
+            onWarning('unknown whisper category ' + key + ' ignored');
             continue;
         }
-        for (const key of Object.keys(item)) {
-            if (key !== 'keywords' && key !== 'pool')
-                onWarning('unknown whisper rule field ' + key + ' ignored');
-        }
-        const keywordsRaw = item.keywords;
-        const keywords = [];
-        if (Array.isArray(keywordsRaw)) {
-            for (const entry of keywordsRaw.slice(0, VOICE_KEYWORDS_PER_RULE_MAX)) {
-                if (typeof entry !== 'string') {
-                    onWarning('non-string keyword dropped');
-                    continue;
-                }
-                const trimmed = entry.trim().toLowerCase().slice(0, VOICE_KEYWORD_MAX);
-                if (trimmed !== '')
-                    keywords.push(trimmed);
-            }
-            if (keywordsRaw.length > VOICE_KEYWORDS_PER_RULE_MAX) {
-                onWarning('rule has more than ' + VOICE_KEYWORDS_PER_RULE_MAX + ' keywords; extra keywords are ignored');
-            }
-        }
-        const pool = normalizePool(item.pool, 'whisperRule', onWarning);
-        if (keywords.length === 0 || pool === undefined || pool.length === 0) {
-            onWarning('whisper rule dropped (needs keywords and a non-empty pool)');
+        const pool = normalizePool(raw[key], 'whisperCategory', onWarning);
+        if (pool !== undefined)
+            pools[key] = pool;
+    }
+    return Object.keys(pools).length > 0 ? pools : undefined;
+}
+/** Normalize whisper outcome pools; a key replaces that outcome's built-in pool (an explicit empty pool mutes it). */
+export function normalizeWhisperResults(raw, onWarning = () => { }) {
+    if (raw === undefined)
+        return undefined;
+    if (!isRecord(raw)) {
+        onWarning('whispers.results must be an object');
+        return undefined;
+    }
+    const pools = {};
+    for (const key of Object.keys(raw)) {
+        if (!WHISPER_RESULTS.includes(key)) {
+            onWarning('unknown whisper result ' + key + ' ignored');
             continue;
         }
-        rules.push({ keywords, pool });
+        const pool = normalizePool(raw[key], 'whisperResult', onWarning);
+        if (pool !== undefined)
+            pools[key] = pool;
     }
-    return rules;
+    return Object.keys(pools).length > 0 ? pools : undefined;
 }
 /** Normalize the panel block (labels / stats / actions; warn-and-drop). */
 export function normalizePanel(raw, onWarning = () => { }) {
@@ -236,7 +227,7 @@ export function normalizePanel(raw, onWarning = () => { }) {
 /** Voice-pack top-level fields ('$schema' mirrors the schema twin; drift-locked in tests). */
 export const VOICE_PACK_KEYS = new Set(['$schema', 'voicePackVersion', 'status', 'tools', 'toolRemaining', 'whispers', 'panel']);
 /** Allowed whisper-section fields (drift-locked in tests). */
-export const WHISPER_KEYS = new Set(['generic', 'rules']);
+export const WHISPER_KEYS = new Set(['categories', 'results']);
 /**
  * Normalize one raw voice.json document into a VoicePack, or undefined when
  * the file cannot serve as a pack at all (non-object root — structure is
@@ -307,15 +298,21 @@ export function normalizeVoicePack(raw, onWarning = () => { }) {
         }
         else {
             for (const key of Object.keys(whispersRaw)) {
-                if (!WHISPER_KEYS.has(key))
+                if (key === 'generic' || key === 'rules') {
+                    // pet M6: keyword and ambient whisper channels are gone; legacy
+                    // fields are ignored with a warning, never mapped to the new shape.
+                    onWarning('whispers.' + key + ' is no longer supported and was ignored');
+                }
+                else if (!WHISPER_KEYS.has(key)) {
                     onWarning('unknown whispers field ' + key + ' ignored');
+                }
             }
-            const generic = normalizePool(whispersRaw.generic, 'whisperGeneric', onWarning);
-            const rules = normalizeWhisperRules(whispersRaw.rules, onWarning);
-            if (generic !== undefined || rules !== undefined) {
+            const categories = normalizeWhisperCategories(whispersRaw.categories, onWarning);
+            const results = normalizeWhisperResults(whispersRaw.results, onWarning);
+            if (categories !== undefined || results !== undefined) {
                 overrides.whispers = {
-                    ...(generic === undefined ? {} : { generic }),
-                    ...(rules === undefined ? {} : { rules }),
+                    ...(categories === undefined ? {} : { categories }),
+                    ...(results === undefined ? {} : { results }),
                 };
             }
         }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@linxin666/dsh-pet",
   "description": "Multi-pet companion plugin for the dsh web GUI: a registry-driven floating pet that reacts to model activity, with per-pet naming, petting/feeding interactions and an affinity score",
-  "version": "0.3.4",
+  "version": "0.3.5",
   "type": "module",
   "engines": {
     "node": "^22.19.0 || >=24.0.0"

package/src/chatter.test.ts

@@ -11,8 +11,9 @@ import {
   TOOL_POOLS,
   toolArgHint,
   toolCategory,
-  WHISPER_GENERIC_POOL,
-  WHISPER_RULES,
+  WHISPER_CATEGORY_POOLS,
+  WHISPER_RESULT_POOLS,
+  looksLikeTestTool,
   WhisperEngine,
   type VoicePackOverrides,
 } from './chatter.ts'
@@ -127,30 +128,65 @@ describe('toolArgHint', () => {
 })
 
 describe('WhisperEngine', () => {
-  it('wakes a themed whisper from a keyword in the model output', () => {
+  it('speaks a category line for the current situation, then respects the cooldown', () => {
     const engine = new WhisperEngine()
-    expect(engine.feed('这里有个错误需要处理', 0)).toBe(WHISPER_RULES[1]!.pool[0])
+    expect(engine.feed('thinking', 0)).toBe(WHISPER_CATEGORY_POOLS.thinking[0])
+    expect(engine.feed('writing', 1)).toBeUndefined()
   })
 
-  it('suppresses whispers during the cooldown, then rotates the pool', () => {
+  it('rotates within each category and keeps the category cursors apart', () => {
     const engine = new WhisperEngine()
-    expect(engine.feed('出现一个错误', 0)).toBe(WHISPER_RULES[1]!.pool[0])
-    expect(engine.feed('又一个错误', 1000)).toBeUndefined()
-    expect(engine.feed('还有一个错误', 9000)).toBe(WHISPER_RULES[1]!.pool[1])
+    expect(engine.feed('thinking', 0)).toBe(WHISPER_CATEGORY_POOLS.thinking[0])
+    expect(engine.feed('writing', 9001)).toBe(WHISPER_CATEGORY_POOLS.writing[0])
+    expect(engine.feed('thinking', 18002)).toBe(WHISPER_CATEGORY_POOLS.thinking[1])
   })
 
-  it('earns an ambient whisper from output volume alone', () => {
-    const engine = new WhisperEngine(undefined, 0, 10)
-    expect(engine.feed('aaaaaaaa', 0)).toBeUndefined()
-    expect(engine.feed('bbbb', 1)).toBe(WHISPER_GENERIC_POOL[0])
-    // The counter resets after speaking: another budget must accumulate.
-    expect(engine.feed('cccc', 2)).toBeUndefined()
-    expect(engine.feed('dddddddddd', 3)).toBe(WHISPER_GENERIC_POOL[1])
+  it('stays quiet on an explicitly muted category', () => {
+    const engine = new WhisperEngine(() => ({ whispers: { categories: { thinking: [] } } }))
+    expect(engine.feed('thinking', 0)).toBeUndefined()
   })
 
-  it('ignores empty chunks', () => {
-    const engine = new WhisperEngine(undefined, 0, 0)
-    expect(engine.feed('', 0)).toBeUndefined()
+  it('wakes outcome whispers on their own shorter cooldown and rotates per outcome', () => {
+    const engine = new WhisperEngine()
+    expect(engine.result('pass', 0)).toBe(WHISPER_RESULT_POOLS.pass[0])
+    expect(engine.result('fail', 1000)).toBeUndefined()
+    expect(engine.result('fail', 5001)).toBe(WHISPER_RESULT_POOLS.fail[0])
+    expect(engine.result('pass', 10002)).toBe(WHISPER_RESULT_POOLS.pass[1])
+  })
+
+  it('paces category and outcome whispers against one shared clock', () => {
+    const engine = new WhisperEngine()
+    expect(engine.feed('writing', 0)).toBe(WHISPER_CATEGORY_POOLS.writing[0])
+    // An outcome right after a category reply must wait the outcome cooldown.
+    expect(engine.result('done', 4999)).toBeUndefined()
+    expect(engine.result('done', 5000)).toBe(WHISPER_RESULT_POOLS.done[0])
+    // After an outcome, the category must wait the full category cooldown
+    // measured from the outcome whisper (5000), so 14000 is the next slot.
+    expect(engine.feed('thinking', 5001)).toBeUndefined()
+    expect(engine.feed('thinking', 14000)).toBe(WHISPER_CATEGORY_POOLS.thinking[0])
+  })
+
+  it('mutes an outcome with an explicit empty pool', () => {
+    const engine = new WhisperEngine(() => ({ whispers: { results: { fail: [] } } }))
+    expect(engine.result('fail', 0)).toBeUndefined()
+  })
+})
+
+describe('looksLikeTestTool', () => {
+  it('recognizes test tools by name and by shell command', () => {
+    expect(looksLikeTestTool('run_tests', undefined)).toBe(true)
+    expect(looksLikeTestTool('run_code', '{"command":"npm test"}')).toBe(true)
+    expect(looksLikeTestTool('run_code', '{"command":"pnpm run test -- --run"}')).toBe(true)
+    expect(looksLikeTestTool('bash', '{"command":"pytest -q"}')).toBe(true)
+    expect(looksLikeTestTool('bash', '{"command":"go test ./..."}')).toBe(true)
+    expect(looksLikeTestTool('run_code', '{"code":"import pytest"}')).toBe(true)
+  })
+
+  it('does not misfire on ordinary tools or mentions in generic code', () => {
+    expect(looksLikeTestTool('bash', '{"command":"node server.js"}')).toBe(false)
+    expect(looksLikeTestTool('grep', '{"pattern":"test"}')).toBe(false)
+    expect(looksLikeTestTool('read', '{"file_path":"/repo/test/fixture.txt"}')).toBe(false)
+    expect(looksLikeTestTool('run_code', '{"code":"server.listen(8080)"}')).toBe(false)
   })
 })
 
@@ -165,8 +201,8 @@ describe('voice-pack overrides (pet-center M4)', () => {
     },
     toolRemaining: ['后台还有 {n} 个'],
     whispers: {
-      generic: ['自定义碎碎念 A', '自定义碎碎念 B'],
-      rules: [{ keywords: ['测试通过'], pool: ['自定义全绿'] }],
+      categories: { thinking: ['自定义思考', '自定义思考二'] },
+      results: { pass: ['自定义全绿'] },
     },
   })
 
@@ -214,28 +250,22 @@ describe('voice-pack overrides (pet-center M4)', () => {
     expect(voice.scene('done', 5000)).toBe('换声了')
   })
 
-  it('replaces the whisper rules as a whole', () => {
+  it('replaces whisper category pools per key', () => {
     const engine = new WhisperEngine(PACK)
-    expect(engine.feed('这里有一个错误', 0)).toBeUndefined()
-    // The built-in error rule is gone; only the pack's rule fires.
-    expect(engine.feed('测试通过', 1000)).toBe('自定义全绿')
+    expect(engine.feed('thinking', 0)).toBe('自定义思考')
+    expect(engine.feed('writing', 9000)).toBe(WHISPER_CATEGORY_POOLS.writing[0])
+    expect(engine.feed('thinking', 18000)).toBe('自定义思考二')
   })
 
-  it('replaces the ambient generic pool', () => {
-    const engine = new WhisperEngine(PACK, 0, 3)
-    expect(engine.feed('aaaa', 0)).toBe('自定义碎碎念 A')
-    expect(engine.feed('bbbb', 1)).toBe('自定义碎碎念 B')
-  })
-
-  it('mutes ambient whispers when the generic pool is explicitly empty', () => {
-    const engine = new WhisperEngine(() => ({ whispers: { generic: [] } }), 0, 3)
-    expect(engine.feed('aaaa', 0)).toBeUndefined()
-    expect(engine.feed('bbbb', 1)).toBeUndefined()
+  it('replaces whisper outcome pools per key', () => {
+    const engine = new WhisperEngine(PACK)
+    expect(engine.result('pass', 0)).toBe('自定义全绿')
+    expect(engine.result('fail', 5001)).toBe(WHISPER_RESULT_POOLS.fail[0])
   })
 
-  it('disables keyword rules when the rules array is explicitly empty', () => {
-    const engine = new WhisperEngine(() => ({ whispers: { rules: [] } }), 0, 3)
-    // No keyword rule matches anymore; volume still earns a built-in ambient.
-    expect(engine.feed('测试通过', 0)).toBe(WHISPER_GENERIC_POOL[0])
+  it('mutes a whisper channel with an explicit empty override', () => {
+    const engine = new WhisperEngine(() => ({ whispers: { categories: { thinking: [] }, results: { done: [] } } }))
+    expect(engine.feed('thinking', 0)).toBeUndefined()
+    expect(engine.result('done', 0)).toBeUndefined()
   })
 })