@linxin666/dsh-pet 0.1.13 → 0.1.15

package/lib/index.js

@@ -1,12 +1,132 @@
-import { a as AFFINITY_MAX, c as applyTurnReward, d as rankOf, i as rowOf, l as defaultAffinityConfig, n as animationForPhase, o as AFFINITY_RANKS, r as defaultPetStateConfig, s as applyInteraction, t as PetStateMachine, u as emptyAffinity } from "./state-C9EyycwI.js";
+import { a as AFFINITY_MAX, c as applyInteraction, d as emptyAffinity, f as rankOf, i as rowOf, l as applyTurnReward, n as animationForPhase, o as AFFINITY_RANKS, r as defaultPetStateConfig, s as affinityViewOf, t as PetStateMachine, u as defaultAffinityConfig } from "./state-CFyJv0sQ.js";
 import { installSettingsSection, settingsNamespace } from "@deepseek-ai/dsh-settings";
 import z from "schemastery";
 import { Service } from "@deepseek-ai/cordis";
 import { mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
+import { isAbsolute, join } from "node:path";
 import { homedir } from "node:os";
 import { readFile } from "node:fs/promises";
 import { fileURLToPath } from "node:url";
+//#region src/event-projection.ts
+/** Fresh projection runtime for a newly seen session. */
+function emptyProjectionRuntime() {
+	return {
+		activeTools: /* @__PURE__ */ new Set(),
+		officialEventsSeen: false,
+		stepHadFailure: false
+	};
+}
+/** Keep tool names readable inside the compact status bubble. */
+function displayToolName(name) {
+	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. */
+function isActivityPhase(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.
+*/
+function projectOfficialEvent(event, runtime) {
+	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;
+		}
+		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 !== void 0 || 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: return { input: { phase: "idle" } };
+			}
+		default: return;
+	}
+}
+//#endregion
 //#region src/treats.ts
 const defaultTreatConfig = {
 	turnsPerTreat: 3,
@@ -80,6 +200,193 @@ function consumeTreat(ledger) {
 	};
 }
 //#endregion
+//#region src/ledger.ts
+/**
+* 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
+*/
+/**
+* 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.
+*/
+var PetLedger = class {
+	affinityConfig;
+	treatConfig;
+	current;
+	/** Completed turns already rewarded, per session (turn numbers are per-session). */
+	rewardedTurns = /* @__PURE__ */ new Map();
+	lastLegacyTurnRewardAt = 0;
+	dirty = false;
+	constructor(persist, config = {}) {
+		this.affinityConfig = {
+			...defaultAffinityConfig,
+			...config.affinity ?? {}
+		};
+		this.treatConfig = {
+			...defaultTreatConfig,
+			...config.treats ?? {}
+		};
+		this.current = persist;
+	}
+	/** Affinity cooldown/rank tuning (read-only). */
+	get affinity() {
+		return this.affinityConfig;
+	}
+	/** The current persistence snapshot (trade a copy when mutating). */
+	get snapshot() {
+		return this.current;
+	}
+	/** Stock cap reported to clients. */
+	get treatMax() {
+		return this.treatConfig.maxTreats;
+	}
+	/** Consume the pending-write flag if any mutation occurred. */
+	takeDirty() {
+		const was = this.dirty;
+		this.dirty = false;
+		return was;
+	}
+	/** Replace the display block (clamping stays a caller concern). */
+	setDisplay(display) {
+		this.current = {
+			...this.current,
+			display
+		};
+		this.dirty = true;
+	}
+	/** Replace the pet display name (validation stays a caller concern). */
+	setName(name) {
+		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) {
+		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, turn, nowMs) {
+		if (turn <= (this.rewardedTurns.get(sessionId) ?? 0)) 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) {
+		if (nowMs - this.lastLegacyTurnRewardAt < 5e3) return false;
+		this.lastLegacyTurnRewardAt = nowMs;
+		let changed = this.applyTurnReward();
+		if (this.settleTreats(nowMs)) changed = true;
+		return changed;
+	}
+	applyTurnReward() {
+		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, nowMs) {
+		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) {
+		return affinityViewOf(this.current.affinity, nowMs, this.affinityConfig);
+	}
+};
+//#endregion
+//#region src/dsh-home.ts
+/**
+* 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.
+*/
+/** Expand a leading ~ (or ~user) in a path, platform-style. */
+function expandHome(path, home = homedir()) {
+	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.
+*/
+function resolveDshHome(env = process.env, home = homedir()) {
+	const raw = env.DSH_HOME;
+	if (raw !== void 0 && 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. */
+function dshHome() {
+	return resolveDshHome();
+}
+//#endregion
 //#region src/persist.ts
 /**
 * Pet persistence — tiny JSON store for affinity + display config, written
@@ -104,9 +411,13 @@ function emptyPersist() {
 		display: { ...defaultDisplayConfig }
 	};
 }
-/** 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).
+*/
 function petHomeDir() {
-	return process.env.DSH_HOME ?? join(homedir(), ".dsh");
+	return dshHome();
 }
 /** Numeric field guard: finite numbers only, else the fallback. */
 function finiteNum(value, fallback) {
@@ -164,37 +475,32 @@ function savePetPersist(data, dir = petHomeDir()) {
 }
 /**
 * Cordis service exposing the pet RPC domain. Lazy: nothing is scanned or
-* written until a query or interaction arrives; event listeners update only
-* in-memory state, and persistence happens on interaction/config changes
-* plus every completed turn.
+* written until an economic event or interaction arrives; event listeners
+* update only in-memory state, and persistence happens on economic changes
+* (turn rewards, feeds, config/name changes) — never on a read.
 */
 var PetService = class extends Service {
 	static inject = [];
 	machine;
-	affinityConfig;
-	treatConfig;
+	ledger;
 	persistDir;
-	persist;
-	/** Completed turns already rewarded, per session (turn numbers are per-session). */
-	rewardedTurns = /* @__PURE__ */ new Map();
 	enabled;
 	disposeActivity;
+	/** Session whose most recent meaningful event currently drives the global pet. */
+	displaySession;
+	sessionActivity = /* @__PURE__ */ new WeakMap();
 	constructor(ctx, config = {}) {
 		super(ctx, "pet");
 		this.persistDir = config.persistDir ?? petHomeDir();
-		this.affinityConfig = {
-			...defaultAffinityConfig,
-			...config.affinity ?? {}
-		};
-		this.treatConfig = {
-			...defaultTreatConfig,
-			...config.treats ?? {}
+		const ledgerConfig = {
+			affinity: config.affinity,
+			treats: config.treats
 		};
+		this.ledger = new PetLedger(loadPetPersist(this.persistDir), ledgerConfig);
 		this.machine = new PetStateMachine({
 			...defaultPetStateConfig,
 			...config.state ?? {}
 		});
-		this.persist = loadPetPersist(this.persistDir);
 		this.enabled = config.enabled ?? true;
 		this.syncActivity();
 	}
@@ -208,11 +514,11 @@ var PetService = class extends Service {
 	}
 	/** Current persisted display config (read-only view). */
 	display() {
-		return { ...this.persist.display };
+		return { ...this.ledger.snapshot.display };
 	}
 	/** Current persisted pet name (read-only view). */
 	petName() {
-		return this.persist.name;
+		return this.ledger.snapshot.name;
 	}
 	/** Start or stop the session-activity listeners that drive the pet. */
 	setEnabled(enabled) {
@@ -227,31 +533,26 @@ var PetService = class extends Service {
 		if (!this.enabled) return;
 		this.disposeActivity = (() => {
 			const disposers = [this.ctx.on("session/event", (session, event) => {
-				switch (event.type) {
-					case "turn/start":
-						this.machine.onSessionActive();
-						break;
-					case "step/start":
-						this.machine.onSessionActive();
-						this.machine.onActivityStatus({ phase: "thinking" });
-						break;
-					case "tool/call":
-						this.machine.onSessionActive();
-						this.machine.onActivityStatus({
-							phase: "tool",
-							line: "tool: " + event.data.name
-						});
-						break;
-					case "turn/end":
-						this.machine.onSessionActive();
-						if (event.data.reason.kind === "completed") {
-							this.machine.onActivityStatus({ phase: "done" });
-							this.rewardTurn(String(session.id), event.data.turn);
-						} else this.machine.onActivityStatus({ phase: "idle" });
-						break;
-					default: break;
+				const runtime = this.activityRuntime(session);
+				if (event.type === "activity/status") {
+					const payload = event.data ?? {};
+					if (typeof payload.phase !== "string" || !isActivityPhase(payload.phase)) return;
+					this.applyActivity(session, {
+						phase: payload.phase,
+						...typeof payload.line === "string" ? { line: payload.line } : {},
+						...typeof payload.phrase === "string" ? { phrase: payload.phrase } : {}
+					});
+					if (payload.phase === "done" && !runtime.officialEventsSeen) this.rewardLegacyTurn();
+					return;
 				}
-			}), this.ctx.on("session/disposed", () => {
+				const transition = projectOfficialEvent(event, runtime);
+				if (transition === void 0) return;
+				runtime.officialEventsSeen = true;
+				this.applyActivity(session, transition.input);
+				if (transition.completedTurn !== void 0) this.rewardTurn(String(session.id), transition.completedTurn);
+			}), this.ctx.on("session/disposed", (session) => {
+				if (session !== this.displaySession) return;
+				this.displaySession = void 0;
 				this.machine.onSessionDisposed();
 			})];
 			return () => {
@@ -259,76 +560,56 @@ var PetService = class extends Service {
 			};
 		})();
 	}
+	/** Return the projection state associated with one live session. */
+	activityRuntime(session) {
+		let runtime = this.sessionActivity.get(session);
+		if (runtime === void 0) {
+			runtime = emptyProjectionRuntime();
+			this.sessionActivity.set(session, runtime);
+		}
+		return runtime;
+	}
+	/** Commit one activity as the host-global pet's most recent display state. */
+	applyActivity(session, input) {
+		this.displaySession = session;
+		this.machine.onActivityStatus(input);
+		this.machine.onSessionActive();
+	}
 	/** RPC: pet or feed the pet. */
 	async interact(kind) {
 		const nowMs = Date.now();
-		if (kind === "feed") this.settleTreats(nowMs);
-		const outcome = applyInteraction(this.persist.affinity, kind, nowMs, this.affinityConfig);
-		if (kind === "feed" && !outcome.accepted) return {
-			reaction: outcome.reaction,
-			delta: 0,
-			affinity: this.affinityView(this.persist.affinity)
-		};
-		if (kind === "feed") {
-			const consume = consumeTreat(this.persist.treats);
-			if (!consume.ok) return {
-				reaction: "没有小鱼干了，多陪鲸鱼娘工作一会儿吧～",
-				delta: 0,
-				affinity: this.affinityView(this.persist.affinity)
-			};
-			this.persist = {
-				...this.persist,
-				treats: consume.ledger
-			};
-		}
-		if (outcome.accepted) {
-			this.persist = {
-				...this.persist,
-				affinity: outcome.affinity
-			};
-			this.flush();
-		}
-		const affinity = this.affinityView(outcome.affinity);
-		return {
-			reaction: outcome.reaction,
-			delta: outcome.delta,
-			affinity
-		};
+		const result = this.ledger.interact(kind, nowMs);
+		if (this.ledger.takeDirty()) this.flush();
+		return result;
 	}
 	/** RPC: show or hide the pet. */
 	async setVisible(visible) {
-		this.persist = {
-			...this.persist,
-			display: {
-				...this.persist.display,
-				visible
-			}
-		};
+		this.ledger.setDisplay({
+			...this.ledger.snapshot.display,
+			visible
+		});
 		this.flush();
 		this.syncSettingsFromPet();
 		return {
 			ok: true,
-			display: this.persist.display
+			display: this.ledger.snapshot.display
 		};
 	}
 	/** RPC: update display config (size / position). Values are clamped to whole pixels. */
 	async setConfig(patch) {
 		const next = {
-			...this.persist.display,
+			...this.ledger.snapshot.display,
 			...patch
 		};
 		next.size = Math.round(Math.min(512, Math.max(32, next.size)));
 		next.right = Math.round(Math.min(DISPLAY_INSET_MAX, Math.max(0, next.right)));
 		next.bottom = Math.round(Math.min(DISPLAY_INSET_MAX, Math.max(0, next.bottom)));
-		this.persist = {
-			...this.persist,
-			display: next
-		};
+		this.ledger.setDisplay(next);
 		this.flush();
 		this.syncSettingsFromPet();
 		return {
 			ok: true,
-			display: this.persist.display
+			display: this.ledger.snapshot.display
 		};
 	}
 	/** RPC: rename the pet (trimmed, 1–20 chars). */
@@ -342,10 +623,7 @@ var PetService = class extends Service {
 			ok: false,
 			error: "name-too-long"
 		};
-		this.persist = {
-			...this.persist,
-			name: trimmed
-		};
+		this.ledger.setName(trimmed);
 		this.flush();
 		this.syncSettingsFromPet();
 		return {
@@ -360,90 +638,55 @@ var PetService = class extends Service {
 	* @param section - the resolved settings section.
 	*/
 	applySettingsSection(section) {
-		const next = { ...this.persist.display };
+		const next = { ...this.ledger.snapshot.display };
 		next.visible = section.visible && (section.enabled ?? true);
 		next.size = Math.round(Math.min(512, Math.max(32, section.size)));
 		next.right = Math.round(Math.min(DISPLAY_INSET_MAX, Math.max(0, section.right)));
 		next.bottom = Math.round(Math.min(DISPLAY_INSET_MAX, Math.max(0, section.bottom)));
-		this.persist = {
-			...this.persist,
-			display: next,
-			name: section.name.trim()
-		};
+		this.ledger.setDisplay(next);
+		this.ledger.setName(section.name.trim());
 		this.flush();
 	}
 	/** Mirror the persisted display config into the settings document (best-effort). */
 	syncSettingsFromPet() {
 		const settings = this.ctx.get("settings", false);
 		if (settings === void 0) return;
+		const snapshot = this.ledger.snapshot;
 		settings.update("pet", {
-			visible: this.persist.display.visible,
-			size: this.persist.display.size,
-			right: this.persist.display.right,
-			bottom: this.persist.display.bottom,
-			name: this.persist.name
+			visible: snapshot.display.visible,
+			size: snapshot.display.size,
+			right: snapshot.display.right,
+			bottom: snapshot.display.bottom,
+			name: snapshot.name
 		}).catch(() => {});
 	}
 	/** Award the turn reward once per completed turn (idempotent per session + turn). */
 	rewardTurn(sessionId, turn) {
-		if (turn <= (this.rewardedTurns.get(sessionId) ?? 0)) return;
-		this.rewardedTurns.set(sessionId, turn);
-		this.persist = {
-			...this.persist,
-			affinity: applyTurnReward(this.persist.affinity, this.affinityConfig)
-		};
-		this.flush();
+		if (this.ledger.rewardTurn(sessionId, turn, Date.now())) this.flush();
 	}
-	/**
-	* Settle the treat economy (work + time output since the last settlement)
-	* and persist whenever the ledger changed. A zero-gain first settlement
-	* still starts the time clock (anchor write), which is what lets the
-	* 30-minute time output ever accrue.
-	*/
-	settleTreats(nowMs) {
-		const settlement = settleTreatGrants(this.persist.treats, this.persist.affinity.turns, nowMs, this.treatConfig);
-		if (settlement.ledger !== this.persist.treats) {
-			this.persist = {
-				...this.persist,
-				treats: settlement.ledger
-			};
-			this.flush();
-		}
+	/** Preserve turn rewards for installations that only emit legacy activity. */
+	rewardLegacyTurn() {
+		if (this.ledger.rewardLegacyTurn(Date.now())) this.flush();
 	}
 	view() {
 		const snapshot = this.machine.render();
-		this.settleTreats(Date.now());
 		return {
 			animation: snapshot.animation,
 			...snapshot.bubble === void 0 ? {} : { bubble: snapshot.bubble },
 			phase: snapshot.phase,
 			sessionActive: snapshot.sessionActive,
-			affinity: this.affinityView(this.persist.affinity),
-			display: { ...this.persist.display },
-			name: this.persist.name,
+			affinity: this.ledger.affinityView(Date.now()),
+			display: { ...this.ledger.snapshot.display },
+			name: this.ledger.snapshot.name,
 			treats: {
-				stocked: this.persist.treats.treats,
-				max: this.treatConfig.maxTreats
+				stocked: this.ledger.snapshot.treats.treats,
+				max: this.ledger.treatMax
 			}
 		};
 	}
-	affinityView(affinity) {
-		const nowMs = Date.now();
-		const rank = rankOf(affinity.points);
-		return {
-			points: affinity.points,
-			rank: rank.name,
-			rankEmoji: rank.emoji,
-			pets: affinity.pets,
-			feeds: affinity.feeds,
-			turns: affinity.turns,
-			petCooldown: nowMs - affinity.lastPetAt < this.affinityConfig.petCooldownMs,
-			feedCooldown: nowMs - affinity.lastFeedAt < this.affinityConfig.feedCooldownMs
-		};
-	}
 	flush() {
 		try {
-			savePetPersist(this.persist, this.persistDir);
+			savePetPersist(this.ledger.snapshot, this.persistDir);
 		} catch {}
 	}
 };

package/lib/invariant.js

@@ -1,4 +1,4 @@
-import { l as defaultAffinityConfig, n as animationForPhase, o as AFFINITY_RANKS } from "./state-C9EyycwI.js";
+import { n as animationForPhase, o as AFFINITY_RANKS, u as defaultAffinityConfig } from "./state-CFyJv0sQ.js";
 //#region src/invariant.ts
 /**
 * Package invariants — cheap structural checks run at import time on the