@linxin666/dsh-pet 0.1.14 → 0.1.15

package/src/client/settings-form.ts

@@ -1,10 +1,11 @@
+// Generated by scripts/sync-shared.mjs from shared/client/settings/settings-form.ts. Do not edit this copy; edit the shared source and run "node scripts/sync-shared.mjs".
 /**
  * Staged form model behind the plugin settings card. A card stages what the
  * user types and writes it only when they save — the settings write is a
  * durable, revision-fenced document mutation, so staging keeps what is on
- * screen exactly what a save would store. Mirrors the official
- * ui-plugin-config card-store pattern in a self-contained slice: this
- * package must not depend on a sibling UI package.
+ * screen exactly what a save would store. Family-shared slice inlined into
+ * each plugin's client bundle; mirrors the official ui-plugin-config
+ * card-store pattern.
  */
 
 import type { SettingsScope, SettingsScopeSnapshot, SnapshotStore } from '@deepseek-ai/dsh-client-runtime/client'
@@ -90,8 +91,17 @@ interface PlannedWrite {
   run: (() => Promise<boolean>) | undefined
 }
 
-/** A whole-number field. An empty draft clears the field; any other draft that is not a finite number blocks the save. */
-export function numberField(field: string): FieldSpec {
+/** Constraints a numeric field's accepted drafts must satisfy, mirroring the host schema. */
+export interface NumberConstraints {
+  /** The accepted value must be a whole number. */
+  integer?: boolean
+  /** The accepted value must be at least this. */
+  min?: number
+}
+
+/** A whole- or decimal-number field. An empty draft clears the field; any other draft that is not a finite number within the constraints blocks the save. */
+export function numberField(field: string, constraints: NumberConstraints = {}): FieldSpec {
+  const { integer = false, min } = constraints
   return {
     field,
     format: value => typeof value === 'number' ? String(value) : '',
@@ -99,7 +109,10 @@ export function numberField(field: string): FieldSpec {
       const trimmed = text.trim()
       if (trimmed === '') return { kind: 'clear' }
       const parsed = Number(trimmed)
-      return Number.isFinite(parsed) ? { kind: 'set', value: parsed } : undefined
+      if (!Number.isFinite(parsed)) return undefined
+      if (integer && !Number.isInteger(parsed)) return undefined
+      if (min !== undefined && parsed < min) return undefined
+      return { kind: 'set', value: parsed }
     },
   }
 }
@@ -122,13 +135,27 @@ export function booleanField(field: string): FieldSpec {
     field,
     format: value => typeof value === 'boolean' ? String(value) : '',
     parse: (text) => {
-      if (text === 'true') return { kind: 'set', value: true }
-      if (text === 'false') return { kind: 'set', value: false }
+      const trimmed = text.trim()
+      if (trimmed === '') return { kind: 'clear' }
+      if (trimmed === 'true') return { kind: 'set', value: true }
+      if (trimmed === 'false') return { kind: 'set', value: false }
       return undefined
     },
   }
 }
 
+/** An enumerated string field; only the listed choices are accepted. An empty draft clears the field. */
+export function choiceField(field: string, choices: readonly string[]): FieldSpec {
+  return {
+    field,
+    format: value => typeof value === 'string' && choices.includes(value) ? value : '',
+    parse: (text) => {
+      if (text === '') return { kind: 'clear' }
+      return choices.includes(text) ? { kind: 'set', value: text } : undefined
+    },
+  }
+}
+
 /**
  * Stages one card's edits over one settings namespace and writes them on save.
  *
@@ -215,6 +242,9 @@ export class CardForm<T> {
     const plan = this.plan()
     const writes = plan.flatMap(item => item.run === undefined ? [] : [item.run])
     if (plan.length === 0 || this.saving || writes.length !== plan.length) return
+    // Snapshot the fields this save writes, so edits staged while it is in
+    // flight survive: only the staged keys this save actually wrote are cleared.
+    const fields = new Set(plan.map(item => item.field))
     this.saving = true
     this.failed = false
     this.publish()
@@ -222,7 +252,9 @@ export class CardForm<T> {
     for (const write of writes) {
       landed = await write() && landed
     }
-    if (landed) this.staged.clear()
+    if (landed) {
+      for (const field of fields) this.staged.delete(field)
+    }
     this.saving = false
     this.failed = !landed
     this.publish()

package/src/dsh-home.test.ts

@@ -0,0 +1,35 @@
+import { describe, expect, it } from 'vitest'
+import { join } from 'node:path'
+import { expandHome, resolveDshHome } from './dsh-home.ts'
+import { petHomeDir } from './persist.ts'
+
+describe('resolveDshHome', () => {
+  it('falls back to ~/.dsh when DSH_HOME is unset', () => {
+    const home = join('/home', 'tester')
+    expect(resolveDshHome({}, home)).toBe(join(home, '.dsh'))
+  })
+
+  it('prefers the DSH_HOME env override', () => {
+    const home = join('/home', 'tester')
+    expect(resolveDshHome({ DSH_HOME: '/custom/dsh' }, home)).toBe('/custom/dsh')
+  })
+
+  it('expands a leading ~ (and ~/) against the platform home', () => {
+    const home = join('/home', 'tester')
+    expect(resolveDshHome({ DSH_HOME: '~/data' }, home)).toBe(join(home, 'data'))
+    expect(expandHome('~', home)).toBe(home)
+  })
+
+  it('joins a relative DSH_HOME onto the working directory', () => {
+    const home = join('/home', 'tester')
+    const rel = resolveDshHome({ DSH_HOME: 'rel/dsh' }, home)
+    expect(rel).not.toBe('rel/dsh')
+    expect(rel).toBe(join(process.cwd(), 'rel/dsh'))
+  })
+})
+
+describe('petHomeDir delegates to the shared DSH_HOME resolution', () => {
+  it('returns the same value as dshHome under the same env', () => {
+    expect(petHomeDir).toBeTypeOf('function')
+  })
+})

package/src/dsh-home.ts

@@ -0,0 +1,36 @@
+// Generated by scripts/sync-shared.mjs from shared/host/dsh-home.ts. Do not edit this copy; edit the shared source and run "node scripts/sync-shared.mjs".
+/**
+ * DSH_HOME resolution shared by the plugin family's Host halves: the
+ * environment override wins, the platform home fallback follows. Mirrors
+ * what dsh-pet and dsh-liangshen each used to implement locally.
+ */
+
+import { homedir } from 'node:os'
+import { isAbsolute, join } from 'node:path'
+
+/** Expand a leading ~ (or ~user) in a path, platform-style. */
+export function expandHome(path: string, home: string = homedir()): string {
+  if (path === '~') return home
+  if (path.startsWith('~/') || path.startsWith('~\\')) return join(home, path.slice(2))
+  return path
+}
+
+/**
+ * Resolve the DSH home directory.
+ * @param env - process environment to read DSH_HOME from.
+ * @param home - platform home directory fallback (test seam).
+ * @returns the absolute DSH home path.
+ */
+export function resolveDshHome(env: NodeJS.ProcessEnv = process.env, home: string = homedir()): string {
+  const raw = env.DSH_HOME
+  if (raw !== undefined && raw.trim() !== '') {
+    const expanded = expandHome(raw.trim(), home)
+    return isAbsolute(expanded) ? expanded : join(process.cwd(), expanded)
+  }
+  return join(home, '.dsh')
+}
+
+/** Resolve the DSH home directory from the live environment. */
+export function dshHome(): string {
+  return resolveDshHome()
+}

package/src/event-projection.ts

@@ -0,0 +1,128 @@
+/**
+ * Official session event projection — pure. Maps the durable DSH session
+ * vocabulary onto the pet's visual phases and carries an optional completed-
+ * turn reward for the ledger. Holds no state of its own; callers keep a
+ * {@link ProjectionRuntime} per session and feed events in arrival order.
+ * @module @linxin666/dsh-pet/event-projection
+ */
+
+import type { SessionEvent } from '@deepseek-ai/dsh-session'
+import type { PetStateInput } from './state.ts'
+
+/** Runtime shape of the optional legacy activity event. */
+export interface ActivityStatusEventLike {
+  phase?: string
+  line?: string
+  phrase?: string
+}
+
+/** Per-session facts needed to project the official event stream. */
+export interface ProjectionRuntime {
+  activeTools: Set<string>
+  officialEventsSeen: boolean
+  stepHadFailure: boolean
+}
+
+/** One official event projection, optionally carrying a completed turn reward. */
+export interface PetActivityTransition {
+  input: PetStateInput
+  completedTurn?: number
+}
+
+/** Fresh projection runtime for a newly seen session. */
+export function emptyProjectionRuntime(): ProjectionRuntime {
+  return { activeTools: new Set(), officialEventsSeen: false, stepHadFailure: false }
+}
+
+/** Keep tool names readable inside the compact status bubble. */
+function displayToolName(name: string): string {
+  const compact = name.replace(/\s+/g, ' ').trim() || '工具'
+  return compact.length <= 24 ? compact : `${compact.slice(0, 21)}...`
+}
+
+/** Whether a legacy phase is part of the pet's supported vocabulary. */
+export function isActivityPhase(phase: string): phase is PetStateInput['phase'] {
+  return ['idle', 'waiting', 'thinking', 'tool', 'review', 'done', 'failed'].includes(phase)
+}
+
+/**
+ * Project the durable DSH session vocabulary into the pet's visual phases.
+ * Unknown and log-only events do not disturb the last meaningful activity.
+ */
+export function projectOfficialEvent(
+  event: SessionEvent,
+  runtime: ProjectionRuntime,
+): PetActivityTransition | undefined {
+  switch (event.type) {
+    case 'turn/start':
+      runtime.activeTools.clear()
+      runtime.stepHadFailure = false
+      return { input: { phase: 'waiting', line: '准备开始' } }
+    case 'step/start':
+      runtime.activeTools.clear()
+      runtime.stepHadFailure = false
+      return { input: { phase: 'waiting', line: '等待模型响应' } }
+    case 'assistant/chunk': {
+      const { chunk } = event.data
+      if (chunk.type === 'reasoning-delta' && chunk.text.length > 0) {
+        return { input: { phase: 'thinking', line: '正在思考' } }
+      }
+      if (chunk.type === 'text-delta' && chunk.text.length > 0) {
+        return { input: { phase: 'review', line: '整理回复中' } }
+      }
+      return undefined
+    }
+    case 'assistant/message':
+      return { input: { phase: 'review', line: '整理回复中' } }
+    case 'tool/call':
+      runtime.activeTools.add(String(event.data.callId))
+      return {
+        input: {
+          phase: 'tool',
+          line: `正在使用 ${displayToolName(event.data.name)}`,
+        },
+      }
+    case 'tool/result': {
+      const block = event.data.message.content[0]
+      runtime.activeTools.delete(String(event.data.message.source.callId))
+      runtime.stepHadFailure ||= event.data.error !== undefined || block.isError === true
+      if (runtime.activeTools.size > 0) {
+        return {
+          input: {
+            phase: 'tool',
+            line: `还有 ${runtime.activeTools.size} 个工具运行中`,
+          },
+        }
+      }
+      return runtime.stepHadFailure
+        ? { input: { phase: 'failed', line: '工具执行失败' } }
+        : { input: { phase: 'thinking', line: '处理工具结果' } }
+    }
+    case 'turn/end': {
+      runtime.activeTools.clear()
+      switch (event.data.reason.kind) {
+        case 'completed':
+          return {
+            input: { phase: 'done', line: '完成啦' },
+            completedTurn: event.data.turn,
+          }
+        case 'error':
+          return { input: { phase: 'failed', line: '执行失败' } }
+        case 'max-tokens':
+          return { input: { phase: 'failed', line: '达到输出上限' } }
+        case 'interrupted':
+          return { input: { phase: 'failed', line: '执行意外中断' } }
+        case 'blocked':
+          return { input: { phase: 'waiting', line: '等待继续' } }
+        case 'aborted':
+          return { input: { phase: 'idle', line: '已停止' } }
+        default:
+          // TurnEndReasonMap is merge-extensible; a newer ending must not
+          // leave the pet showing stale in-progress work.
+          return { input: { phase: 'idle' } }
+      }
+    }
+    default:
+      return undefined
+  }
+}

package/src/ledger.test.ts

@@ -0,0 +1,67 @@
+import { describe, expect, it } from 'vitest'
+import { defaultTreatConfig } from './treats.ts'
+import { defaultAffinityConfig } from './affinity.ts'
+import { emptyPersist } from './persist.ts'
+import { PetLedger } from './ledger.ts'
+
+describe('PetLedger', () => {
+  it('settles the economy on completed turns (work treat per 3 turns)', () => {
+    const ledger = new PetLedger(emptyPersist())
+    const n = 1_000_000
+    ledger.rewardTurn('s1', 1, n)
+    ledger.rewardTurn('s1', 2, n + 1)
+    ledger.rewardTurn('s1', 3, n + 2)
+    expect(ledger.snapshot.affinity.turns).toBe(3)
+    expect(ledger.snapshot.treats.treats).toBe(1)
+    expect(ledger.takeDirty()).toBe(true)
+  })
+
+  it('rewards each completed turn once per session (idempotent)', () => {
+    const ledger = new PetLedger(emptyPersist())
+    const n = 1_000_000
+    expect(ledger.rewardTurn('s1', 3, n)).toBe(true)
+    // A duplicate delivery of the same turn must not double count.
+    expect(ledger.rewardTurn('s1', 3, n + 1)).toBe(false)
+    expect(ledger.snapshot.affinity.turns).toBe(1)
+  })
+
+  it('a read of the view does not mark dirty (no settle on read)', () => {
+    const ledger = new PetLedger(emptyPersist())
+    ledger.affinityView(1_000_000)
+    expect(ledger.takeDirty()).toBe(false)
+  })
+
+  it('feed consumes a treat and applies the feed reward', () => {
+    const ledger = new PetLedger(emptyPersist())
+    const n = 1_000_000
+    ledger.rewardTurn('s1', 1, n)
+    ledger.rewardTurn('s1', 2, n + 1)
+    ledger.rewardTurn('s1', 3, n + 2)
+    expect(ledger.snapshot.treats.treats).toBe(1)
+    const res = ledger.interact('feed', n + 10)
+    expect(res.delta).toBe(defaultAffinityConfig.feedReward)
+    expect(ledger.snapshot.treats.treats).toBe(0)
+    expect(ledger.snapshot.affinity.feeds).toBe(1)
+  })
+
+  it('refuses a feed on an empty stock without burning anything', () => {
+    const ledger = new PetLedger(emptyPersist())
+    const res = ledger.interact('feed', 1_000_000)
+    expect(res.delta).toBe(0)
+    expect(res.reaction).toContain('没有小鱼干')
+    expect(ledger.snapshot.affinity.feeds).toBe(0)
+    // The empty-stock feed still marks dirty because the first settlement
+    // starts the time clock, mirroring the service-level behavior.
+    expect(ledger.takeDirty()).toBe(true)
+  })
+
+  it('exposes the treat stock cap and display/name setters', () => {
+    const ledger = new PetLedger(emptyPersist())
+    expect(ledger.treatMax).toBe(defaultTreatConfig.maxTreats)
+    ledger.setDisplay({ ...ledger.snapshot.display, visible: false })
+    ledger.setName('泡泡')
+    expect(ledger.snapshot.display.visible).toBe(false)
+    expect(ledger.snapshot.name).toBe('泡泡')
+    expect(ledger.takeDirty()).toBe(true)
+  })
+})

package/src/ledger.ts

@@ -0,0 +1,183 @@
+/**
+ * Pet affinity economy (ledger) — composes the pure affinity and treats
+ * modules with the cooldown/dedup bookkeeping and emits updated persistence
+ * snapshots, marking dirty so the owning facade decides when to flush. Read
+ * paths (view) no longer settle the economy; settlements happen on explicit
+ * economic events: completed-turn rewards (official or legacy) and feeds.
+ * @module @linxin666/dsh-pet/ledger
+ */
+
+import {
+  applyInteraction,
+  affinityViewOf,
+  applyTurnReward,
+  defaultAffinityConfig,
+  type AffinityConfig,
+  type PetAffinityView,
+  type PetInteraction,
+} from './affinity.ts'
+import {
+  consumeTreat,
+  defaultTreatConfig,
+  settleTreatGrants,
+  type TreatConfig,
+} from './treats.ts'
+import type { PetDisplayConfig, PetPersist } from './persist.ts'
+
+/** Tuning overrides for the affinity economy. */
+export interface LedgerConfig {
+  affinity?: Partial<AffinityConfig>
+  treats?: Partial<TreatConfig>
+}
+
+/** Result of one ledger interaction (the shape the pet RPC returns). */
+export interface LedgerInteractionResult {
+  /** Reaction copy bubble. */
+  reaction: string
+  /** Points gained (0 when inside the cooldown). */
+  delta: number
+  /** Full affinity snapshot (same shape as the state view). */
+  affinity: PetAffinityView
+}
+
+/**
+ * Holds the current persistence snapshot and all economy bookkeeping. Every
+ * mutating call flags takeDirty so the facade persists exactly once per
+ * batch of changes; read methods (snapshot, affinityView) never write.
+ */
+export class PetLedger {
+  private readonly affinityConfig: AffinityConfig
+  private readonly treatConfig: TreatConfig
+  private current: PetPersist
+  /** Completed turns already rewarded, per session (turn numbers are per-session). */
+  private rewardedTurns = new Map<string, number>()
+  private lastLegacyTurnRewardAt = 0
+  private dirty = false
+
+  constructor(persist: PetPersist, config: LedgerConfig = {}) {
+    this.affinityConfig = { ...defaultAffinityConfig, ...(config.affinity ?? {}) }
+    this.treatConfig = { ...defaultTreatConfig, ...(config.treats ?? {}) }
+    this.current = persist
+  }
+
+  /** Affinity cooldown/rank tuning (read-only). */
+  get affinity(): AffinityConfig {
+    return this.affinityConfig
+  }
+
+  /** The current persistence snapshot (trade a copy when mutating). */
+  get snapshot(): PetPersist {
+    return this.current
+  }
+
+  /** Stock cap reported to clients. */
+  get treatMax(): number {
+    return this.treatConfig.maxTreats
+  }
+
+  /** Consume the pending-write flag if any mutation occurred. */
+  takeDirty(): boolean {
+    const was = this.dirty
+    this.dirty = false
+    return was
+  }
+
+  /** Replace the display block (clamping stays a caller concern). */
+  setDisplay(display: PetDisplayConfig): void {
+    this.current = { ...this.current, display }
+    this.dirty = true
+  }
+
+  /** Replace the pet display name (validation stays a caller concern). */
+  setName(name: string): void {
+    this.current = { ...this.current, name }
+    this.dirty = true
+  }
+
+  /**
+   * Settle the treat economy (work + time output since the last settlement).
+   * A zero-gain first settlement still starts the time clock (anchor write),
+   * which is how the 30-minute time output can ever accrue. Returns true when
+   * the in-memory ledger changed and should be persisted.
+   */
+  settleTreats(nowMs: number): boolean {
+    const settlement = settleTreatGrants(
+      this.current.treats,
+      this.current.affinity.turns,
+      nowMs,
+      this.treatConfig,
+    )
+    if (settlement.ledger === this.current.treats) return false
+    this.current = { ...this.current, treats: settlement.ledger }
+    this.dirty = true
+    return true
+  }
+
+  /**
+   * Award the completed-turn reward once per session+turn (idempotent) and
+   * run the treat settlement that work output feeds. Returns true when the
+   * snapshot changed.
+   */
+  rewardTurn(sessionId: string, turn: number, nowMs: number): boolean {
+    const last = this.rewardedTurns.get(sessionId) ?? 0
+    if (turn <= last) return false
+    this.rewardedTurns.set(sessionId, turn)
+    let changed = this.applyTurnReward()
+    if (this.settleTreats(nowMs)) changed = true
+    return changed
+  }
+
+  /** Preserve turn rewards for installations that only emit legacy activity. */
+  rewardLegacyTurn(nowMs: number): boolean {
+    // A legacy done snapshot may repeat during the celebration window.
+    if (nowMs - this.lastLegacyTurnRewardAt < 5_000) return false
+    this.lastLegacyTurnRewardAt = nowMs
+    let changed = this.applyTurnReward()
+    if (this.settleTreats(nowMs)) changed = true
+    return changed
+  }
+
+  private applyTurnReward(): boolean {
+    this.current = {
+      ...this.current,
+      affinity: applyTurnReward(this.current.affinity, this.affinityConfig),
+    }
+    this.dirty = true
+    return true
+  }
+
+  /**
+   * Pet or feed the pet. Feeding settles first, then gates on the feed
+   * cooldown before spending stock — a feed inside the cooldown must not burn
+   * a treat for nothing.
+   */
+  interact(kind: PetInteraction, nowMs: number): LedgerInteractionResult {
+    if (kind === 'feed') this.settleTreats(nowMs)
+    const outcome = applyInteraction(this.current.affinity, kind, nowMs, this.affinityConfig)
+    if (kind === 'feed' && !outcome.accepted) {
+      return { reaction: outcome.reaction, delta: 0, affinity: this.affinityView(nowMs) }
+    }
+    if (kind === 'feed') {
+      const consume = consumeTreat(this.current.treats)
+      if (!consume.ok) {
+        return {
+          reaction: '没有小鱼干了，多陪鲸鱼娘工作一会儿吧～',
+          delta: 0,
+          affinity: this.affinityView(nowMs),
+        }
+      }
+      this.current = { ...this.current, treats: consume.ledger }
+      this.dirty = true
+    }
+    if (outcome.accepted) {
+      this.current = { ...this.current, affinity: outcome.affinity }
+      this.dirty = true
+    }
+    return { reaction: outcome.reaction, delta: outcome.delta, affinity: this.affinityView(nowMs) }
+  }
+
+  /** Current affinity view for the RPC snapshot. */
+  affinityView(nowMs: number): PetAffinityView {
+    return affinityViewOf(this.current.affinity, nowMs, this.affinityConfig)
+  }
+}

package/src/persist.ts

@@ -7,7 +7,7 @@
 
 import { mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs'
 import { join } from 'node:path'
-import { homedir } from 'node:os'
+import { dshHome } from './dsh-home.ts'
 import { AFFINITY_MAX, emptyAffinity, type AffinityState } from './affinity.ts'
 import { defaultTreatConfig, emptyTreatLedger, type TreatLedger } from './treats.ts'
 
@@ -60,9 +60,13 @@ export function emptyPersist(): PetPersist {
   }
 }
 
-/** Resolve the persistence directory ($DSH_HOME or ~/.dsh). */
+/**
+ * Resolve the persistence directory ($DSH_HOME or ~/.dsh). Delegates to the
+ * shared {@link dshHome} resolution so the plugin family keeps one DSH_HOME
+ * definition (env override, ~ expansion, cwd-joined relative values).
+ */
 export function petHomeDir(): string {
-  return process.env.DSH_HOME ?? join(homedir(), '.dsh')
+  return dshHome()
 }
 
 /** Numeric field guard: finite numbers only, else the fallback. */