@istarry/dsh-assistant-profile 0.2.1 → 0.3.1

package/lib/index.js

@@ -1,4 +1,11 @@
 import z from "@deepseek-ai/schemastery";
+import { Remote, TypertRemoteService } from "@deepseek-ai/dsh-typert-protocol";
+import { defineTool } from "@deepseek-ai/dsh-tools";
+import { BlockAssembler, createUserMessage } from "@deepseek-ai/dsh-llm";
+import { SessionId } from "@deepseek-ai/dsh-session";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { dshHomePath } from "@deepseek-ai/dsh-home-paths";
 //#region ../tooling/node_modules/.pnpm/js-yaml@4.2.0/node_modules/js-yaml/dist/js-yaml.mjs
 /*! js-yaml 4.2.0 https://github.com/nodeca/js-yaml @license MIT */
 var __create = Object.create;
@@ -2407,13 +2414,126 @@ const DEFAULT_PERSONA = {
 	].join("\n")
 };
 //#endregion
+//#region ../.build/tsc/memory.js
+/**
+* 助理记忆的 Markdown 存储。
+*
+* 只有一个档案，所以只有一份记忆：`<dshHome>/assistant-profile/memory.md`。
+* 路径经 `dshHomePath` 解析，`$DSH_HOME` 覆盖与跨平台 home 都能落对位置。
+*
+* 文档形状：`# 标题` 之类的自由文本由用户自己写，每条记忆是
+* `- [YYYY-MM-DD HH:mm] 内容` 一行。时间戳是条目的主元数据——重存同一件事会刷新
+* 时间戳而不是复制一行。
+*
+* 读写都是同步的：提示词组装调用 section thunk 时没有 await 点，而文件很小。
+*
+* @module @istarry/dsh-assistant-profile/memory
+*/
+/** 本包在 harness home 下占用的目录名。 */
+const MEMORY_DIR = "assistant-profile";
+/** 记忆文档的文件名。 */
+const MEMORY_FILE = "memory.md";
+const ENTRY_RE = /^-?\s*\[(\d{4}-\d{2}-\d{2} \d{2}:\d{2})\]\s*(.*)$/;
+/** 把本地时间格式化成条目的时间戳。 */
+function stampNow(date = /* @__PURE__ */ new Date()) {
+	const pad = (n) => String(n).padStart(2, "0");
+	return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())} ${pad(date.getHours())}:${pad(date.getMinutes())}`;
+}
+/** 记忆文档的绝对路径。 */
+function memoryPath() {
+	return join(dshHomePath(MEMORY_DIR), MEMORY_FILE);
+}
+/** 读取整篇记忆文档；文件不存在时返回空串。 */
+function readMemoryText() {
+	const path = memoryPath();
+	return existsSync(path) ? readFileSync(path, "utf8") : "";
+}
+/** 整体替换记忆文档（用户编辑框里的保存）。 */
+function writeMemory(text) {
+	const path = memoryPath();
+	mkdirSync(dirname(path), { recursive: true });
+	writeFileSync(path, text, "utf8");
+}
+/** 从文档正文里解析出所有记忆条目。 */
+function parseEntries(text) {
+	const entries = [];
+	for (const line of text.split(/\r?\n/)) {
+		const match = ENTRY_RE.exec(line);
+		if (match === null) continue;
+		entries.push({
+			stamp: match[1] ?? "",
+			content: (match[2] ?? "").trim()
+		});
+	}
+	return entries;
+}
+/**
+* 去重比较键：内容大小写折叠、连续空白压成一个空格。
+* 「记得 DSH 路径」和「记得DSH路径」因此算同一条。
+* @param content - 原始条目内容。
+* @returns 用于比较的规范键。
+*/
+function dedupeKey(content) {
+	return content.trim().toLowerCase().replace(/\s+/g, " ");
+}
+/**
+* 追加一条记忆，对整篇文档去重：已存在同义条目就刷新它的时间戳，否则追加新行。
+* 非条目行（标题、空行）原样保留。
+* @param content - 要记住的事实（单行文本）。
+* @param at - 时间戳来源，测试可注入。
+* @returns 这次写入做了什么。
+*/
+function appendMemory(content, at = /* @__PURE__ */ new Date()) {
+	const text = readMemoryText();
+	const stamp = stampNow(at);
+	const trimmed = content.trim();
+	if (trimmed === "") return {
+		appended: false,
+		refreshed: false,
+		content: trimmed
+	};
+	const key = dedupeKey(trimmed);
+	const headerLines = [];
+	const entryLines = [];
+	for (const line of text.split(/\r?\n/)) if (ENTRY_RE.test(line)) entryLines.push(line);
+	else headerLines.push(line);
+	for (let index = 0; index < entryLines.length; index += 1) {
+		const match = ENTRY_RE.exec(entryLines[index]);
+		if (match === null) continue;
+		if (dedupeKey((match[2] ?? "").trim()) === key) {
+			entryLines[index] = `- [${stamp}] ${trimmed}`;
+			writeChunked(headerLines, entryLines);
+			return {
+				appended: false,
+				refreshed: true,
+				content: trimmed
+			};
+		}
+	}
+	entryLines.push(`- [${stamp}] ${trimmed}`);
+	writeChunked(headerLines, entryLines);
+	return {
+		appended: true,
+		refreshed: false,
+		content: trimmed
+	};
+}
+/** 把标题行与条目行拼回一篇文档并写入（顺手收掉首尾空行）。 */
+function writeChunked(headerLines, entryLines) {
+	const meaningful = [...headerLines];
+	while (meaningful.length > 0 && /^\s*$/.test(meaningful[0])) meaningful.shift();
+	while (meaningful.length > 0 && /^\s*$/.test(meaningful[meaningful.length - 1])) meaningful.pop();
+	const body = [...meaningful, ...entryLines].join("\n");
+	writeMemory(body.endsWith("\n") ? body : `${body}\n`);
+}
+//#endregion
 //#region ../.build/tsc/index.js
 /**
 * 助理档案 · 宿主半端。
 *
-* 一个档案、一份人格、四个模式通用。做法只有一件事：每个对话 agent 创建时，在这个
-* agent **自己的上下文**里注册一段 `deployment:persona-prefix`——作用域链上最近的
-* 同名段胜出，于是预设自带的身份句被档案替换，而工具、流程、模式语义一律不动。
+* 一个档案、一份人格、四个模式通用。人格的做法只有一件事：每个对话 agent 创建时，
+* 在这个 agent **自己的上下文**里注册一段 `deployment:persona-prefix`——作用域链上最近
+* 的同名段胜出，于是预设自带的身份句被档案替换，而工具、流程、模式语义一律不动。
 * 官方给子代理发独立人格走的正是这条路径（`dsh-subagent` 的 applyChildComposition），
 * 所以它对标准 / PTC / 极简 / 创造四种预设都成立，不用复制预设组合，也不用改模式
 * 选择器与会话绑定逻辑。
@@ -2421,30 +2541,82 @@ const DEFAULT_PERSONA = {
 * 极简模式的预设人格是「整段系统提示只有这一句」（complete: true）。遮蔽段必须镜像
 * 这个标记，否则会把它变成「全套工具说明 + 人格」，等于改掉了那个模式的定义。
 *
-* 文本是**每次组装提示词时求值**的，所以保存后已打开的会话下一句话就用新人格。是否
-* 因此重算前缀缓存由宿主判定：路由声明 `systemPromptUpdate: 'in-history'` 时，变化的
-* 系统提示会被追加在已缓存的历史之后，历史那段前缀仍然命中；否则从开头失效。
+* 文本是**每次组装提示词时求值**的，所以保存后已打开的会话下一句话就用新人格。
+*
+* ## 助理记忆
+*
+* 单档案所以单记忆：一份 markdown（见 `memory.ts`），以 `memory:assistant` 段注入，
+* order 500——排在人格（0）之后、工具目录（1000）之前：记忆描述的是「用户和我是什么
+* 关系」，工具说明会引用这些前提。段文本每次组装重读文件，所以编辑器保存后下一句话
+* 就带着新记忆。两个开关都是 volatile：设置页写、加载器就地提交、无需重挂。
+*
+* 模型主动记忆走 `memory_add` 工具，仅在「记忆开 + 自动记忆开」时注册；设置页重建
+* 注册靠监听 `loader/volatile-update`。按钮提取走 `rememberFromSession`：用该会话自己的
+* 模型把选中的对话文本提炼成条目后追加。
 *
 * @module @istarry/dsh-assistant-profile
 */
+var __runInitializers = function(thisArg, initializers, value) {
+	var useValue = arguments.length > 2;
+	for (var i = 0; i < initializers.length; i++) value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+	return useValue ? value : void 0;
+};
+var __esDecorate = function(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+	function accept(f) {
+		if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected");
+		return f;
+	}
+	var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+	var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+	var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+	var _, done = false;
+	for (var i = decorators.length - 1; i >= 0; i--) {
+		var context = {};
+		for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+		for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+		context.addInitializer = function(f) {
+			if (done) throw new TypeError("Cannot add initializers after decoration has completed");
+			extraInitializers.push(accept(f || null));
+		};
+		var result = (0, decorators[i])(kind === "accessor" ? {
+			get: descriptor.get,
+			set: descriptor.set
+		} : descriptor[key], context);
+		if (kind === "accessor") {
+			if (result === void 0) continue;
+			if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+			if (_ = accept(result.get)) descriptor.get = _;
+			if (_ = accept(result.set)) descriptor.set = _;
+			if (_ = accept(result.init)) initializers.unshift(_);
+		} else if (_ = accept(result)) if (kind === "field") initializers.unshift(_);
+		else descriptor[key] = _;
+	}
+	if (target) Object.defineProperty(target, contextIn.name, descriptor);
+	done = true;
+};
 /** Cordis 插件名。 */
 const name = "assistant-profile";
 /** 人格所在的那一段的规范名——预设与档案共用同一个名字，遮蔽才成立。 */
 const PERSONA_PREFIX_SECTION = "deployment:persona-prefix";
 /** 该段在提示词里的位置（宿主 SECTION_ORDERS.DEPLOYMENT_PERSONA_PREFIX）。 */
 const PERSONA_PREFIX_ORDER = 0;
+/** 记忆段的名字与位置：人格之后、工具目录（1000）之前。 */
+const MEMORY_SECTION = "memory:assistant";
+const MEMORY_ORDER = 500;
 /** 人格插件的包名，兼容没有 `id` 的旧写法。 */
 const PERSONA_PLUGIN_NAME = "@deepseek-ai/dsh-persona";
 /**
-* 运行时 schema。字段都是 volatile：它们由「助理档案」页而不是插件配置页编辑，
-* 改动经设置通道写回 profile 的 patch，重启后仍在。默认值取内置「默认三」，
-* 所以装好就是一条带人设的鱼；三栏全部清空再保存，则什么都不注入。
+* 运行时 schema。字段都是 volatile：它们由「助理档案」页与「Agent记忆」设置页
+* 而不是插件配置页编辑，改动经设置通道写回 profile 的 patch，重启后仍在。默认值取
+* 内置「默认三」，所以装好就是一条带人设的鱼；三栏全部清空再保存，则什么都不注入。
 */
 const Config = z.object({
 	name: z.string().default(DEFAULT_PERSONA.name).volatile(),
 	language: z.string().default(DEFAULT_PERSONA.language).volatile(),
 	persona: z.string().default(DEFAULT_PERSONA.persona).volatile(),
-	customsJson: z.string().default("[]").volatile()
+	customsJson: z.string().default("[]").volatile(),
+	memoryEnabled: z.boolean().default(true).description("Inject the assistant memory into the system prompt").volatile(),
+	autoMemory: z.boolean().default(false).description("Let the model write memories on its own judgment (requires memoryEnabled)").volatile()
 });
 /** 跨插件重载共享的当前配置引用：旧闭包也能读到新值。 */
 const LIVE = Symbol.for("dsh.assistant-profile.config");
@@ -2463,7 +2635,7 @@ function text(value) {
 	return trimmed === void 0 || trimmed === "" ? void 0 : trimmed;
 }
 /**
-* 把档案渲染成系统提示的首段。四段空行分隔、各自可缺省；全空时返回空串，
+* 把档案渲染成系统提示的首段。三段空行分隔、各自可缺省；全空时返回空串，
 * 由调用方回落到预设自带的身份。
 * @returns 人格文本。
 */
@@ -2532,7 +2704,7 @@ async function basePersonaOf(ctx, agentPreset) {
 * @param ctx - 插件上下文。
 * @param agent - 新建（或恢复）的 agent。
 */
-async function install(ctx, agent) {
+async function installPersona(ctx, agent) {
 	if (agent.session.header.origin === "subagent") return;
 	const agentCtx = agent.ctx;
 	const presetId = ctx.get("agentPresets")?.composedPreset(agentCtx);
@@ -2551,24 +2723,297 @@ async function install(ctx, agent) {
 		...base?.complete === true ? { complete: true } : {}
 	});
 }
-/**
-* 挂载宿主半端：把人格装到每个新建 agent 上，并登记自己的设置入口。
-* @param ctx - 宿主根上下文。
-* @param config - 档案四个字段。
-*/
-function apply(ctx, config) {
-	live.config = config;
-	ctx.inject(["settings"], (child) => {
-		child.effect(() => child.settings.configure({ auto: false }, ctx.fiber));
-	});
-	const reinstall = (agent) => install(ctx, agent).catch((error) => {
-		ctx.logger.warn(`assistant-profile: persona install failed: ${String(error)}`);
-	});
-	ctx.effect(() => ctx.on("agent/created", ({ agent }) => reinstall(agent)), "assistant-profile: persona");
-	ctx.effect(() => ctx.on("agent-preset/selected", (sessionId) => {
-		const agent = ctx.get("agents")?.get(String(sessionId));
-		if (agent !== void 0) reinstall(agent);
-	}), "assistant-profile: preset switch");
+const MEMORY_ADD_DESCRIPTION = "Add one fact to the assistant's long-term memory when the conversation reveals something worth remembering across future sessions: stable preferences, work habits, durable decisions, or facts the human stated as lasting. Remember prose conclusions, not the raw exchange; merge related facts into one entry. Do not store credentials, one-off task details, or anything the human said is transient.";
+/** `memory_add` 的输出结构。 */
+const MEMORY_ADD_VALUE_SCHEMA = {
+	type: "object",
+	additionalProperties: false,
+	properties: {
+		saved: {
+			type: "boolean",
+			required: true
+		},
+		outcome: { type: "string" },
+		content: { type: "string" }
+	}
+};
+/** 把选中的对话文本提炼成记忆条目的指令（与 agent-suite 一致的规则）。 */
+const REMEMBER_INSTRUCTION = "你是一个长期记忆提炼引擎。用户从对话中圈选了下面这段内容，明确希望把它记入助手的长期记忆。请把这些内容提炼成简短、稳定、可跨会话复用的记忆条目。\n规则：\n- 每行输出一条记忆内容本身（不带时间戳、不带 \"- \" 前缀、不带编号）。\n- 用户既然圈选了它，请默认提取出其中明确、稳定的信息：称呼、偏好、习惯、约定、身份事实、项目背景。\n- 把相关事实合并成一条；不要逐字复述，只提炼结论，但保留关键名称、数字、关系。\n- 只有当整段内容完全是临时任务细节或含凭据、密钥时，才不输出条目（此时只输出一个真正的空行）。\n- 用与对话片段一致的语言书写（对话是中文就用中文，是英文就用英文）。\n- 严禁输出\"空行\"\"（空行）\"\"无\"\"没有\"\"none\"之类的占位文字。";
+let AssistantProfile = (() => {
+	let _classSuper = TypertRemoteService;
+	let _instanceExtraInitializers = [];
+	let _readMemory_decorators;
+	let _writeMemory_decorators;
+	let _rememberFromSession_decorators;
+	return class AssistantProfile extends _classSuper {
+		static {
+			const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+			_readMemory_decorators = [Remote("readMemory")];
+			_writeMemory_decorators = [Remote("writeMemory")];
+			_rememberFromSession_decorators = [Remote("rememberFromSession")];
+			__esDecorate(this, null, _readMemory_decorators, {
+				kind: "method",
+				name: "readMemory",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "readMemory" in obj,
+					get: (obj) => obj.readMemory
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _writeMemory_decorators, {
+				kind: "method",
+				name: "writeMemory",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "writeMemory" in obj,
+					get: (obj) => obj.writeMemory
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _rememberFromSession_decorators, {
+				kind: "method",
+				name: "rememberFromSession",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "rememberFromSession" in obj,
+					get: (obj) => obj.rememberFromSession
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			if (_metadata) Object.defineProperty(this, Symbol.metadata, {
+				enumerable: true,
+				configurable: true,
+				writable: true,
+				value: _metadata
+			});
+		}
+		config = __runInitializers(this, _instanceExtraInitializers);
+		static inject = [
+			"systemPrompt",
+			"tools",
+			"llm"
+		];
+		static Config = Config;
+		/** `memory_add` 工具的注册 disposer，只在开关允许时存在。 */
+		toolDisposer;
+		constructor(ctx, config) {
+			super(ctx, "assistantProfile");
+			this.config = config;
+			live.config = config;
+			ctx.inject(["settings"], (child) => {
+				child.effect(() => child.settings.configure({ auto: false }, ctx.fiber));
+			});
+			ctx.effect(() => ctx.systemPrompt.section({
+				name: MEMORY_SECTION,
+				order: MEMORY_ORDER,
+				text: () => {
+					if (config.memoryEnabled.get() !== true) return "";
+					return readMemoryText().trim();
+				}
+			}), "assistant-profile: memory section");
+			const reinstall = (agent) => installPersona(ctx, agent).catch((error) => {
+				ctx.logger.warn(`assistant-profile: persona install failed: ${String(error)}`);
+			});
+			ctx.effect(() => ctx.on("agent/created", ({ agent }) => {
+				reinstall(agent);
+			}), "assistant-profile: persona");
+			ctx.effect(() => ctx.on("agent-preset/selected", (sessionId) => {
+				const agent = ctx.get("agents")?.get(String(sessionId));
+				if (agent !== void 0) reinstall(agent);
+			}), "assistant-profile: preset switch");
+			this.syncTool();
+			ctx.on("loader/volatile-update", () => {
+				this.syncTool();
+			});
+		}
+		/** 按当前开关注册或撤下 `memory_add` 工具。 */
+		syncTool() {
+			const want = this.config.memoryEnabled.get() === true && this.config.autoMemory.get() === true;
+			if (want && this.toolDisposer === void 0) this.toolDisposer = this.registerTool();
+			else if (!want && this.toolDisposer !== void 0) {
+				this.toolDisposer();
+				this.toolDisposer = void 0;
+			}
+		}
+		/** 注册模型侧的记忆工具，返回撤下函数。 */
+		registerTool() {
+			const ctx = this.ctx;
+			const disposer = ctx.tools.register(defineTool({
+				name: "memory_add",
+				description: MEMORY_ADD_DESCRIPTION,
+				parameters: { text: {
+					type: "string",
+					required: true,
+					description: "The stable fact to remember, in its final prose form."
+				} },
+				output: {
+					schema: MEMORY_ADD_VALUE_SCHEMA,
+					render: (_args, value) => {
+						const v = value;
+						if (v.saved) return [{
+							type: "text",
+							text: `记住：${v.content ?? ""}`
+						}];
+						return [{
+							type: "text",
+							text: `未记住：${v.outcome ?? "未启用"}`
+						}];
+					}
+				},
+				execute: async (args, _exec) => {
+					const trimmed = args.text.trim();
+					if (trimmed === "") return {
+						saved: false,
+						outcome: "empty fact"
+					};
+					const result = appendMemory(trimmed);
+					return {
+						saved: true,
+						content: result.content,
+						outcome: result.appended ? "appended" : result.refreshed ? "refreshed" : "unchanged"
+					};
+				}
+			}));
+			const teardown = () => {
+				disposer();
+				this.toolDisposer = void 0;
+			};
+			ctx.effect(() => teardown, "assistant-profile: memory tool");
+			return () => {
+				disposer();
+			};
+		}
+		/** 读取记忆全文（设置页编辑框）。 */
+		readMemory() {
+			return readMemoryText();
+		}
+		/** 整体保存记忆（设置页编辑框的保存按钮）。 */
+		writeMemory(text) {
+			writeMemory(text);
+		}
+		/** 追加一条记忆（内部使用／将来的其它入口）。 */
+		appendMemory(content) {
+			return appendMemory(content);
+		}
+		/**
+		* 用某个会话自己的模型，把选中的对话文本提炼成记忆条目后追加。
+		*
+		* 这是 UI 按钮的路径：用户在弹窗里选一段聊天记录，模型把其中稳定的事实抽出来。
+		* 会话必须是活的（它的 agent 提供模型配置），否则没有可用的 provider/model。
+		* @param sessionId - 执行提炼的会话。
+		* @param text - 选中的对话文本。
+		* @returns 是否写入、写入了哪些条目，以及失败原因。
+		*/
+		async rememberFromSession(sessionId, text) {
+			const agent = this.ctx.get("agents")?.get(SessionId(sessionId));
+			if (agent === void 0) return {
+				saved: false,
+				outcome: "session not open"
+			};
+			const callConfig = (agent.session.requestHeader?.())?.config;
+			if (callConfig === void 0) return {
+				saved: false,
+				outcome: "no provider/model available"
+			};
+			const trimmed = text.trim();
+			if (trimmed === "") return {
+				saved: false,
+				outcome: "empty selection"
+			};
+			const assembler = new BlockAssembler();
+			const messages = [createUserMessage({
+				content: [{
+					type: "text",
+					text: trimmed
+				}],
+				source: { kind: "user" }
+			}), createUserMessage({
+				content: [{
+					type: "text",
+					text: REMEMBER_INSTRUCTION
+				}],
+				source: { kind: "user" }
+			})];
+			try {
+				for await (const chunk of this.ctx.llm.stream({
+					...callConfig,
+					messages,
+					sessionId: SessionId(sessionId)
+				})) assembler.push(chunk);
+			} catch (error) {
+				return {
+					saved: false,
+					outcome: `analysis failed: ${errorChain(error)}`
+				};
+			}
+			const failure = rememberFinishError(assembler.finish);
+			if (failure !== void 0) return {
+				saved: false,
+				outcome: failure
+			};
+			const entries = splitEntries(assembler.blocks());
+			if (entries.length === 0) return {
+				saved: false,
+				outcome: "nothing worth remembering"
+			};
+			for (const entry of entries) appendMemory(entry);
+			return {
+				saved: true,
+				entries,
+				outcome: `remembered ${entries.length} entries`
+			};
+		}
+	};
+})();
+/** 把错误及其 cause 链压成一行。 */
+function errorChain(error) {
+	const parts = [];
+	let current = error;
+	while (typeof current === "object" && current !== null && parts.length < 4) {
+		const message = current.message;
+		if (typeof message !== "string" || message === "") break;
+		parts.push(message);
+		current = current.cause;
+	}
+	return parts.join(" | ");
+}
+/** 把终止原因映射成失败描述（fail-closed）。 */
+function rememberFinishError(finish) {
+	switch (finish.kind) {
+		case "error":
+		case "aborted": return `analysis ${finish.kind}: ${errorChain(finish.failure)}`;
+		case "max-tokens": return "analysis truncated at the token cap";
+		default: return;
+	}
+}
+/** 把模型输出的文本拆成一行一条记忆（去前缀、丢空行、丢占位词）。 */
+function splitEntries(blocks) {
+	const entries = [];
+	for (const block of blocks) {
+		if (block.type !== "text" || typeof block.text !== "string") continue;
+		for (const raw of block.text.split(/\r?\n/)) {
+			const line = stripInvisible(raw.trim().replace(/^[-*]\s+/, "").trim());
+			if (line === "") continue;
+			if (isVacuousEntry(line)) continue;
+			entries.push(line);
+		}
+	}
+	return entries;
+}
+/** 去掉模型可能在正文周围吐出的不可见字符。 */
+function stripInvisible(value) {
+	return value.replace(/[\u0000-\u001F\u007F-\u009F\u00A0\u00AD\u1680\u2000-\u200B\u2028-\u202F\u205F-\u206F\u3000\uFEFF\uFFFD]/g, "").trim();
+}
+/** 这一行是不是「没有内容」的占位词。 */
+function isVacuousEntry(line) {
+	const cleaned = stripInvisible(line);
+	if (cleaned === "") return true;
+	const normalized = cleaned.toLowerCase().replace(/[\s（）()「」"'　\-*—–]+/g, "");
+	return normalized === "" || normalized === "空行" || normalized === "无" || normalized === "没有" || normalized === "无内容" || normalized === "无值得记住的内容" || normalized === "暂无" || normalized === "none" || normalized === "no" || normalized === "nothing" || normalized === "na" || normalized === "n/a";
 }
 //#endregion
-export { Config, apply, name, renderPersona };
+export { Config, MEMORY_DIR, MEMORY_FILE, MEMORY_SECTION, appendMemory, dedupeKey, AssistantProfile as default, isVacuousEntry, memoryPath, name, parseEntries, readMemoryText, renderPersona, stampNow, stripInvisible, writeMemory };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@istarry/dsh-assistant-profile",
   "description": "助理档案：给 DSH 一份全局人格（名称 / 风格 / 语言 / 人格提示词），每个新会话的系统提示最前面都带着它；侧栏「新会话」上方显示助理名",
-  "version": "0.2.1",
+  "version": "0.3.1",
   "icon": "./icon.svg",
   "type": "module",
   "main": "lib/index.js",
@@ -52,6 +52,11 @@
     "@deepseek-ai/dsh-agent": "^0.2.1-rc.2",
     "@deepseek-ai/dsh-agent-preset-registry": "^0.2.1-rc.2",
     "@deepseek-ai/dsh-settings": "^0.2.1-rc.2",
-    "@deepseek-ai/dsh-system-prompt": "^0.2.1-rc.2"
+    "@deepseek-ai/dsh-system-prompt": "^0.2.1-rc.2",
+    "@deepseek-ai/dsh-typert-protocol": "*",
+    "@deepseek-ai/dsh-tools": "*",
+    "@deepseek-ai/dsh-llm": "*",
+    "@deepseek-ai/dsh-session": "*",
+    "@deepseek-ai/dsh-home-paths": "*"
   }
 }