@puwenhui/dsh-rag-kb 0.0.0-stage → 0.1.0

package/README.md

@@ -1,3 +1,101 @@
-# Temporary Holding Version
+# @puwenhui/dsh-rag-kb
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+DSH RAG 知识库插件：**文档导入 → 智能切块 → 本地向量化 → 语义检索**，让 DSH 对话拥有私域知识。
+
+> 面向公司非技术人员的使用帮助请阅读 **[USAGE.zh.md](./USAGE.zh.md)**。
+
+## 核心特性
+
+- **语义检索**：自然语言提问，agent 自动从知识库找答案（中文/英文均可）
+- **多格式支持**：pdf / docx / md / txt / csv / json
+- **完全本地**：向量化模型本地运行（bge-small-zh ONNX），数据不出机器
+- **会话语义管理**：所有操作（添加/删除/保存/检索）直接在对话里用大白话完成
+- **目录自动索引**：配置一个目录，文件放入/变更自动入库
+- **对话内容保存**：把对话中的结论/总结一键存入知识库
+
+## 版本要求
+
+- **DSH ≥ 0.2.0**（依赖 settings 标签页体系与 volatile 字段机制）
+
+## 安装
+
+```sh
+dsh plugin --profile web add @puwenhui/dsh-rag-kb
+```
+
+（源码宿主用 `pnpm dsh plugin --profile web add @puwenhui/dsh-rag-kb`）
+
+## 配置
+
+安装后打开 `dsh web`，**设置 → 插件 →「知识库」**标签页：
+
+| 字段 | 说明 |
+|---|---|
+| 知识库描述 | agent 检索前阅读，知道库里有什么 |
+| 自动索引目录 | 放入文档自动入库（可选） |
+| 检索返回条数 | 默认 5 |
+| 相似度阈值 | 0~1，默认 0.3 |
+
+**首次使用**会自动下载中文向量化模型（约 100MB，下载后完全离线，模型缓存在 `$DSH_HOME/rag-kb/hf-cache/`）。
+
+## 会话语义操作
+
+所有知识库操作直接在对话里说，agent 自动调用对应工具：
+
+| 你说 | agent 调用 |
+|---|---|
+| 「把 D:\docs 加进知识库」 | `knowledge_manage add` |
+| 「把刚才的总结存到知识库」 | `knowledge_manage save` |
+| 「知识库里有什么？」 | `knowledge_status` |
+| 「删掉旧版手册」 | `knowledge_manage remove` |
+| 「根据知识库回答：XXX」 | `knowledge_search` |
+
+## 模型工具（3 个）
+
+| 工具 | 说明 |
+|---|---|
+| `knowledge_search` | 语义检索：query + top_k → 带来源/相似度/原文的结果 |
+| `knowledge_status` | 知识库状态：文档列表/配置/描述 |
+| `knowledge_manage` | 管理操作：save / add / remove / reindex / describe |
+
+## 技术架构
+
+```
+文档 → unpdf/mammoth 提取纯文本
+     → 标题感知切块（400 token + 10% 重叠）
+     → transformers.js 向量化（bge-small-zh-v1.5, 512 维, GPU 自动检测/CPU fallback）
+     → node:sqlite 存储（chunk + 向量 BLOB）
+     → 检索时内存余弦相似 top-K（万级 chunk 毫秒级）
+```
+
+- **向量库**：`node:sqlite`（Node 22.5+ 内置，零 npm 依赖，万级 chunk 内存检索 <50ms）
+- **Embedding**：`@huggingface/transformers` + `Xenova/bge-small-zh-v1.5`（纯 JS ONNX，本地 CPU 3.6ms/chunk）
+- **PDF 解析**：`unpdf`（纯 JS）| **DOCX**：`mammoth`（纯 JS）
+- **数据目录**：`$DSH_HOME/rag-kb/`（index.db + hf-cache/）
+
+## 已知限制
+
+- 单库设计（不分知识库），适合 <1000 篇文档
+- 512 维向量（bge-small-zh），如需多语言可换 bge-m3（1024 维）
+- 附件出站（图片/文件回传 QQ）走路径文本，暂不支持直接推送
+
+## 目录结构
+
+```
+src/           # 宿主半边（工具 + 索引 + 检索 + systemPrompt 注入 + SSE + 目录监视）
+client-src/    # 浏览器半边（设置标签页）
+lib/plugin.mjs # 宿主半边构建产物
+lib/client.js  # 浏览器半边构建产物
+cordis.patch.yml
+```
+
+## 开发
+
+- 宿主半边：`npx tsdown`（产出 lib/plugin.mjs）
+- 浏览器半边：`cd client-src && npm install && npm run build`
+- 部署到本地 profile：构建后复制 `lib/plugin.mjs` 和 `lib/client.js` 到 profile 的 node_modules 目录
+- 发布：bump version → `npm publish`
+
+## License
+
+MIT

package/USAGE.zh.md

@@ -0,0 +1,107 @@
+# DSH 知识库 · 使用帮助
+
+DSH 知识库让你**在对话里拥有自己的私域知识**——把公司文档、技术手册、会议纪要放进去，直接用大白话提问，AI 自动从知识库里找答案。不需要任何技术操作。
+
+---
+
+## 首次使用：两步配置（约 1 分钟 + 模型下载等待）
+
+管理员执行 `dsh plugin --profile web add @puwenhui/dsh-rag-kb` 安装后：
+
+### 第一步：填写知识库描述（所有人必做）
+
+1. 打开 DSH 网页（`dsh web` 启动后浏览器打开的那个地址）
+2. 点左侧栏底部的 **⚙ 设置** → 在左侧列表点 **插件**
+3. 在标签页行点 **「知识库」**
+4. 在「知识库描述」里写一段话，说明知识库里放的是什么类型的内容。例如：
+
+   > 公司产品手册、技术规范、常见问题解答
+
+   这段话 AI 每次检索前都会读到——写得越清楚，AI 越知道什么时候该查知识库。
+
+5. 点 **保存**
+
+> **首次保存后**会自动下载中文向量化模型（约 100MB），下载完成后**完全离线运行**，后续不再需要网络。
+
+### 第二步（可选）：设置自动索引目录
+
+如果你有一个固定的文档目录（如 `D:\公司文档`），可以填在「自动索引目录」里——之后往目录里丢文件就自动入库，不用手动添加。
+
+---
+
+## 日常使用：直接在对话里说
+
+所有知识库操作**不需要打开设置页面**，直接在对话里用大白话说就行：
+
+### 📥 添加文档
+
+> 💬 把 D:\公司文档 目录加进知识库
+> 💬 帮我把这份 PDF 加入知识库：D:\docs\产品手册.pdf
+
+### 💾 保存对话内容
+
+对话中产出了有价值的结论、总结、流程说明？直接说：
+
+> 💬 把刚才的报销流程总结存到知识库
+> 💬 这段分析很好，保存到知识库里
+
+AI 会自动提取内容、起标题、入库。
+
+### 🔍 检索知识
+
+> 💬 根据知识库回答：公司的报销流程是什么？
+> 💬 知识库里有没有关于 XX 系统部署的说明？
+> 💬 查一下产品手册里关于安全设置的部分
+
+### 📋 查看知识库状态
+
+> 💬 知识库里有哪些文档？
+> 💬 知识库里现在有多少个知识块？
+
+### 🗑️ 删除文档
+
+> 💬 删掉知识库里的旧版手册
+> 💬 把那个「对话保存」的文档从知识库移除
+
+---
+
+## 知识库支持哪些文件？
+
+| 格式 | 说明 |
+|---|---|
+| PDF | 扫描件暂不支持（需文字版 PDF） |
+| Word (.docx) | 自动提取正文 |
+| Markdown (.md) | 保留标题结构 |
+| 纯文本 (.txt) | 自动分段 |
+| CSV / JSON | 结构化数据 |
+
+**不支持的**：图片、音视频、加密文档、扫描版 PDF（无文字层）。
+
+---
+
+## 常见问题
+
+**Q：刚添加的文档搜不到？**
+添加后需要几秒钟建索引（切块+向量化）。如果文档很大（如 200 页 PDF），可能需要 10-30 秒。等一下再搜。
+
+**Q：模型下载很慢或失败了？**
+首次使用需要从 HuggingFace 下载约 100MB 模型。如果网络不通，联系管理员获取离线模型包。
+
+**Q：检索结果不准确？**
+尝试以下方法：
+- 把「相似度阈值」调低（如 0.2）——能搜到更多结果
+- 把「相似度阈值」调高（如 0.5）——结果更精准但可能漏掉
+- 在「知识库描述」里写得更具体，帮助 AI 判断什么时候该检索
+
+**Q：能同时存多少文档？**
+建议 1000 篇以内。超过后检索仍可用，但不同主题的文档可能互相干扰。
+
+**Q：数据存在哪里？安全吗？**
+所有数据（文档内容 + 向量索引）存储在你本机的 `$DSH_HOME/rag-kb/` 目录。向量化模型也运行在本机，**文档内容不会发送到任何外部服务器**。
+
+**Q：换电脑怎么办？**
+把 `$DSH_HOME/rag-kb/` 目录整个复制到新电脑的相同位置即可（包含索引库和模型缓存）。
+
+---
+
+*文档随 `@puwenhui/dsh-rag-kb` 插件提供 · 有问题找管理员*

package/cordis.patch.yml

@@ -0,0 +1,4 @@
+# dsh bundle patch: inserts this plugin into a profile's layer stack.
+- insert:
+    - id: rag-kb
+      name: '@puwenhui/dsh-rag-kb'

package/lib/client.js

@@ -0,0 +1,387 @@
+window.__ModuleLoader__.load({ id: "@puwenhui/dsh-rag-kb", factory: (require) => {
+
+
+		var module = { exports: {} };
+		var exports = module.exports;
+		Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+		let react = require("react");
+		let react_jsx_runtime = require("react/jsx-runtime");
+		//#region settings-tab.tsx
+		/**
+		* 设置 → 插件 →「知识库」标签页：配置项 + 使用指引。
+		* 复杂操作按设计走会话语义（对话里说「把 D:\docs 加入知识库」即可），
+		* 面板只承载：检索参数、知识库描述、监视目录 + 操作提示。
+		*/
+		const FIELDS = [
+			{
+				key: "description",
+				label: "知识库描述",
+				type: "string",
+				placeholder: "如：公司产品手册、技术规范、常见问题解答",
+				hint: "agent 检索前会阅读这段描述，知道库里有什么"
+			},
+			{
+				key: "watchDir",
+				label: "自动索引目录",
+				type: "string",
+				placeholder: "D:\\docs",
+				hint: "放入此目录的文档自动监视索引（可选）"
+			},
+			{
+				key: "topK",
+				label: "检索返回条数",
+				type: "number",
+				hint: "默认 5"
+			},
+			{
+				key: "minScore",
+				label: "相似度阈值",
+				type: "number",
+				hint: "0~1，默认 0.3，过低噪音多"
+			}
+		];
+		function KbSettingsTab(props) {
+			const face = props.face;
+			const [ns, setNs] = (0, react.useState)(null);
+			const [view, setView] = (0, react.useState)(null);
+			const [error, setError] = (0, react.useState)(null);
+			const [draft, setDraft] = (0, react.useState)(null);
+			const [saving, setSaving] = (0, react.useState)(false);
+			const [message, setMessage] = (0, react.useState)(null);
+			const [failed, setFailed] = (0, react.useState)(false);
+			const reload = (0, react.useCallback)(async () => {
+				setError(null);
+				if (face === void 0 || typeof face.describe !== "function") {
+					setError("组件未收到设置读写面");
+					return;
+				}
+				const timeout = new Promise((_, reject) => setTimeout(() => reject(/* @__PURE__ */ new Error("settings.describe 8 秒未响应")), 8e3));
+				let result;
+				try {
+					result = await Promise.race([face.describe(), timeout]);
+				} catch (e) {
+					setError(`读取设置失败：${String(e.message)}`);
+					return;
+				}
+				if ("error" in result) {
+					setError(result.error);
+					return;
+				}
+				const rows = result.namespaces ?? [];
+				const hit = rows.find((row) => row.ns === "rag-kb");
+				if (hit === void 0) {
+					setError(`设置视图中未找到 rag-kb 命名空间（共 ${String(rows.length)} 个）`);
+					return;
+				}
+				setNs(hit.ns);
+				setView(hit);
+				setDraft(null);
+			}, [face]);
+			(0, react.useEffect)(() => {
+				reload();
+			}, [reload]);
+			const current = view?.value ?? {};
+			const userLayer = view?.user ?? {};
+			const shown = draft ?? current;
+			const edit = (key, value) => {
+				setMessage(null);
+				setFailed(false);
+				setDraft((prev) => ({
+					...prev ?? { ...current },
+					[key]: value
+				}));
+			};
+			const save = async () => {
+				if (draft === null || ns === null || view === void 0) return;
+				setSaving(true);
+				try {
+					const ops = [];
+					for (const f of FIELDS) {
+						const after = draft[f.key];
+						if (after === void 0 || after === "") continue;
+						const value = f.type === "number" ? Number(after) : after;
+						if (Number.isNaN(value)) continue;
+						if (JSON.stringify(value) === JSON.stringify(current[f.key])) continue;
+						ops.push({
+							op: "set",
+							path: [f.key],
+							value
+						});
+					}
+					if (ops.length > 0) {
+						const result = await face.mutate(ns, ops, view.revision);
+						if (!result.ok) throw new Error(result.error ?? "写入失败");
+					}
+					setDraft(null);
+					setFailed(false);
+					setMessage(ops.length > 0 ? "已保存，插件已按新配置自动重载" : "无更改");
+					await reload();
+				} catch (e) {
+					setFailed(true);
+					setMessage(`保存失败：${String(e.message)}`);
+				} finally {
+					setSaving(false);
+				}
+			};
+			const inputStyle = {
+				width: "100%",
+				padding: "6px 10px",
+				font: "inherit",
+				boxSizing: "border-box",
+				border: "1px solid var(--dsw-alias-border-l2)",
+				borderRadius: "6px",
+				background: "var(--dsw-alias-bg-layer-2)",
+				color: "var(--dsw-alias-label-primary)"
+			};
+			if (error !== null) return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+				style: {
+					...cardStyle,
+					color: "var(--dsw-alias-label-tertiary)"
+				},
+				children: [
+					"知识库配置加载失败：",
+					error,
+					/* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
+						type: "button",
+						onClick: () => {
+							reload();
+						},
+						style: {
+							...btnStyle,
+							marginLeft: "10px"
+						},
+						children: "重试"
+					})
+				]
+			});
+			if (view === null) return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+				style: {
+					...cardStyle,
+					color: "var(--dsw-alias-label-tertiary)"
+				},
+				children: "知识库配置加载中…"
+			});
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", { children: [/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+				style: cardStyle,
+				children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("strong", {
+					style: { fontSize: "14px" },
+					children: "知识库"
+				}), /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+					style: {
+						display: "grid",
+						gridTemplateColumns: "1fr",
+						gap: "10px",
+						marginTop: "12px"
+					},
+					children: [FIELDS.map((f) => {
+						const overridden = Object.hasOwn(userLayer, f.key);
+						return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("label", {
+							style: {
+								display: "flex",
+								flexDirection: "column",
+								gap: "4px",
+								fontSize: "13px"
+							},
+							children: [
+								/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("span", {
+									style: { color: "var(--dsw-alias-label-secondary)" },
+									children: [f.label, overridden && /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+										style: {
+											marginLeft: "6px",
+											color: "var(--dsw-alias-brand-primary)"
+										},
+										children: "·已覆盖"
+									})]
+								}),
+								/* @__PURE__ */ (0, react_jsx_runtime.jsx)("input", {
+									value: draft !== null && draft[f.key] !== void 0 ? String(draft[f.key]) : String(shown[f.key] ?? ""),
+									placeholder: f.placeholder ?? "",
+									onChange: (e) => {
+										edit(f.key, e.target.value);
+									},
+									style: inputStyle
+								}),
+								f.hint !== void 0 && /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+									style: {
+										fontSize: "11px",
+										color: "var(--dsw-alias-label-tertiary)"
+									},
+									children: f.hint
+								})
+							]
+						}, f.key);
+					}), /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+						style: {
+							display: "flex",
+							alignItems: "center",
+							gap: "10px",
+							marginTop: "4px"
+						},
+						children: [
+							/* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
+								type: "button",
+								disabled: saving || draft === null,
+								onClick: () => {
+									save();
+								},
+								style: {
+									padding: "6px 16px",
+									borderRadius: "6px",
+									font: "inherit",
+									border: "1px solid var(--dsw-alias-brand-primary)",
+									background: "var(--dsw-alias-brand-primary)",
+									color: "var(--dsw-alias-label-primary-foreground)",
+									cursor: draft === null ? "default" : "pointer",
+									opacity: draft === null ? .6 : 1
+								},
+								children: saving ? "保存中…" : "保存"
+							}),
+							draft !== null && /* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
+								type: "button",
+								disabled: saving,
+								onClick: () => {
+									setDraft(null);
+									setMessage(null);
+									setFailed(false);
+								},
+								style: {
+									padding: "6px 16px",
+									border: "1px solid var(--dsw-alias-border-l2)",
+									borderRadius: "6px",
+									background: "transparent",
+									font: "inherit",
+									color: "var(--dsw-alias-label-secondary)",
+									cursor: "pointer"
+								},
+								children: "放弃更改"
+							}),
+							message !== null && /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+								style: {
+									fontSize: "12px",
+									color: failed ? "var(--dsw-alias-label-error)" : "var(--dsw-alias-label-secondary)"
+								},
+								children: message
+							})
+						]
+					})]
+				})]
+			}), /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+				style: {
+					...cardStyle,
+					marginTop: "12px",
+					color: "var(--dsw-alias-label-secondary)"
+				},
+				children: [
+					/* @__PURE__ */ (0, react_jsx_runtime.jsx)("strong", {
+						style: { fontSize: "13px" },
+						children: "💡 知识库管理：直接在对话里说"
+					}),
+					/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+						style: {
+							marginTop: "8px",
+							lineHeight: 1.8,
+							fontSize: "13px"
+						},
+						children: [
+							/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", { children: [
+								"💬 「把 ",
+								/* @__PURE__ */ (0, react_jsx_runtime.jsx)("code", {
+									style: {
+										background: "var(--dsw-alias-bg-layer-2)",
+										padding: "1px 4px",
+										borderRadius: "3px"
+									},
+									children: "D:\\docs"
+								}),
+								" 目录加入知识库」"
+							] }),
+							/* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", { children: "💬 「知识库里有哪些文档？」" }),
+							/* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", { children: "💬 「删掉知识库里的旧版手册」" }),
+							/* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", { children: "💬 「根据知识库回答：报销流程是什么？」" })
+						]
+					}),
+					/* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+						style: {
+							marginTop: "8px",
+							fontSize: "11px",
+							color: "var(--dsw-alias-label-tertiary)"
+						},
+						children: "支持 pdf / docx / md / txt / csv / json；文件内容变化自动重新索引。 首次使用会自动下载中文向量化模型（约 100MB，下载后完全离线）。"
+					})
+				]
+			})] });
+		}
+		const cardStyle = {
+			border: "1px solid var(--dsw-alias-border-l2)",
+			borderRadius: "10px",
+			padding: "14px 16px",
+			background: "var(--dsw-alias-bg-layer-3)",
+			font: "13px/1.5 system-ui, \"Segoe UI\", \"Microsoft YaHei\", sans-serif",
+			color: "var(--dsw-alias-label-primary)"
+		};
+		const btnStyle = {
+			padding: "6px 12px",
+			border: "1px solid var(--dsw-alias-border-l2)",
+			borderRadius: "6px",
+			background: "transparent",
+			color: "inherit",
+			font: "inherit",
+			cursor: "pointer",
+			whiteSpace: "nowrap"
+		};
+		//#endregion
+		//#region index.tsx
+		const name = "dsh-rag-kb";
+		const inject = [
+			"slots",
+			"locale",
+			"remote",
+			"remote.settings"
+		];
+		const NS = "dsh-rag-kb";
+		const zh = { tab: "知识库" };
+		const en = { tab: "Knowledge" };
+		function apply(ctx) {
+			ctx.effect(() => {
+				try {
+					ctx.locale.register(NS, {
+						zh,
+						en
+					});
+				} catch {}
+				const t = (key) => zh[key] ?? String(key);
+				const face = {
+					describe: async () => {
+						const response = await ctx.remote.settings.describe();
+						return response.ok && response.value !== void 0 ? { namespaces: response.value.namespaces } : { error: response.error?.message ?? "settings.describe failed" };
+					},
+					mutate: async (ns, ops, revision) => {
+						const response = await ctx.remote.settings.mutate(ns, ops, revision);
+						return response.ok ? { ok: true } : {
+							ok: false,
+							error: response.error?.message ?? "settings.mutate failed"
+						};
+					}
+				};
+				const offTab = ctx.slots.inject("settings.plugins.tab", () => ctx.slots.register({
+					name: "settings.plugins.tab",
+					id: "rag-kb",
+					order: 50,
+					label: () => t("tab"),
+					locale: NS,
+					inject: () => ({ face })
+				}, KbSettingsTab));
+				return () => {
+					offTab();
+				};
+			}, "dsh-rag-kb: settings tab");
+		}
+		//#endregion
+		exports.apply = apply;
+		exports.inject = inject;
+		exports.name = name;
+		return module.exports;
+	}
+});
+
+//# sourceMappingURL=client.js.map

package/lib/plugin.mjs

@@ -0,0 +1,657 @@
+import { createRequire } from "node:module";
+import { existsSync, mkdirSync, statSync, watch } from "node:fs";
+import { basename, extname, join, resolve } from "node:path";
+import z from "@deepseek-ai/schemastery";
+import { createHash } from "node:crypto";
+import { readFile } from "node:fs/promises";
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+var __require = /* #__PURE__ */ (() => createRequire(import.meta.url))();
+//#endregion
+//#region src/config.ts
+/**
+* RAG 知识库插件配置：schemastery schema，全字段 volatile（0.2.0 设置体系要求）。
+* 由 build 脚本编译打包为 lib/plugin.mjs。
+*/
+/** 用户可见配置（设置面板「知识库」标签页） */
+const PublicConfig = z.object({
+	watchDir: z.string().default("").description("本地文档目录（放入即自动索引）"),
+	topK: z.number().default(5).description("检索返回条数（默认 5）"),
+	minScore: z.number().default(.3).description("相似度阈值（0~1，默认 0.3）"),
+	description: z.string().default("").description("知识库描述（agent 检索前会阅读）")
+});
+/** 完整配置（含高级项） */
+const Config = z.object({
+	watchDir: z.string().default("").description("本地文档目录"),
+	topK: z.number().default(5).description("检索返回条数"),
+	minScore: z.number().default(.3).description("相似度阈值"),
+	description: z.string().default("").description("知识库描述"),
+	embeddingModel: z.string().default("Xenova/bge-small-zh-v1.5").description("embedding 模型"),
+	batchSize: z.number().default(32).description("批量推理大小")
+});
+/** 全字段 volatile 注入（npm 版 schemastery 无 .volatile()，0.2.0 设置面板只收录 volatile 字段） */
+for (const schema of [PublicConfig, Config]) for (const child of Object.values(schema.dict ?? {})) child.meta.volatile = true;
+/** 解析后的配置快照 */
+function resolveKbConfig(c = {}) {
+	return {
+		watchDir: c.watchDir ?? "",
+		topK: Math.max(1, Math.min(50, c.topK ?? 5)),
+		minScore: Math.max(0, Math.min(1, c.minScore ?? .3)),
+		description: c.description ?? "",
+		embeddingModel: c.embeddingModel ?? "Xenova/bge-small-zh-v1.5",
+		batchSize: Math.max(1, Math.min(128, c.batchSize ?? 32))
+	};
+}
+//#endregion
+//#region src/store.ts
+/**
+* 向量索引库：node:sqlite（DSH 宿主先例模式）。
+* 表结构：documents（文档元数据）+ chunks（切块 + 向量 blob）。
+* 检索：向量全量载入内存 → 余弦相似 top-K（万级 chunk 毫秒级）。
+*/
+/** 库归属标识（PRAGMA application_id，抄宿主 session-query-sqlite 惯例） */
+const APP_ID = 1380009794;
+const SCHEMA_VERSION = 1;
+var KbStore = class {
+	db;
+	vectors = [];
+	vectorRows = [];
+	loaded = false;
+	constructor(dbPath) {
+		const { DatabaseSync } = __require("node:sqlite");
+		mkdirSync(join(dbPath, ".."), { recursive: true });
+		this.db = new DatabaseSync(dbPath);
+		this.db.exec("PRAGMA journal_mode=WAL;");
+		const appId = this.db.prepare("PRAGMA application_id").get().application_id;
+		if (appId !== 0 && appId !== APP_ID) throw new Error(`rag-kb: ${dbPath} belongs to another application`);
+		this.db.exec(`PRAGMA application_id = ${APP_ID}; PRAGMA user_version = ${SCHEMA_VERSION};`);
+		this.db.exec(`
+      CREATE TABLE IF NOT EXISTS documents(
+        doc_id TEXT PRIMARY KEY,
+        name TEXT NOT NULL,
+        source TEXT NOT NULL DEFAULT 'upload',
+        bytes INTEGER NOT NULL DEFAULT 0,
+        chunk_count INTEGER NOT NULL DEFAULT 0,
+        status TEXT NOT NULL DEFAULT 'pending',
+        error TEXT NOT NULL DEFAULT '',
+        created_at TEXT NOT NULL DEFAULT '',
+        updated_at TEXT NOT NULL DEFAULT ''
+      );
+      CREATE TABLE IF NOT EXISTS chunks(
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        doc_id TEXT NOT NULL,
+        seq INTEGER NOT NULL,
+        text TEXT NOT NULL,
+        embedding BLOB NOT NULL,
+        FOREIGN KEY(doc_id) REFERENCES documents(doc_id) ON DELETE CASCADE
+      );
+      CREATE INDEX IF NOT EXISTS idx_chunks_doc ON chunks(doc_id);
+    `);
+	}
+	/** 文档内容 hash 作 doc_id（同名不同内容=不同文档） */
+	static docId(content) {
+		return createHash("sha256").update(content).digest("hex").slice(0, 16);
+	}
+	hasDoc(docId) {
+		return this.db.prepare("SELECT 1 FROM documents WHERE doc_id=?").get(docId) !== void 0;
+	}
+	upsertDoc(docId, name, source, bytes, status, error = "") {
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		this.db.prepare(`
+      INSERT INTO documents(doc_id, name, source, bytes, chunk_count, status, error, created_at, updated_at)
+      VALUES(?,?,?,?,0,?,?,?,?)
+      ON CONFLICT(doc_id) DO UPDATE SET name=excluded.name, bytes=excluded.bytes, status=excluded.status, error=excluded.error, updated_at=excluded.updated_at
+    `).run(docId, name, source, bytes, status, error, now, now);
+		this.loaded = false;
+	}
+	setDocStatus(docId, status, chunkCount, error = "") {
+		this.db.prepare("UPDATE documents SET status=?, chunk_count=?, error=?, updated_at=? WHERE doc_id=?").run(status, chunkCount, error, (/* @__PURE__ */ new Date()).toISOString(), docId);
+		this.loaded = false;
+	}
+	deleteDoc(docId) {
+		this.db.prepare("DELETE FROM chunks WHERE doc_id=?").run(docId);
+		this.db.prepare("DELETE FROM documents WHERE doc_id=?").run(docId);
+		this.loaded = false;
+	}
+	listDocs() {
+		return this.db.prepare("SELECT * FROM documents ORDER BY updated_at DESC").all();
+	}
+	getDoc(docId) {
+		return this.db.prepare("SELECT * FROM documents WHERE doc_id=?").get(docId);
+	}
+	/** 批量写入切块+向量（一个事务，失败回滚） */
+	insertChunks(docId, chunks) {
+		this.db.exec("BEGIN");
+		try {
+			this.db.prepare("DELETE FROM chunks WHERE doc_id=?").run(docId);
+			const stmt = this.db.prepare("INSERT INTO chunks(doc_id, seq, text, embedding) VALUES(?,?,?,?)");
+			for (const c of chunks) stmt.run(docId, c.seq, c.text, Buffer.from(c.embedding.buffer, c.embedding.byteOffset, c.embedding.byteLength));
+			this.db.exec("COMMIT");
+		} catch (e) {
+			this.db.exec("ROLLBACK");
+			throw e;
+		}
+		this.loaded = false;
+	}
+	/** 惰性加载全部向量到内存（首次或写后失效） */
+	ensureLoaded() {
+		if (this.loaded) return;
+		this.vectors = [];
+		this.vectorRows = [];
+		const rows = this.db.prepare("SELECT c.doc_id, c.seq, c.embedding FROM chunks c JOIN documents d ON d.doc_id=c.doc_id WHERE d.status='ready'").all();
+		for (const row of rows) {
+			this.vectors.push(new Float32Array(row.embedding.buffer, row.embedding.byteOffset, row.embedding.byteLength / 4));
+			this.vectorRows.push({
+				docId: row.doc_id,
+				seq: row.seq
+			});
+		}
+		this.loaded = true;
+	}
+	/** 余弦相似检索（向量已归一化，等价点积） */
+	search(queryVec, topK, minScore) {
+		this.ensureLoaded();
+		const scored = [];
+		for (let i = 0; i < this.vectors.length; i++) {
+			const v = this.vectors[i];
+			let dot = 0;
+			for (let j = 0; j < queryVec.length; j++) dot += queryVec[j] * v[j];
+			if (dot >= minScore) scored.push({
+				docId: this.vectorRows[i].docId,
+				seq: this.vectorRows[i].seq,
+				score: dot
+			});
+		}
+		scored.sort((a, b) => b.score - a.score);
+		return scored.slice(0, topK);
+	}
+	/** 按 doc_id + seq 取 chunk 原文 */
+	chunkText(docId, seq) {
+		return this.db.prepare("SELECT text FROM chunks WHERE doc_id=? AND seq=?").get(docId, seq)?.text ?? "";
+	}
+	close() {
+		this.db.close();
+	}
+};
+//#endregion
+//#region src/indexer.ts
+/**
+* 文档管线：解析（pdf/docx/md/txt）→ 切块（标题感知 + 固定长度 fallback）→ 批量向量化。
+* Embedding: transformers.js（GPU 加速优先，ONNX Runtime 自动检测 CUDA/WebGPU/CPU）。
+*/
+var indexer_exports = /* @__PURE__ */ __exportAll({
+	chunkText: () => chunkText,
+	extractText: () => extractText,
+	getEmbedder: () => getEmbedder,
+	indexFile: () => indexFile
+});
+/** 中文友好的切块参数 */
+const CHUNK_TOKENS = 400;
+const OVERLAP_RATIO = .1;
+async function extractText(filePath) {
+	const ext = extname(filePath).toLowerCase();
+	const buf = await readFile(filePath);
+	if (ext === ".pdf") {
+		const { extractText: pdfExtract, getDocumentProxy } = await import("unpdf");
+		const { text, totalPages } = await pdfExtract(await getDocumentProxy(new Uint8Array(buf)), { mergePages: true });
+		return {
+			text,
+			pages: totalPages
+		};
+	}
+	if (ext === ".docx") {
+		const { value: html } = await (await import("mammoth")).extractRawText({ buffer: buf });
+		return { text: html };
+	}
+	if (ext === ".md" || ext === ".txt" || ext === ".log" || ext === ".csv" || ext === ".json") return { text: buf.toString("utf8") };
+	throw new Error(`不支持的文件类型 ${ext}（支持 pdf/docx/md/txt/csv/json）`);
+}
+/** 标题感知切块：按标题/空行分段，过长段再固定长度切 */
+function chunkText(text) {
+	const normalized = text.replace(/\r\n/g, "\n").replace(/\n{3,}/g, "\n\n").trim();
+	if (normalized === "") return [];
+	const paragraphs = normalized.split(/\n(?=#{1,4} )|\n\n+/).map((p) => p.trim()).filter((p) => p !== "");
+	const chunks = [];
+	let current = "";
+	const maxChars = CHUNK_TOKENS * 1.5;
+	const overlap = Math.floor(maxChars * OVERLAP_RATIO);
+	for (const para of paragraphs) {
+		if (current !== "" && (current + "\n" + para).length > maxChars) {
+			chunks.push(current);
+			current = current.length > overlap ? current.slice(-60) : "";
+		}
+		if (para.length > maxChars * 2) {
+			if (current !== "") {
+				chunks.push(current);
+				current = "";
+			}
+			for (let i = 0; i < para.length; i += 540) chunks.push(para.slice(i, i + maxChars));
+			continue;
+		}
+		current = current === "" ? para : current + "\n" + para;
+	}
+	if (current !== "") chunks.push(current);
+	return chunks.filter((c) => c.trim().length >= 10);
+}
+let pipelinePromise;
+async function loadPipeline(modelName) {
+	const { pipeline, env } = await import("@huggingface/transformers");
+	const { dshHomePath } = await import("@deepseek-ai/dsh-home-paths");
+	env.cacheDir = dshHomePath("rag-kb", "hf-cache");
+	return pipeline("feature-extraction", modelName);
+}
+async function getEmbedder(modelName) {
+	pipelinePromise ??= loadPipeline(modelName);
+	const embedder = await pipelinePromise;
+	return {
+		/** 单条向量化（检索查询用） */
+		async embed(text) {
+			const out = await embedder(text, {
+				pooling: "cls",
+				normalize: true
+			});
+			return new Float32Array(out.data);
+		},
+		/** 批量向量化（索引用，batch 推理吃满多核/GPU） */
+		async embedBatch(texts, batchSize) {
+			const results = [];
+			for (let i = 0; i < texts.length; i += batchSize) {
+				const batch = texts.slice(i, i + batchSize);
+				const out = await embedder(batch, {
+					pooling: "cls",
+					normalize: true
+				});
+				const dim = out.data.length / batch.length;
+				for (let j = 0; j < batch.length; j++) results.push(new Float32Array(out.data.slice(j * dim, (j + 1) * dim)));
+			}
+			return results;
+		}
+	};
+}
+/** 完整索引管线：文件路径 → 切块+向量数组 */
+async function indexFile(filePath, embedder, batchSize, onProgress) {
+	const { text } = await extractText(filePath);
+	const pieces = chunkText(text);
+	if (pieces.length === 0) return [];
+	const embeddings = await embedder.embedBatch(pieces, batchSize);
+	if (onProgress) onProgress(pieces.length, pieces.length);
+	return pieces.map((piece, i) => ({
+		seq: i,
+		text: piece,
+		embedding: embeddings[i]
+	}));
+}
+//#endregion
+//#region src/plugin.ts
+/**
+* DSH RAG 知识库插件宿主半边入口。
+* - 模型工具：knowledge_search / knowledge_status / knowledge_manage（会话语义管理）
+* - systemPrompt 注入：agent 自动知道知识库
+* - SSE 通道：索引进度推送（浏览器面板用）
+* - 目录监视：watchDir 下的文档自动索引（V2 能力，V1 已生效）
+*/
+const name = "rag-kb";
+const inject = [
+	"tools",
+	"systemPrompt",
+	"settings"
+];
+let store;
+let cfg;
+const progressListeners = /* @__PURE__ */ new Set();
+function broadcastProgress(msg) {
+	for (const write of progressListeners) try {
+		write(`event: progress\ndata: ${JSON.stringify(msg)}\n\n`);
+	} catch {}
+}
+async function ensureStore() {
+	if (store !== void 0) return store;
+	const { dshHomePath } = await import("@deepseek-ai/dsh-home-paths");
+	store = new KbStore(dshHomePath("rag-kb", "index.db"));
+	return store;
+}
+/** 索引一个文件路径（upload 或 watch 共用） */
+async function indexOne(ctx, filePath, source) {
+	const s = await ensureStore();
+	const name = basename(filePath);
+	const bytes = statSync(filePath).size;
+	const content = await (await import("node:fs/promises")).readFile(filePath);
+	const docId = KbStore.docId(content);
+	if (s.hasDoc(docId) && s.getDoc(docId)?.status === "ready") return {
+		ok: true,
+		message: `${name} 已索引（内容未变化，跳过）`
+	};
+	s.upsertDoc(docId, name, source, bytes, "indexing");
+	broadcastProgress(`正在索引 ${name}`);
+	try {
+		const chunks = await indexFile(filePath, await getEmbedder(cfg?.embeddingModel ?? "Xenova/bge-small-zh-v1.5"), cfg?.batchSize ?? 32);
+		s.insertChunks(docId, chunks.map((c) => ({
+			seq: c.seq,
+			text: c.text,
+			embedding: c.embedding
+		})));
+		s.setDocStatus(docId, "ready", chunks.length);
+		broadcastProgress(`${name} 索引完成（${chunks.length} 块）`);
+		return {
+			ok: true,
+			message: `${name} 索引完成，共 ${chunks.length} 个知识块`
+		};
+	} catch (e) {
+		const msg = String(e.message ?? e);
+		s.setDocStatus(docId, "failed", 0, msg);
+		broadcastProgress(`${name} 索引失败：${msg}`);
+		return {
+			ok: false,
+			message: `${name} 索引失败：${msg}`
+		};
+	}
+}
+/** 语义检索 */
+async function search(query, topK) {
+	const s = await ensureStore();
+	const queryVec = await (await getEmbedder(cfg?.embeddingModel ?? "Xenova/bge-small-zh-v1.5")).embed(query);
+	return s.search(queryVec, topK ?? cfg?.topK ?? 5, cfg?.minScore ?? .3).map((h) => ({
+		doc: s.getDoc(h.docId)?.name ?? h.docId,
+		seq: h.seq,
+		score: Number(h.score.toFixed(3)),
+		text: s.chunkText(h.docId, h.seq).slice(0, 800)
+	}));
+}
+function apply(ctx, config = {}) {
+	const unwrap = (v) => v !== null && typeof v === "object" && "get" in v ? v.get() : v;
+	const raw = {};
+	for (const [k, v] of Object.entries(config)) raw[k] = unwrap(v);
+	cfg = resolveKbConfig(raw);
+	ctx.inject(["webServer"], (hostCtx) => {
+		hostCtx.webServer.register({
+			kind: "exact",
+			path: "/rag-kb/progress",
+			handler: (req, res) => {
+				res.writeHead(200, {
+					"content-type": "text/event-stream",
+					"cache-control": "no-store",
+					connection: "keep-alive"
+				});
+				res.write("retry: 3000\n\n");
+				const write = (chunk) => res.write(chunk);
+				progressListeners.add(write);
+				const heartbeat = setInterval(() => {
+					try {
+						res.write(": ping\n\n");
+					} catch {}
+				}, 25e3);
+				req.on("close", () => {
+					clearInterval(heartbeat);
+					progressListeners.delete(write);
+				});
+			}
+		});
+	});
+	if (cfg.watchDir !== "" && existsSync(cfg.watchDir)) {
+		const dir = resolve(cfg.watchDir);
+		try {
+			const watcher = watch(dir, { persistent: false }, (_ev, filename) => {
+				if (filename === null || filename === void 0) return;
+				const fname = String(filename);
+				if (!/\.(pdf|docx|md|txt|csv|json|log)$/i.test(fname)) return;
+				const f = join(dir, fname);
+				setTimeout(() => {
+					if (existsSync(f)) indexOne(ctx, f, "watch");
+				}, 2e3);
+			});
+			ctx.effect(() => {
+				watcher.close();
+			}, "rag-kb: dir watcher");
+		} catch (e) {
+			console.warn(`[rag-kb] 目录监视失败 ${dir}: ${String(e.message)}`);
+		}
+	}
+	const compileParams = (spec) => {
+		const properties = {};
+		const required = [];
+		for (const [key, def] of Object.entries(spec)) {
+			const { required: req, ...rest } = def;
+			properties[key] = rest;
+			if (req === true) required.push(key);
+		}
+		return {
+			type: "object",
+			properties,
+			...required.length > 0 ? { required } : {}
+		};
+	};
+	const disposers = [
+		ctx.tools.register({
+			name: "knowledge_search",
+			description: "在本地知识库中语义检索。返回最相关的知识块（带来源文档名、相似度、原文片段）。回答与知识库内容相关的问题前应先检索。query 支持自然语言。",
+			parameters: compileParams({
+				query: {
+					type: "string",
+					required: true,
+					description: "检索问题（自然语言，中英文均可）"
+				},
+				top_k: {
+					type: "number",
+					description: "返回条数（默认 5）"
+				}
+			}),
+			output: {
+				schema: {},
+				render: (_a, v) => [{
+					type: "text",
+					text: JSON.stringify(v)
+				}]
+			},
+			async execute(args) {
+				const a = args;
+				const hits = await search(a.query, a.top_k);
+				return {
+					ok: true,
+					count: hits.length,
+					results: hits
+				};
+			}
+		}),
+		ctx.tools.register({
+			name: "knowledge_status",
+			description: "查看知识库状态：已索引文档列表（名称/大小/块数/状态）、配置参数、知识库描述。",
+			parameters: compileParams({}),
+			output: {
+				schema: {},
+				render: (_a, v) => [{
+					type: "text",
+					text: JSON.stringify(v)
+				}]
+			},
+			async execute() {
+				const s = await ensureStore();
+				return {
+					ok: true,
+					description: cfg?.description ?? "",
+					topK: cfg?.topK,
+					minScore: cfg?.minScore,
+					documents: s.listDocs().map((d) => ({
+						name: d.name,
+						source: d.source,
+						bytes: d.bytes,
+						chunks: d.chunk_count,
+						status: d.status,
+						...d.error !== "" ? { error: d.error } : {}
+					}))
+				};
+			}
+		}),
+		ctx.tools.register({
+			name: "knowledge_manage",
+			description: "知识库管理操作（用户在对话中用自然语言请求时调用）。支持：save（把对话中的内容直接保存入库，给 title + text）、add（索引本地文件路径或目录）、remove（按文档名删除）、reindex（重建全部索引）、describe（设置知识库描述）。用户说「存到知识库」「把这个记下来」时用 save。",
+			parameters: compileParams({
+				action: {
+					type: "string",
+					required: true,
+					description: "add | remove | reindex | describe"
+				},
+				path: {
+					type: "string",
+					description: "add：本地文件或目录路径"
+				},
+				title: {
+					type: "string",
+					description: "save：文档标题（会成为知识库里的文档名）"
+				},
+				text: {
+					type: "string",
+					description: "save：要保存的文本内容（直接从对话中提取，无需先写文件）"
+				},
+				name: {
+					type: "string",
+					description: "remove：要删除的文档名"
+				},
+				description: {
+					type: "string",
+					description: "describe：知识库描述文本"
+				}
+			}),
+			output: {
+				schema: {},
+				render: (_a, v) => [{
+					type: "text",
+					text: JSON.stringify(v)
+				}]
+			},
+			async execute(args) {
+				const a = args;
+				const s = await ensureStore();
+				if (a.action === "save" && a.text !== void 0 && a.text !== "") {
+					const title = a.title !== void 0 && a.title !== "" ? a.title : `对话保存 ${(/* @__PURE__ */ new Date()).toISOString().slice(0, 16)}`;
+					const content = `# ${title}\n\n${a.text}`;
+					const docId = KbStore.docId(content);
+					if (s.hasDoc(docId) && s.getDoc(docId)?.status === "ready") return {
+						ok: true,
+						message: `${title} 已在知识库中（内容相同，跳过）`
+					};
+					s.upsertDoc(docId, title, "save", content.length, "indexing");
+					broadcastProgress(`正在索引对话内容「${title}」`);
+					try {
+						const embedder = await getEmbedder(cfg?.embeddingModel ?? "Xenova/bge-small-zh-v1.5");
+						const { chunkText } = await Promise.resolve().then(() => indexer_exports);
+						const pieces = chunkText(content);
+						if (pieces.length === 0) return {
+							ok: false,
+							error: "内容太短或为空，无法切块"
+						};
+						const embeddings = await embedder.embedBatch(pieces, cfg?.batchSize ?? 32);
+						s.insertChunks(docId, pieces.map((piece, i) => ({
+							seq: i,
+							text: piece,
+							embedding: embeddings[i]
+						})));
+						s.setDocStatus(docId, "ready", pieces.length);
+						broadcastProgress(`「${title}」已入库（${pieces.length} 块）`);
+						return {
+							ok: true,
+							message: `已保存「${title}」到知识库，共 ${pieces.length} 个知识块`
+						};
+					} catch (e) {
+						const msg = String(e.message ?? e);
+						s.setDocStatus(docId, "failed", 0, msg);
+						return {
+							ok: false,
+							error: `索引失败：${msg}`
+						};
+					}
+				}
+				if (a.action === "add" && a.path) {
+					const p = resolve(a.path);
+					if (!existsSync(p)) return {
+						ok: false,
+						error: `路径不存在：${p}`
+					};
+					if (statSync(p).isFile()) {
+						const r = await indexOne(ctx, p, "upload");
+						return {
+							ok: r.ok,
+							message: r.message
+						};
+					}
+					const { readdir } = await import("node:fs/promises");
+					const files = (await readdir(p)).filter((f) => /\.(pdf|docx|md|txt|csv|json|log)$/i.test(f)).map((f) => join(p, f));
+					const results = [];
+					for (const f of files) {
+						const r = await indexOne(ctx, f, "upload");
+						results.push(r.message);
+					}
+					return {
+						ok: true,
+						message: `批量索引 ${files.length} 个文件`,
+						detail: results
+					};
+				}
+				if (a.action === "remove" && a.name) {
+					const docs = s.listDocs().filter((d) => d.name.includes(a.name));
+					if (docs.length === 0) return {
+						ok: false,
+						error: `未找到包含「${a.name}」的文档`
+					};
+					for (const d of docs) s.deleteDoc(d.doc_id);
+					return {
+						ok: true,
+						message: `已删除 ${docs.length} 个文档：${docs.map((d) => d.name).join(", ")}`
+					};
+				}
+				if (a.action === "reindex") {
+					const docs = s.listDocs();
+					for (const d of docs) s.setDocStatus(d.doc_id, "pending", 0);
+					return {
+						ok: true,
+						message: `已重置 ${docs.length} 个文档为待索引。请用户通过设置面板或重新 add 触发重建（文件源路径不再保留，需重新添加）。`
+					};
+				}
+				if (a.action === "describe" && a.description !== void 0) return {
+					ok: true,
+					message: `知识库描述已记录（当前会话生效）。持久化请通过设置面板「知识库描述」字段。`,
+					description: a.description
+				};
+				return {
+					ok: false,
+					error: `未知操作 ${a.action}（支持 save/add/remove/reindex/describe）`
+				};
+			}
+		})
+	];
+	ctx.effect(() => () => {
+		for (const d of disposers) d();
+	}, "rag-kb: tools");
+	const promptText = () => {
+		const desc = cfg?.description ?? "";
+		const docs = store?.listDocs().filter((d) => d.status === "ready").length ?? 0;
+		return [
+			"You have a local knowledge base accessible via these tools:",
+			"- knowledge_search: semantic search the KB (use BEFORE answering questions about its content)",
+			"- knowledge_status: list documents and config",
+			"- knowledge_manage: add/save/remove/reindex documents",
+			desc !== "" ? `KB description: ${desc}` : "",
+			`Currently ${docs} document(s) indexed.`,
+			"When the user says \"save this to the knowledge base\" (保存到知识库/记下来), extract the valuable content from the conversation and call knowledge_manage with action=\"save\", providing a concise title and the text.",
+			"For file/directory indexing use action=\"add\" with a path."
+		].filter(Boolean).join("\n");
+	};
+	ctx.systemPrompt.section({
+		name: "tool:rag-kb",
+		order: 2350,
+		text: promptText,
+		interpolate: false
+	});
+}
+//#endregion
+export { Config, KbStore, apply, chunkText, extractText, getEmbedder, indexFile, inject, name, resolveKbConfig };
+
+//# sourceMappingURL=plugin.mjs.map

package/package.json

@@ -1,6 +1,57 @@
 {
   "name": "@puwenhui/dsh-rag-kb",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "DSH RAG 知识库插件：文档导入→切块→本地向量化→语义检索，knowledge_search 工具 + 会话语义管理 + 设置面板",
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Puwenhui-Me/dsh-rag-kb.git"
+  },
+  "homepage": "https://github.com/Puwenhui-Me/dsh-rag-kb#readme",
+  "type": "module",
+  "main": "lib/plugin.mjs",
+  "exports": {
+    ".": "./lib/plugin.mjs",
+    "./client": "./lib/client.js",
+    "./cordis.patch.yml": "./cordis.patch.yml",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "lib/plugin.mjs",
+    "lib/client.js",
+    "cordis.patch.yml",
+    "README.md",
+    "USAGE.zh.md"
+  ],
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "platform": "web",
+      "inject": [
+        "@deepseek-ai/dsh-client-connection",
+        "@deepseek-ai/dsh-client-locale",
+        "@deepseek-ai/dsh-client-ui-theme"
+      ]
+    }
+  },
+  "dependencies": {
+    "@deepseek-ai/schemastery": "^3.18.2",
+    "@huggingface/transformers": "^3.7.2",
+    "mammoth": "^1.11.0",
+    "unpdf": "^0.12.1"
+  },
+  "peerDependencies": {
+    "@deepseek-ai/cordis": "^4.0.1"
+  },
+  "devDependencies": {
+    "@deepseek-ai/cordis": "^4.0.4",
+    "tsdown": "^0.23.0",
+    "typescript": "^7.0.2"
+  },
+  "license": "MIT"
+}