@linxin666/dsh-pet 0.3.4 → 0.3.5

package/src/voice-pack.test.ts

@@ -12,7 +12,8 @@ import {
   normalizePanel,
   normalizePool,
   normalizeVoicePack,
-  normalizeWhisperRules,
+  normalizeWhisperCategories,
+  normalizeWhisperResults,
   PANEL_ACTIONS,
   PANEL_LABEL_KEYS,
   PANEL_STAT_KEYS,
@@ -21,7 +22,7 @@ import {
   VOICE_PACK_V1,
   WHISPER_KEYS,
 } from './voice-pack.ts'
-import { STATUS_SCENES, TOOL_CATEGORIES } from './chatter.ts'
+import { STATUS_SCENES, TOOL_CATEGORIES, WHISPER_CATEGORIES, WHISPER_RESULTS } from './chatter.ts'
 import { petPackageRoot } from './registry.ts'
 
 function collectWarnings(pack: unknown): { pack: ReturnType<typeof normalizeVoicePack>; warnings: string[] } {
@@ -85,31 +86,40 @@ describe('normalizePool', () => {
   })
 
   it('preserves an explicit empty array (mute semantics) but not absent', () => {
-    expect(normalizePool([], 'whisperGeneric')).toEqual([])
-    expect(normalizePool(undefined, 'whisperGeneric')).toBeUndefined()
+    expect(normalizePool([], 'whisperCategory')).toEqual([])
+    expect(normalizePool(undefined, 'whisperCategory')).toBeUndefined()
   })
 })
 
-describe('normalizeWhisperRules', () => {
-  it('lowercases and trims keywords, drops unusable rules', () => {
+describe('normalizeWhisperCategories', () => {
+  it('keeps known categories, keeps an explicit empty pool (mute) and warns on unknown keys', () => {
     const warnings: string[] = []
-    const rules = normalizeWhisperRules([
-      { keywords: ['  测试通过  ', 7], pool: ['全绿'] },
-      { keywords: [], pool: ['没有关键词'] },
-      { keywords: ['有词'], pool: [] },
-    ], m => warnings.push(m))
-    expect(rules).toEqual([{ keywords: ['测试通过'], pool: ['全绿'] }])
-    expect(warnings.length).toBeGreaterThan(0)
+    const pools = normalizeWhisperCategories({ thinking: ['自定义思考'], running: [], bogus: ['x'] }, m => warnings.push(m))
+    expect(pools).toEqual({ thinking: ['自定义思考'], running: [] })
+    expect(warnings.join('\n')).toContain('unknown whisper category')
   })
 
-  it('caps the rule count and keyword count', () => {
-    const many = Array.from({ length: 40 }, (_, i) => ({ keywords: ['k' + i], pool: ['p'] }))
-    expect(normalizeWhisperRules(many)).toHaveLength(32)
-    expect(normalizeWhisperRules([{ keywords: Array.from({ length: 20 }, (_, i) => 'k' + i), pool: ['p'] }])![0]!.keywords).toHaveLength(16)
+  it('returns undefined for an absent or non-object section', () => {
+    expect(normalizeWhisperCategories(undefined)).toBeUndefined()
+    const warnings: string[] = []
+    expect(normalizeWhisperCategories(['x'], m => warnings.push(m))).toBeUndefined()
+    expect(warnings.join('\n')).toContain('must be an object')
+  })
+})
+
+describe('normalizeWhisperResults', () => {
+  it('keeps known outcomes, keeps an explicit empty pool (mute) and warns on unknown keys', () => {
+    const warnings: string[] = []
+    const pools = normalizeWhisperResults({ pass: ['自定义全绿'], done: [], bogus: ['x'] }, m => warnings.push(m))
+    expect(pools).toEqual({ pass: ['自定义全绿'], done: [] })
+    expect(warnings.join('\n')).toContain('unknown whisper result')
   })
 
-  it('returns an explicit empty array (disables the keyword channel)', () => {
-    expect(normalizeWhisperRules([])).toEqual([])
+  it('returns undefined for an absent or non-object section', () => {
+    expect(normalizeWhisperResults(undefined)).toBeUndefined()
+    const warnings: string[] = []
+    expect(normalizeWhisperResults('x', m => warnings.push(m))).toBeUndefined()
+    expect(warnings.join('\n')).toContain('must be an object')
   })
 })
 
@@ -153,12 +163,22 @@ describe('mergeVoicePacks', () => {
     expect(merged?.panel?.labels).toEqual({ feed: '宠物投喂', hide: '宠物藏' })
   })
 
-  it('lets the pet pack replace whisper sections while the global stays', () => {
-    const global = normalizeVoicePack({ whispers: { generic: ['全局碎碎念'] } })
-    const pet = normalizeVoicePack({ whispers: { rules: [{ keywords: ['测试'], pool: ['宠物全绿'] }] } })
+  it('lets the pet pack replace whisper keys while the global stays', () => {
+    const global = normalizeVoicePack({ whispers: { categories: { thinking: ['全局思考'] }, results: { pass: ['全局全绿'] } } })
+    const pet = normalizeVoicePack({ whispers: { categories: { thinking: ['宠物思考'] } } })
     const merged = mergeVoicePacks(global, pet)
-    expect(merged?.overrides.whispers?.generic).toEqual(['全局碎碎念'])
-    expect(merged?.overrides.whispers?.rules).toEqual([{ keywords: ['测试'], pool: ['宠物全绿'] }])
+    expect(merged?.overrides.whispers?.categories?.thinking).toEqual(['宠物思考'])
+    expect(merged?.overrides.whispers?.results?.pass).toEqual(['全局全绿'])
+  })
+
+  it('warns and ignores the legacy generic / rules whisper fields', () => {
+    const { pack, warnings } = collectWarnings({
+      whispers: { generic: ['老环境池'], rules: [{ keywords: ['测试'], pool: ['老全绿'] }], categories: { thinking: ['新思考'] } },
+    })
+    expect(pack?.overrides.whispers?.categories?.thinking).toEqual(['新思考'])
+    expect(pack?.overrides.whispers?.categories?.generic).toBeUndefined()
+    expect(warnings.join('\n')).toContain('generic')
+    expect(warnings.join('\n')).toContain('rules')
   })
 
   it('returns undefined when every layer is empty', () => {
@@ -200,7 +220,10 @@ describe('voice-pack schema file drift lock', () => {
     const props = schema.properties
     expect(new Set(Object.keys(props.status?.properties ?? {}))).toEqual(new Set(STATUS_SCENES))
     expect(new Set(Object.keys(props.tools?.properties ?? {}))).toEqual(new Set(TOOL_CATEGORIES))
-    expect(new Set(Object.keys(props.whispers?.properties ?? {}))).toEqual(WHISPER_KEYS)
+    const whispers = props.whispers?.properties ?? {}
+    expect(new Set(Object.keys(whispers))).toEqual(WHISPER_KEYS)
+    expect(new Set(Object.keys((whispers.categories as { properties?: Record<string, unknown> })?.properties ?? {}))).toEqual(new Set(WHISPER_CATEGORIES))
+    expect(new Set(Object.keys((whispers.results as { properties?: Record<string, unknown> })?.properties ?? {}))).toEqual(new Set(WHISPER_RESULTS))
     const panel = props.panel?.properties ?? {}
     const labels = (panel.labels as { properties?: Record<string, unknown> } | undefined)?.properties ?? {}
     const stats = (panel.stats as { properties?: Record<string, unknown> } | undefined)?.properties ?? {}

package/src/voice-pack.ts

@@ -31,8 +31,11 @@
 import {
   STATUS_SCENES,
   TOOL_CATEGORIES,
+  WHISPER_CATEGORIES,
+  WHISPER_RESULTS,
   type VoicePackOverrides,
-  type WhisperRule,
+  type WhisperCategory,
+  type WhisperResult,
 } from './chatter.ts'
 
 /** Schema version this module normalizes (optional field; missing = 1). */
@@ -71,9 +74,6 @@ export interface VoicePack {
 /** 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
 
@@ -87,7 +87,7 @@ const PLACEHOLDER_WHITELIST: Partial<Record<PoolKind, readonly string[]>> = {
   stat: ['{rank}', '{n}', '{points}'],
 }
 
-type PoolKind = 'status' | 'tools' | 'toolRemaining' | 'whisperGeneric' | 'whisperRule' | 'label' | 'stat'
+type PoolKind = 'status' | 'tools' | 'toolRemaining' | 'whisperCategory' | 'whisperResult' | 'label' | 'stat'
 
 function isRecord(value: unknown): value is Record<string, unknown> {
   return typeof value === 'object' && value !== null && !Array.isArray(value)
@@ -151,51 +151,48 @@ export function normalizePool(
   return pool
 }
 
-/** Normalize the ordered keyword-rule list ([] disables the keyword channel). */
-export function normalizeWhisperRules(
+/** Normalize whisper category pools; a key replaces that category's built-in pool (an explicit empty pool mutes it). */
+export function normalizeWhisperCategories(
   raw: unknown,
   onWarning: (message: string) => void = () => {},
-): WhisperRule[] | undefined {
+): Partial<Record<WhisperCategory, readonly string[]>> | undefined {
   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: WhisperRule[] = []
-  for (const item of raw.slice(0, VOICE_RULES_MAX)) {
-    if (!isRecord(item)) {
-      onWarning('whisper rule must be an object')
+  const pools: Partial<Record<WhisperCategory, readonly string[]>> = {}
+  for (const key of Object.keys(raw)) {
+    if (!(WHISPER_CATEGORIES as readonly string[]).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: unknown = item.keywords
-    const keywords: string[] = []
-    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 as WhisperCategory] = 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: unknown,
+  onWarning: (message: string) => void = () => {},
+): Partial<Record<WhisperResult, readonly string[]>> | undefined {
+  if (raw === undefined) return undefined
+  if (!isRecord(raw)) {
+    onWarning('whispers.results must be an object')
+    return undefined
+  }
+  const pools: Partial<Record<WhisperResult, readonly string[]>> = {}
+  for (const key of Object.keys(raw)) {
+    if (!(WHISPER_RESULTS as readonly string[]).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 as WhisperResult] = pool
   }
-  return rules
+  return Object.keys(pools).length > 0 ? pools : undefined
 }
 
 /** Normalize the panel block (labels / stats / actions; warn-and-drop). */
@@ -271,7 +268,7 @@ export function normalizePanel(
 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
@@ -340,14 +337,20 @@ export function normalizeVoicePack(
       onWarning('whispers must be an object')
     } else {
       for (const key of Object.keys(whispersRaw)) {
-        if (!WHISPER_KEYS.has(key)) onWarning('unknown whispers field ' + key + ' ignored')
+        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 }),
         }
       }
     }