opencode-haimati 1.0.2

package/README.md

@@ -0,0 +1,100 @@
+# opencode-haimati
+
+海马体记忆系统插件 - 为 OpenCode 提供基于文件系统的长期记忆存储和检索功能。
+
+## 功能特性
+
+- 🧠 类海马体记忆机制：模拟人脑记忆系统的分类存储
+- 📁 树形索引结构：通过 `.haimati/索引.md` 维护记忆索引
+- 📚 分组书页存储：记忆内容按序号分组存储于 `.haimati/书页/` 目录
+- 🔍 多模式查询：支持序号、路径、标题精确匹配和模糊搜索
+- ✏️ 完整 CRUD：读取、写入、更新、删除、移动记忆
+- 🔄 自动规则注入：新会话自动注入海马体使用原则
+- 📋 日志追踪：完整的操作日志记录
+
+## 安装
+
+```bash
+npm install -g opencode-haimati
+# 或
+bun add -g opencode-haimati
+```
+
+## 使用方法
+
+将插件添加到你的 `opencode.json`：
+
+```json
+{
+  "$schema": "https://opencode.ai/config.json",
+  "plugin": ["opencode-haimati"],
+}
+```
+
+## 海马体结构
+
+```
+.haimati/
+├── 索引.md      # 树形结构索引
+└── 书页/        # 存储各记忆内容（按序号分组）
+    ├── 001-050/
+    │   ├── 001.md
+    │   └── 002.md
+    └── 051-100/
+        └── ...
+```
+
+## 可用工具
+
+- `haimati_read` - 从海马体读取记忆（支持序号、路径、标题查询）
+- `haimati_write` - 写入新记忆
+- `haimati_search` - 搜索记忆内容
+- `haimati_update` - 更新已有记忆的内容
+- `haimati_move` - 修改记忆的分类路径
+- `haimati_delete` - 删除记忆
+- `haimati_list` - 列出记忆索引
+
+## 海马体三大原则
+
+1. **信息不丢失**: 完整保留所有有价值的信息
+2. **错误信息修正**: 不再保留已被纠正的错误信息
+3. **拒绝冗余**: 不要重复记录相同内容
+
+## 使用示例
+
+```typescript
+// 写入新记忆
+haimati_write({
+  category: "标立方/签章",
+  title: "签章服务WS通信机制",
+  content: "WebSocket通信采用base64编码..."
+})
+
+// 读取记忆
+haimati_read({ query: "086" })
+// 或
+haimati_read({ query: "标立方/签章/签章服务WS通信机制" })
+
+// 搜索记忆
+haimati_search({ keyword: "WebSocket", limit: 10 })
+```
+
+## 索引格式示例
+
+```
+标立方/
+├── 签章/
+│   └── 签章服务WS通信机制 - 086
+└── 通用/
+    └── 用户注册密码 - 033
+```
+
+## 依赖要求
+
+- OpenCode v0.15.0 或更高版本
+- Node.js 或 Bun 运行时
+- 项目目录的文件系统写入权限
+
+## 许可证
+
+MIT

package/dist/index.js

@@ -0,0 +1,1098 @@
+// index.ts
+import fs from "fs";
+import path from "path";
+import os from "os";
+import { tool } from "@opencode-ai/plugin";
+var HAIMATI_DIR = ".haimati";
+var INDEX_FILE = "\u7D22\u5F15.md";
+var PAGES_DIR = "\u4E66\u9875";
+var NEXT_ID_FILE = "next-id.txt";
+var LOG_FILE = "haimati.log";
+var LOCK_MAX_WAIT = 5e3;
+var LOCK_RETRY_INTERVAL = 50;
+var HAIMATI_CONFIG_FILE = "opencode-haimati.conf";
+var HAIMATI_PATH_KEY = "haimati-path";
+var VERSION_SEPARATOR = "\n---\nversion:";
+var DEFAULT_VERSION = 1;
+function getConfigHaimatiPath(directory) {
+  const configPath = path.join(directory, HAIMATI_CONFIG_FILE);
+  if (!fs.existsSync(configPath)) {
+    return null;
+  }
+  try {
+    const content = fs.readFileSync(configPath, "utf-8");
+    const lines = content.split("\n");
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith("#")) {
+        continue;
+      }
+      const keyValueMatch = trimmed.match(/^([^:]+):\s*(.+)$/);
+      if (keyValueMatch) {
+        const key = keyValueMatch[1].trim();
+        const value = keyValueMatch[2].trim();
+        if (key === HAIMATI_PATH_KEY && value) {
+          return path.resolve(directory, value);
+        }
+      }
+    }
+  } catch (error) {
+    console.error(`[haimati] \u8BFB\u53D6\u914D\u7F6E\u6587\u4EF6\u5931\u8D25:`, error);
+  }
+  return null;
+}
+function getHaimatiDir(directory) {
+  const configPath = getConfigHaimatiPath(directory);
+  if (configPath) {
+    return configPath;
+  }
+  return path.join(directory, HAIMATI_DIR);
+}
+function getIndexPath(directory) {
+  return path.join(getHaimatiDir(directory), INDEX_FILE);
+}
+function getNextIdPath(directory) {
+  return path.join(getHaimatiDir(directory), NEXT_ID_FILE);
+}
+function getLockPath(directory) {
+  return path.join(getHaimatiDir(directory), ".lock");
+}
+function getPagesDir(directory) {
+  return path.join(getHaimatiDir(directory), PAGES_DIR);
+}
+function getPageGroupDir(directory, id) {
+  const n = parseInt(id, 10);
+  const groupStart = Math.floor((n - 1) / 50) * 50 + 1;
+  const groupEnd = groupStart + 49;
+  const groupName = `${String(groupStart).padStart(3, "0")}-${String(groupEnd).padStart(3, "0")}`;
+  return path.join(getPagesDir(directory), groupName);
+}
+function getPagePath(directory, id) {
+  return path.join(getPageGroupDir(directory, id), `${id}.md`);
+}
+function getLogFilePath() {
+  const osTmpDir = os.tmpdir();
+  return path.join(osTmpDir, "haimati_logs", LOG_FILE);
+}
+async function writeLogToFile(message) {
+  try {
+    const now = /* @__PURE__ */ new Date();
+    const dateStr = now.toISOString().split("T")[0];
+    const timeStr = now.toISOString().replace("T", " ").split(".")[0];
+    const logPath = getLogFilePath();
+    const logDir = path.dirname(logPath);
+    if (!fs.existsSync(logDir)) {
+      fs.mkdirSync(logDir, { recursive: true });
+    }
+    let shouldOverwrite = false;
+    if (fs.existsSync(logPath)) {
+      const mtime = fs.statSync(logPath).mtime;
+      const fileDate = mtime.toISOString().split("T")[0];
+      if (fileDate !== dateStr) {
+        shouldOverwrite = true;
+      }
+    }
+    const logLine = `[${timeStr}] ${message}`;
+    if (shouldOverwrite) {
+      fs.writeFileSync(logPath, logLine + "\n", "utf-8");
+    } else {
+      fs.appendFileSync(logPath, logLine + "\n", "utf-8");
+    }
+  } catch (error) {
+    console.error(`[haimati] \u5199\u5165\u65E5\u5FD7\u6587\u4EF6\u5931\u8D25:`, error);
+  }
+}
+function truncateForLog(content, maxLen = 500) {
+  if (content.length <= maxLen) return content;
+  const half = Math.floor((maxLen - 20) / 2);
+  return content.substring(0, half) + "...(\u7701\u7565" + (content.length - maxLen) + "\u5B57\u7B26)..." + content.substring(content.length - half);
+}
+async function log(level, message) {
+  await writeLogToFile(`[${level.toUpperCase()}] ${message}`);
+}
+function getTreeDepth(line) {
+  let depth = 0;
+  let i = 0;
+  const len = line.length;
+  while (i < len) {
+    if (line[i] === "\u2502" && i + 3 < len && line.slice(i + 1, i + 4) === "   ") {
+      depth++;
+      i += 4;
+    } else if (line.slice(i, i + 4) === "    ") {
+      depth++;
+      i += 4;
+    } else if ((line[i] === "\u251C" || line[i] === "\u2514") && i + 3 < len && line.slice(i + 1, i + 4) === "\u2500\u2500 ") {
+      break;
+    } else {
+      break;
+    }
+  }
+  return depth;
+}
+function extractCategoryName(line) {
+  const trimmed = line.trim();
+  let name = trimmed.replace(/^[│├└─\s]+/, "").trim();
+  if (name === "/") {
+    return "/";
+  }
+  if (!name.endsWith("/")) {
+    return null;
+  }
+  name = name.slice(0, -1);
+  if (!name) return null;
+  return name;
+}
+function parseIndex(content) {
+  const entries = [];
+  const lines = content.split("\n");
+  const categoryPath = [];
+  for (const line of lines) {
+    if (!line.trim()) continue;
+    const depth = getTreeDepth(line);
+    const entryMatch = line.match(/^\s*[│├└─\s]*(.+?)\s*-\s*(\d+)\s*$/);
+    if (entryMatch) {
+      const title = entryMatch[1].trim();
+      const id = entryMatch[2];
+      const entryCategoryParts = categoryPath.slice(0, depth).filter((p) => p !== "");
+      const category = entryCategoryParts.join("/");
+      entries.push({ id, category, title });
+    } else {
+      const name = extractCategoryName(line);
+      if (name) {
+        if (name === "/") {
+          categoryPath[depth] = "";
+          for (let j = depth + 1; j < categoryPath.length; j++) {
+            delete categoryPath[j];
+          }
+        } else {
+          categoryPath[depth] = name;
+          for (let j = depth + 1; j < categoryPath.length; j++) {
+            delete categoryPath[j];
+          }
+        }
+      }
+    }
+  }
+  return entries;
+}
+function findEntryById(entries, id) {
+  return entries.find((e) => e.id === id) || null;
+}
+function findEntryByPath(entries, categoryPath, title) {
+  return entries.find((e) => e.category === categoryPath && e.title === title) || null;
+}
+async function searchEntriesAsync(entries, keyword, matchMode, directory, searchContent = false) {
+  const keywords = keyword.toLowerCase().split(/\s+/).filter((k) => k.length > 0);
+  if (keywords.length === 0) return [];
+  const matchedWithScore = [];
+  for (const e of entries) {
+    const titleLower = e.title.toLowerCase();
+    const categoryLower = e.category.toLowerCase();
+    const idLower = e.id.toLowerCase();
+    let metaKeywordsCount = 0;
+    let contentKeywordsCount = 0;
+    for (const kw of keywords) {
+      if (titleLower.includes(kw) || categoryLower.includes(kw) || idLower.includes(kw)) {
+        metaKeywordsCount++;
+      }
+    }
+    if (searchContent && directory) {
+      const page = await readPageAsync(directory, e.id);
+      if (page && page.content) {
+        const contentLower = page.content.toLowerCase();
+        for (const kw of keywords) {
+          if (contentLower.includes(kw)) {
+            contentKeywordsCount++;
+          }
+        }
+      }
+    }
+    const totalMatchCount = metaKeywordsCount + contentKeywordsCount;
+    if (matchMode === "and") {
+      if (totalMatchCount >= keywords.length) {
+        matchedWithScore.push({ entry: e, score: totalMatchCount });
+      }
+    } else {
+      if (metaKeywordsCount > 0 || searchContent && contentKeywordsCount > 0) {
+        matchedWithScore.push({ entry: e, score: totalMatchCount });
+      }
+    }
+  }
+  matchedWithScore.sort((a, b) => b.score - a.score);
+  return matchedWithScore.map((item) => item.entry);
+}
+async function readNextIdFromFileAsync(directory) {
+  const nextIdPath = getNextIdPath(directory);
+  if (!fs.existsSync(nextIdPath)) {
+    return 1;
+  }
+  const content = fs.readFileSync(nextIdPath, "utf-8");
+  const trimmed = content.trim();
+  const parsed = parseInt(trimmed, 10);
+  if (!isNaN(parsed) && parsed > 0) {
+    return parsed;
+  }
+  return 1;
+}
+async function initializeNextIdIfNeededAsync(directory) {
+  const nextIdPath = getNextIdPath(directory);
+  if (fs.existsSync(nextIdPath)) {
+    return;
+  }
+  const entries = await readIndexAsync(directory);
+  let maxId = 0;
+  for (const e of entries) {
+    const n = parseInt(e.id, 10);
+    if (n > maxId) maxId = n;
+  }
+  await writeNextIdToFileAsync(directory, maxId + 1);
+}
+async function writeNextIdToFileAsync(directory, nextId) {
+  const haimatiDir = getHaimatiDir(directory);
+  if (!fs.existsSync(haimatiDir)) {
+    fs.mkdirSync(haimatiDir, { recursive: true });
+  }
+  const nextIdPath = getNextIdPath(directory);
+  fs.writeFileSync(nextIdPath, String(nextId), "utf-8");
+}
+function acquireLock(directory) {
+  const haimatiDir = getHaimatiDir(directory);
+  if (!fs.existsSync(haimatiDir)) {
+    fs.mkdirSync(haimatiDir, { recursive: true });
+  }
+  const lockPath = getLockPath(directory);
+  const startTime = Date.now();
+  while (fs.existsSync(lockPath)) {
+    if (Date.now() - startTime > LOCK_MAX_WAIT) {
+      return false;
+    }
+    const sleep = LOCK_RETRY_INTERVAL + Math.random() * 20;
+    const end = Date.now() + sleep;
+    while (Date.now() < end) {
+    }
+  }
+  fs.writeFileSync(lockPath, String(process.pid), "utf-8");
+  return true;
+}
+function releaseLock(directory) {
+  const lockPath = getLockPath(directory);
+  if (fs.existsSync(lockPath)) {
+    fs.unlinkSync(lockPath);
+  }
+}
+async function readPageAsync(directory, id) {
+  const pagePath = getPagePath(directory, id);
+  if (!fs.existsSync(pagePath)) {
+    return null;
+  }
+  const content = fs.readFileSync(pagePath, "utf-8");
+  const lines = content.split("\n");
+  if (lines.length < 2) {
+    return null;
+  }
+  let version = 1;
+  let actualContentLines = lines.slice(2);
+  const versionMatchIndex = content.lastIndexOf(VERSION_SEPARATOR);
+  if (versionMatchIndex !== -1) {
+    const versionStr = content.substring(versionMatchIndex + VERSION_SEPARATOR.length);
+    version = parseInt(versionStr.trim(), 10) || DEFAULT_VERSION;
+    actualContentLines = lines.slice(2, lines.length - 2);
+  }
+  return {
+    title: lines[0],
+    createdAt: lines[1],
+    content: actualContentLines.join("\n"),
+    version
+  };
+}
+async function writePageAsync(directory, id, title, createdAt, content, version = 1) {
+  const pagesDir = getPagesDir(directory);
+  if (!fs.existsSync(pagesDir)) {
+    fs.mkdirSync(pagesDir, { recursive: true });
+  }
+  const pageGroupDir = getPageGroupDir(directory, id);
+  if (!fs.existsSync(pageGroupDir)) {
+    fs.mkdirSync(pageGroupDir, { recursive: true });
+  }
+  const pagePath = getPagePath(directory, id);
+  const fileContent = `${title}
+${createdAt}
+${content}${VERSION_SEPARATOR}${version}`;
+  fs.writeFileSync(pagePath, fileContent, "utf-8");
+}
+async function deletePageAsync(directory, id) {
+  const pagePath = getPagePath(directory, id);
+  if (fs.existsSync(pagePath)) {
+    fs.unlinkSync(pagePath);
+    return true;
+  }
+  return false;
+}
+function buildIndexTree(entries) {
+  if (entries.length === 0) {
+    return "";
+  }
+  const root = { name: "/", children: [], entry: null };
+  for (const entry of entries) {
+    const parts = entry.category.split("/");
+    let current = root;
+    for (let i = 0; i < parts.length; i++) {
+      const part = parts[i];
+      if (!part) continue;
+      let child = current.children.find((c) => c.name === part);
+      if (!child) {
+        child = { name: part, children: [], entry: null };
+        current.children.push(child);
+      }
+      current = child;
+    }
+    const entryNode = {
+      name: entry.id,
+      children: [],
+      entry
+    };
+    current.children.push(entryNode);
+  }
+  function sortNode(node) {
+    node.children.sort((a, b) => a.name.localeCompare(b.name, void 0, { sensitivity: "base" }));
+    for (const child of node.children) {
+      sortNode(child);
+    }
+  }
+  sortNode(root);
+  function nodeToLines(node, prefix, isLast) {
+    const lines = [];
+    const displayPrefix = prefix + (isLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ");
+    const nodeName = node.name === "/" ? "/" : node.name + "/";
+    lines.push(`${displayPrefix}${nodeName}`);
+    prefix = prefix + (isLast ? "    " : "\u2502   ");
+    const categories = node.children.filter((c) => c.entry === null);
+    const items = node.children.filter((c) => c.entry !== null);
+    const allChildren = [...categories, ...items];
+    for (let i = 0; i < allChildren.length; i++) {
+      const child = allChildren[i];
+      const childIsLast = i === allChildren.length - 1;
+      if (child.entry) {
+        const itemPrefix = prefix + (childIsLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ");
+        lines.push(`${itemPrefix}${child.entry.title} - ${child.entry.id}`);
+      } else {
+        lines.push(...nodeToLines(child, prefix, childIsLast));
+      }
+    }
+    return lines;
+  }
+  return nodeToLines(root, "", true).join("\n");
+}
+function removeIndexEntry(entries, id) {
+  return entries.filter((e) => e.id !== id);
+}
+async function readIndexAsync(directory) {
+  const indexPath = getIndexPath(directory);
+  if (!fs.existsSync(indexPath)) {
+    return [];
+  }
+  const content = fs.readFileSync(indexPath, "utf-8");
+  return parseIndex(content);
+}
+async function writeIndexAsync(directory, entries) {
+  const haimatiDir = getHaimatiDir(directory);
+  if (!fs.existsSync(haimatiDir)) {
+    fs.mkdirSync(haimatiDir, { recursive: true });
+  }
+  const tree = buildIndexTree(entries);
+  const indexPath = getIndexPath(directory);
+  fs.writeFileSync(indexPath, tree, "utf-8");
+}
+async function allocateIdWithLock(directory, category, title, now, content) {
+  if (!acquireLock(directory)) {
+    return null;
+  }
+  try {
+    await initializeNextIdIfNeededAsync(directory);
+    const entries = await readIndexAsync(directory);
+    const existingEntry = entries.find((e) => e.category === category && e.title === title);
+    if (existingEntry) {
+      const page = await readPageAsync(directory, existingEntry.id);
+      const createdAt = page ? page.createdAt : now;
+      const newVersion = page ? page.version + 1 : 1;
+      await writePageAsync(directory, existingEntry.id, title, createdAt, content, newVersion);
+      await log("info", `[allocateIdWithLock] \u66F4\u65B0\u5DF2\u6709\u6761\u76EE: #${existingEntry.id} ${category}/${title}, \u65B0\u7248\u672C: ${newVersion}`);
+      return null;
+    }
+    const currentNext = await readNextIdFromFileAsync(directory);
+    const newId = String(currentNext).padStart(3, "0");
+    await writePageAsync(directory, newId, title, now, content, 1);
+    const newEntry = {
+      id: newId,
+      category,
+      title
+    };
+    entries.push(newEntry);
+    await writeIndexAsync(directory, entries);
+    await writeNextIdToFileAsync(directory, currentNext + 1);
+    return newId;
+  } catch (error) {
+    const errMsg = error instanceof Error ? error.message : String(error);
+    await log("error", `[allocateIdWithLock] \u5206\u914D\u5E8F\u53F7\u5931\u8D25: ${errMsg}`);
+    return null;
+  } finally {
+    releaseLock(directory);
+  }
+}
+var HaimatiPlugin = async (ctx) => {
+  await log("info", `\u6D77\u9A6C\u4F53\u8BB0\u5FC6\u7CFB\u7EDF\u63D2\u4EF6(\u6587\u4EF6\u7248)\u5DF2\u52A0\u8F7D`);
+  return {
+    tool: {
+      /**
+       * haimati_read - 从海马体读取记忆
+       * 
+       * 只支持序号查询：如 "086"
+        */
+      haimati_read: tool({
+        description: "\u4ECE\u6D77\u9A6C\u4F53\u8BB0\u5FC6\u7CFB\u7EDF\u8BFB\u53D6\u5185\u5BB9\u3002\u901A\u8FC7\u5E8F\u53F7\uFF08\u5982 '086'\uFF09\u6765\u5B9A\u4F4D\u5E76\u8BFB\u53D6\u8BB0\u5FC6\u5185\u5BB9\u3002\u652F\u6301\u5206\u9875\u8BFB\u53D6\uFF08offset/limit\uFF09\uFF0C\u8FD4\u56DE\u5185\u5BB9\u5E26\u884C\u53F7\u548C\u7248\u672C\u53F7\u3002",
+        args: {
+          query: tool.schema.string().describe("\u5E8F\u53F7\u3002\u4F8B\u5982\uFF1A'086'"),
+          offset: tool.schema.number().optional().default(1).describe("\u8D77\u59CB\u884C\u53F7\uFF08\u9ED8\u8BA4 1\uFF09"),
+          limit: tool.schema.number().optional().default(2e3).describe("\u6700\u5927\u8BFB\u53D6\u884C\u6570\uFF08\u9ED8\u8BA4 2000\uFF09")
+        },
+        /**
+         * 返回格式：
+         *   version:1
+         *   1|第一行内容
+         *   2|第二行内容
+         *   ...
+         * 
+         * version 用于后续 haimati_edit 的并发控制，请妥善保存
+         */
+        async execute(args, context) {
+          const { directory } = context;
+          const indexPath = getIndexPath(directory);
+          await log("info", `[haimati_read] \u5165\u53C2: query="${args.query}", offset=${args.offset || 1}, limit=${args.limit || 2e3}`);
+          if (!fs.existsSync(indexPath)) {
+            const result = `\u9519\u8BEF\uFF1A\u6D77\u9A6C\u4F53\u7D22\u5F15\u4E0D\u5B58\u5728\u4E8E ${indexPath}`;
+            await log("warn", `[haimati_read] \u51FA\u53C2:
+${truncateForLog(result)}`);
+            return result;
+          }
+          try {
+            const entries = await readIndexAsync(directory);
+            await log("debug", `[haimati_read] \u8BFB\u53D6\u7D22\u5F15: \u5171 ${entries.length} \u6761\u8BB0\u5F55`);
+            const query = args.query.trim();
+            if (!/^\d+$/.test(query)) {
+              const result2 = `\u9519\u8BEF\uFF1Aquery \u5FC5\u987B\u662F\u5E8F\u53F7\uFF0C\u53EA\u652F\u6301\u5E8F\u53F7\u67E5\u8BE2`;
+              await log("warn", `[haimati_read] \u51FA\u53C2:
+${truncateForLog(result2)}`);
+              return result2;
+            }
+            const entry = findEntryById(entries, query);
+            await log("debug", `[haimati_read] \u5E8F\u53F7\u67E5\u8BE2 #${query}: ${entry ? "\u627E\u5230" : "\u672A\u627E\u5230"}`);
+            if (!entry) {
+              const result2 = `\u672A\u627E\u5230\u8BB0\u5FC6: ${args.query}`;
+              await log("info", `[haimati_read] \u51FA\u53C2:
+${truncateForLog(result2)}`);
+              return result2;
+            }
+            const page = await readPageAsync(directory, entry.id);
+            if (!page) {
+              const result2 = `\u672A\u627E\u5230\u4E66\u9875: #${entry.id}`;
+              await log("error", `[haimati_read] \u51FA\u53C2:
+${truncateForLog(result2)}`);
+              return result2;
+            }
+            await log("debug", `[haimati_read] \u8BFB\u53D6\u4E66\u9875: \u4E66\u9875/${getPageGroupDir(directory, entry.id).split(/[\\/]/).pop()}/${entry.id}.md, version=${page.version}`);
+            const contentLines = page.content.split("\n");
+            const offset = args.offset || 1;
+            const limit = args.limit || 2e3;
+            const totalLines = contentLines.length;
+            const startIndex = Math.max(0, offset - 1);
+            const endIndex = Math.min(totalLines, startIndex + limit);
+            const linesOutput = [];
+            linesOutput.push(`version:${page.version}`);
+            for (let i = startIndex; i < endIndex; i++) {
+              linesOutput.push(`${i + 1}|${contentLines[i]}`);
+            }
+            const result = linesOutput.join("\n");
+            await log("info", `[haimati_read] \u51FA\u53C2:
+${truncateForLog(result)}`);
+            return result;
+          } catch (error) {
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            const stack = error instanceof Error ? error.stack : "";
+            await log("error", `[haimati_read] \u51FA\u53C2: \u9519\u8BEF: ${errorMsg}
+\u5806\u6808: ${stack}`);
+            return `\u9519\u8BEF: ${errorMsg}`;
+          }
+        }
+      }),
+      /**
+       * haimati_write - 将新信息写入海马体记忆系统
+       * 
+       * 会自动分配新的序号并存储到文件
+       */
+      haimati_write: tool({
+        description: "\u5C06\u65B0\u4FE1\u606F\u5199\u5165\u6D77\u9A6C\u4F53\u8BB0\u5FC6\u7CFB\u7EDF\u3002\u9700\u8981\u63D0\u4F9B\u5206\u7C7B\u8DEF\u5F84\uFF08\u5982 '\u6807\u7ACB\u65B9/\u7B7E\u7AE0'\uFF09\u3001\u6807\u9898\u548C\u5185\u5BB9\u3002",
+        args: {
+          category: tool.schema.string().describe("\u5206\u7C7B\u8DEF\u5F84\uFF0C\u5982 '\u6807\u7ACB\u65B9/\u7B7E\u7AE0' \u6216 '\u901A\u7528'"),
+          title: tool.schema.string().describe("\u8BB0\u5FC6\u6807\u9898\uFF0C\u5982 '\u7B7E\u7AE0\u670D\u52A1WS\u901A\u4FE1\u673A\u5236'"),
+          content: tool.schema.string().describe("\u8981\u5199\u5165\u7684\u8BE6\u7EC6\u5185\u5BB9")
+        },
+        async execute(args, context) {
+          const { directory } = context;
+          await log("info", `[haimati_write] \u5165\u53C2: category="${args.category}", title="${args.title}", content\u957F\u5EA6=${args.content.length}\u5B57\u7B26, content=
+${truncateForLog(args.content)}
+`);
+          try {
+            const now = (/* @__PURE__ */ new Date()).toISOString();
+            let newId = null;
+            for (let retry = 0; retry < 3; retry++) {
+              newId = await allocateIdWithLock(directory, args.category, args.title, now, args.content);
+              if (newId) break;
+              await log("warn", `[haimati_write] \u9501\u83B7\u53D6\u5931\u8D25\uFF0C\u91CD\u8BD5\u7B2C ${retry + 1} \u6B21`);
+            }
+            if (newId) {
+              await log("debug", `[haimati_write] \u5206\u914D\u65B0\u5E8F\u53F7: #${newId}`);
+              await log("debug", `[haimati_write] \u4E66\u9875\u548C\u7D22\u5F15\u5DF2\u66F4\u65B0: \u4E66\u9875/${getPageGroupDir(directory, newId).split(/[\\/]/).pop()}/${newId}.md`);
+              const result2 = `\u5DF2\u5199\u5165\u6D77\u9A6C\u4F53 #${newId}
+\u8DEF\u5F84: ${args.category}/${args.title}
+\u7248\u672C: 1`;
+              await log("info", `[haimati_write] \u51FA\u53C2:
+${truncateForLog(result2)}`);
+              return result2;
+            }
+            const entries = await readIndexAsync(directory);
+            const existingEntry = findEntryByPath(entries, args.category, args.title);
+            if (existingEntry) {
+              const page = await readPageAsync(directory, existingEntry.id);
+              const version = page ? page.version : 1;
+              const result2 = `\u5DF2\u66F4\u65B0\u6D77\u9A6C\u4F53 #${existingEntry.id}
+\u8DEF\u5F84: ${args.category}/${args.title}
+\u7248\u672C: ${version}`;
+              await log("info", `[haimati_write] \u51FA\u53C2:
+${truncateForLog(result2)}`);
+              return result2;
+            }
+            const result = `\u9519\u8BEF\uFF1A\u65E0\u6CD5\u5206\u914D\u5E8F\u53F7\uFF08\u9501\u7B49\u5F85\u8D85\u65F6\uFF09`;
+            await log("error", `[haimati_write] \u51FA\u53C2:
+${truncateForLog(result)}`);
+            return result;
+          } catch (error) {
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            const stack = error instanceof Error ? error.stack : "";
+            await log("error", `[haimati_write] \u51FA\u53C2: \u9519\u8BEF: ${errorMsg}
+\u5806\u6808: ${stack}`);
+            return `\u9519\u8BEF: ${errorMsg}`;
+          }
+        }
+      }),
+      /**
+       * haimati_search - 搜索海马体记忆系统
+       * 
+       * 在标题、分类、序号和书页内容中进行搜索
+       */
+      haimati_search: tool({
+        description: "\u641C\u7D22\u6D77\u9A6C\u4F53\u8BB0\u5FC6\u7CFB\u7EDF\uFF08\u652F\u6301\u591A\u5173\u952E\u5B57\uFF0C\u7528\u7A7A\u683C\u5206\u9694\uFF09\u3002\u641C\u7D22\u8303\u56F4\u5305\u62EC\uFF1A\u6807\u9898\u3001\u5206\u7C7B\u3001\u5E8F\u53F7\u3001\u4E66\u9875\u5185\u5BB9\u3002\u8F93\u5165\u5173\u952E\u8BCD\uFF0C\u8FD4\u56DE\u5339\u914D\u7684\u6761\u76EE\u5217\u8868\u548C\u5185\u5BB9\u7247\u6BB5\uFF0C\u652F\u6301\u5206\u9875\uFF08limit/offset\uFF09\u3002",
+        args: {
+          keyword: tool.schema.string().describe("\u641C\u7D22\u5173\u952E\u8BCD\uFF08\u652F\u6301\u591A\u5173\u952E\u5B57\uFF0C\u7528\u7A7A\u683C\u5206\u9694\uFF09"),
+          match: tool.schema.string().describe("\u5339\u914D\u6A21\u5F0F\uFF1Aand=\u6240\u6709\u5173\u952E\u5B57\u90FD\u5339\u914D\uFF0Cor=\u4EFB\u610F\u5173\u952E\u5B57\u5339\u914D"),
+          limit: tool.schema.number().default(10).describe("\u8FD4\u56DE\u7ED3\u679C\u6570\u91CF\u9650\u5236"),
+          offset: tool.schema.number().default(0).describe("\u5206\u9875\u504F\u79FB\u91CF\uFF0C\u7528\u4E8E\u83B7\u53D6\u540E\u7EED\u9875\u9762")
+        },
+        async execute(args, context) {
+          const { directory } = context;
+          const indexPath = getIndexPath(directory);
+          await log("info", `[haimati_search] \u5165\u53C2: keyword="${args.keyword}", match="${args.match}", limit=${args.limit || 10}, offset=${args.offset || 0}`);
+          if (!fs.existsSync(indexPath)) {
+            const result = `\u9519\u8BEF\uFF1A\u6D77\u9A6C\u4F53\u7D22\u5F15\u4E0D\u5B58\u5728`;
+            await log("warn", `[haimati_search] \u51FA\u53C2:
+${truncateForLog(result)}`);
+            return result;
+          }
+          try {
+            const entries = await readIndexAsync(directory);
+            const keyword = args.keyword.trim();
+            const match = args.match;
+            const limit = args.limit || 10;
+            const offset = args.offset || 0;
+            const allMatched = await searchEntriesAsync(entries, keyword, match, directory, true);
+            const totalCount = allMatched.length;
+            const matched = allMatched.slice(offset, offset + limit);
+            if (matched.length === 0) {
+              const result2 = `\u672A\u627E\u5230\u5305\u542B '${keyword}' \u7684\u8BB0\u5FC6`;
+              await log("info", `[haimati_search] \u51FA\u53C2:
+${truncateForLog(result2)}`);
+              return result2;
+            }
+            const results = [];
+            const hasMore = offset + matched.length < totalCount;
+            const displayCount = hasMore ? `${offset + 1}-${offset + matched.length}/${totalCount}` : `${offset + 1}-${offset + matched.length}/${totalCount}`;
+            results.push(`\u627E\u5230 ${displayCount} \u6761\u5339\u914D\uFF1A
+`);
+            if (hasMore) {
+              results.push(`\uFF08\u5982\u9700\u83B7\u53D6\u66F4\u591A\uFF0C\u8BF7\u4F7F\u7528 offset=${offset + limit} \u7EE7\u7EED\u7FFB\u9875\uFF09
+`);
+            }
+            for (const entry of matched) {
+              const page = await readPageAsync(directory, entry.id);
+              const fullPath = `${entry.category}/${entry.title}`;
+              let excerpt = "";
+              if (page) {
+                const lines = page.content.split("\n").filter((l) => l.trim());
+                excerpt = lines.slice(0, 3).join(" | ").substring(0, 150);
+                if (excerpt.length === 150) excerpt += "...";
+              }
+              results.push(`## ${fullPath} [${entry.id}]`);
+              if (excerpt) {
+                results.push(`> ${excerpt}`);
+              }
+              results.push("");
+            }
+            const result = results.join("\n");
+            await log("info", `[haimati_search] \u51FA\u53C2:
+${truncateForLog(result)}`);
+            return result;
+          } catch (error) {
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            const stack = error instanceof Error ? error.stack : "";
+            await log("error", `[haimati_search] \u51FA\u53C2: \u9519\u8BEF: ${errorMsg}
+\u5806\u6808: ${stack}`);
+            return `\u9519\u8BEF: ${errorMsg}`;
+          }
+        }
+      }),
+      /**
+       * haimati_edit - 修改海马体中的记忆内容（部分替换）
+       * 
+       * 使用流程：
+       * 1. 先调用 haimati_read 获取当前内容的行号和 version
+       * 2. 传入 offsetBegin/offsetEnd 指定替换范围，传入 content 替换内容
+       * 3. 传入 read 返回的 version 进行并发控制
+       * 
+       * 并发控制原理：
+       * - 如果在你读取后、其他会话修改了该记忆，version会变化
+       * - 写入时检查 version 是否匹配，不匹配则拒绝写入
+       * - 写入成功后 version 自动+1
+       */
+      haimati_edit: tool({
+        description: "\u4FEE\u6539\u6D77\u9A6C\u4F53\u8BB0\u5FC6\u7684\u90E8\u5206\u5185\u5BB9\u3002\u5C06\u6307\u5B9A\u884C\u53F7\u8303\u56F4 [offsetBegin, offsetEnd) \u7684\u5185\u5BB9\u66FF\u6362\u4E3A\u65B0 content\u3002\u9700\u8981\u63D0\u4F9B read \u65F6\u8FD4\u56DE\u7684 version \u8FDB\u884C\u5E76\u53D1\u63A7\u5236\u3002",
+        args: {
+          query: tool.schema.string().describe("\u5E8F\u53F7\uFF0C\u7528\u4E8E\u5B9A\u4F4D\u8981\u66F4\u65B0\u7684\u8BB0\u5FC6"),
+          offsetBegin: tool.schema.number().describe("\u8D77\u59CB\u884C\u53F7\uFF08\u5305\u62EC\uFF09"),
+          offsetEnd: tool.schema.number().describe("\u7ED3\u675F\u884C\u53F7\uFF08\u4E0D\u5305\u62EC\uFF09"),
+          content: tool.schema.string().describe("\u66FF\u6362\u5185\u5BB9"),
+          version: tool.schema.number().describe("read \u65F6\u8FD4\u56DE\u7684 version\uFF0C\u7528\u4E8E\u5E76\u53D1\u63A7\u5236")
+        },
+        async execute(args, context) {
+          const { directory } = context;
+          const indexPath = getIndexPath(directory);
+          await log("info", `[haimati_edit] \u5165\u53C2: query="${args.query}", offsetBegin=${args.offsetBegin}, offsetEnd=${args.offsetEnd}, content\u957F\u5EA6=${args.content.length}\u5B57\u7B26, version=${args.version}, content=
+${truncateForLog(args.content)}
+`);
+          if (!fs.existsSync(indexPath)) {
+            const result = `\u9519\u8BEF\uFF1A\u6D77\u9A6C\u4F53\u7D22\u5F15\u4E0D\u5B58\u5728`;
+            await log("warn", `[haimati_edit] \u51FA\u53C2:
+${truncateForLog(result)}`);
+            return result;
+          }
+          try {
+            const entries = await readIndexAsync(directory);
+            const query = args.query.trim();
+            if (!/^\d+$/.test(query)) {
+              const result2 = `\u9519\u8BEF\uFF1Aquery \u5FC5\u987B\u662F\u5E8F\u53F7\uFF0C\u53EA\u652F\u6301\u5E8F\u53F7\u67E5\u8BE2`;
+              await log("warn", `[haimati_edit] \u51FA\u53C2:
+${truncateForLog(result2)}`);
+              return result2;
+            }
+            const entry = findEntryById(entries, query);
+            if (!entry) {
+              const result2 = `\u672A\u627E\u5230\u4E0E '${query}' \u76F8\u5173\u7684\u8BB0\u5FC6`;
+              await log("info", `[haimati_edit] \u51FA\u53C2:
+${truncateForLog(result2)}`);
+              return result2;
+            }
+            const page = await readPageAsync(directory, entry.id);
+            if (!page) {
+              const result2 = `\u672A\u627E\u5230\u4E66\u9875: #${entry.id}`;
+              await log("error", `[haimati_edit] \u51FA\u53C2:
+${truncateForLog(result2)}`);
+              return result2;
+            }
+            const offsetBegin = args.offsetBegin;
+            const offsetEnd = args.offsetEnd;
+            if (offsetBegin > page.content.split("\n").length || offsetBegin >= offsetEnd) {
+              const result2 = `\u9519\u8BEF\uFF1Aoffset \u975E\u6CD5\uFF0CoffsetBegin=${offsetBegin}, offsetEnd=${offsetEnd}, \u6587\u4EF6\u603B\u884C\u6570=${page.content.split("\n").length}`;
+              await log("warn", `[haimati_edit] \u51FA\u53C2:
+${truncateForLog(result2)}`);
+              return result2;
+            }
+            if (page.version !== args.version) {
+              const result2 = `\u9519\u8BEF\uFF1A\u7248\u672C\u51B2\u7A81\uFF0C\u5F53\u524D version=${page.version}\uFF0C\u4F20\u5165 version=${args.version}\uFF0C\u8BF7\u91CD\u65B0\u8BFB\u53D6\u540E\u518D\u64CD\u4F5C`;
+              await log("warn", `[haimati_edit] \u51FA\u53C2:
+${truncateForLog(result2)}`);
+              return result2;
+            }
+            const contentLines = page.content.split("\n");
+            const newContentLines = [
+              ...contentLines.slice(0, offsetBegin - 1),
+              // [0, offsetBegin-1) 保留
+              ...args.content.split("\n"),
+              // 插入新内容
+              ...contentLines.slice(offsetEnd - 1)
+              // [offsetEnd-1, end) 保留
+            ];
+            const newContent = newContentLines.join("\n");
+            const newVersion = page.version + 1;
+            await writePageAsync(directory, entry.id, entry.title, page.createdAt, newContent, newVersion);
+            const fullPath = `${entry.category}/${entry.title}`;
+            const result = `\u5DF2\u66F4\u65B0\u6D77\u9A6C\u4F53 #${entry.id}
+\u8DEF\u5F84: ${fullPath}
+\u65B0\u7248\u672C: ${newVersion}`;
+            await log("info", `[haimati_edit] \u51FA\u53C2:
+${truncateForLog(result)}`);
+            return result;
+          } catch (error) {
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            const stack = error instanceof Error ? error.stack : "";
+            await log("error", `[haimati_edit] \u51FA\u53C2: \u9519\u8BEF: ${errorMsg}
+\u5806\u6808: ${stack}`);
+            return `\u9519\u8BEF: ${errorMsg}`;
+          }
+        }
+      }),
+      /**
+       * haimati_delete - 删除海马体中的记忆
+       */
+      haimati_delete: tool({
+        description: "\u5220\u9664\u6D77\u9A6C\u4F53\u4E2D\u7684\u8BB0\u5FC6\u3002\u901A\u8FC7\u5E8F\u53F7\uFF08\u5982 '086'\uFF09\u6216\u5B8C\u6574\u8DEF\u5F84\uFF08\u5982 '\u6807\u7ACB\u65B9/\u7B7E\u7AE0/\u7B7E\u7AE0\u670D\u52A1WS\u901A\u4FE1\u673A\u5236'\uFF09\u6765\u5B9A\u4F4D\u8981\u5220\u9664\u7684\u8BB0\u5FC6\u3002",
+        args: {
+          query: tool.schema.string().describe("\u5E8F\u53F7\u6216\u5B8C\u6574\u8DEF\u5F84\uFF0C\u7528\u4E8E\u5B9A\u4F4D\u8981\u5220\u9664\u7684\u8BB0\u5FC6")
+        },
+        async execute(args, context) {
+          const { directory } = context;
+          const indexPath = getIndexPath(directory);
+          await log("info", `[haimati_delete] \u5165\u53C2: query="${args.query}"`);
+          if (!fs.existsSync(indexPath)) {
+            const result = `\u9519\u8BEF\uFF1A\u6D77\u9A6C\u4F53\u7D22\u5F15\u4E0D\u5B58\u5728`;
+            await log("warn", `[haimati_delete] \u51FA\u53C2:
+${truncateForLog(result)}`);
+            return result;
+          }
+          try {
+            const entries = await readIndexAsync(directory);
+            const query = args.query.trim();
+            let entry = null;
+            if (/^\d+$/.test(query)) {
+              entry = findEntryById(entries, query);
+            } else {
+              const parts = query.split("/").filter(Boolean);
+              if (parts.length >= 2) {
+                const title = parts.pop();
+                const category = parts.join("/");
+                entry = findEntryByPath(entries, category, title);
+              } else {
+                const results = await searchEntriesAsync(entries, query, "or", directory);
+                if (results.length === 1) {
+                  entry = results[0];
+                } else if (results.length > 1) {
+                  const list = results.slice(0, 10).map((e) => `  - ${e.category}/${e.title} [${e.id}]`).join("\n");
+                  return `\u627E\u5230\u591A\u6761\u5339\u914D\uFF0C\u8BF7\u4F7F\u7528\u5E8F\u53F7\u7CBE\u786E\u6307\u5B9A\uFF1A
+${list}`;
+                }
+              }
+            }
+            if (!entry) {
+              const result2 = `\u672A\u627E\u5230\u4E0E '${query}' \u76F8\u5173\u7684\u8BB0\u5FC6`;
+              await log("info", `[haimati_delete] \u51FA\u53C2:
+${truncateForLog(result2)}`);
+              return result2;
+            }
+            await deletePageAsync(directory, entry.id);
+            const newEntries = removeIndexEntry(entries, entry.id);
+            await writeIndexAsync(directory, newEntries);
+            const fullPath = `${entry.category}/${entry.title}`;
+            const result = `\u5DF2\u5220\u9664\u6D77\u9A6C\u4F53 #${entry.id}
+\u8DEF\u5F84: ${fullPath}`;
+            await log("info", `[haimati_delete] \u51FA\u53C2:
+${truncateForLog(result)}`);
+            return result;
+          } catch (error) {
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            const stack = error instanceof Error ? error.stack : "";
+            await log("error", `[haimati_delete] \u51FA\u53C2: \u9519\u8BEF: ${errorMsg}
+\u5806\u6808: ${stack}`);
+            return `\u9519\u8BEF: ${errorMsg}`;
+          }
+        }
+      }),
+      /**
+       * haimati_move - 修改记忆的分类路径
+       */
+      haimati_move: tool({
+        description: "\u4FEE\u6539\u6D77\u9A6C\u4F53\u8BB0\u5FC6\u7684\u5206\u7C7B\u8DEF\u5F84\u3002\u901A\u8FC7\u5E8F\u53F7\u6216\u5B8C\u6574\u8DEF\u5F84\u5B9A\u4F4D\u8BB0\u5FC6\uFF0C\u7136\u540E\u5C06\u5176\u79FB\u52A8\u5230\u65B0\u7684\u5206\u7C7B\u3002",
+        args: {
+          query: tool.schema.string().describe("\u5E8F\u53F7\u6216\u5B8C\u6574\u8DEF\u5F84\uFF0C\u7528\u4E8E\u5B9A\u4F4D\u8981\u79FB\u52A8\u7684\u8BB0\u5FC6"),
+          newCategory: tool.schema.string().describe("\u65B0\u7684\u5206\u7C7B\u8DEF\u5F84\uFF0C\u5982 '\u6807\u7ACB\u65B9/\u5BA2\u6237\u7AEF' \u6216 '\u901A\u7528'")
+        },
+        async execute(args, context) {
+          const { directory } = context;
+          const indexPath = getIndexPath(directory);
+          await log("info", `[haimati_move] \u5165\u53C2: query="${args.query}", newCategory="${args.newCategory}"`);
+          if (!fs.existsSync(indexPath)) {
+            const result = `\u9519\u8BEF\uFF1A\u6D77\u9A6C\u4F53\u7D22\u5F15\u4E0D\u5B58\u5728`;
+            await log("warn", `[haimati_move] \u51FA\u53C2:
+${truncateForLog(result)}`);
+            return result;
+          }
+          try {
+            const entries = await readIndexAsync(directory);
+            const query = args.query.trim();
+            let entry = null;
+            if (/^\d+$/.test(query)) {
+              entry = findEntryById(entries, query);
+            } else {
+              const parts = query.split("/").filter(Boolean);
+              if (parts.length >= 2) {
+                const title = parts.pop();
+                const category = parts.join("/");
+                entry = findEntryByPath(entries, category, title);
+              } else {
+                const results = await searchEntriesAsync(entries, query, "or", directory);
+                if (results.length === 1) {
+                  entry = results[0];
+                } else if (results.length > 1) {
+                  const list = results.slice(0, 10).map((e) => `  - ${e.category}/${e.title} [${e.id}]`).join("\n");
+                  return `\u627E\u5230\u591A\u6761\u5339\u914D\uFF0C\u8BF7\u4F7F\u7528\u5E8F\u53F7\u7CBE\u786E\u6307\u5B9A\uFF1A
+${list}`;
+                }
+              }
+            }
+            if (!entry) {
+              const result2 = `\u672A\u627E\u5230\u4E0E '${query}' \u76F8\u5173\u7684\u8BB0\u5FC6`;
+              await log("info", `[haimati_move] \u51FA\u53C2:
+${truncateForLog(result2)}`);
+              return result2;
+            }
+            const oldCategory = entry.category;
+            const oldPath = `${oldCategory}/${entry.title}`;
+            const newCategory = args.newCategory;
+            const newPath = `${newCategory}/${entry.title}`;
+            const newEntries = entries.map((e) => {
+              if (e.id === entry.id) {
+                return { ...e, category: newCategory };
+              }
+              return e;
+            });
+            await writeIndexAsync(directory, newEntries);
+            const result = `\u5DF2\u79FB\u52A8\u6D77\u9A6C\u4F53 #${entry.id}
+\u65E7\u8DEF\u5F84: ${oldPath}
+\u65B0\u8DEF\u5F84: ${newPath}`;
+            await log("info", `[haimati_move] \u51FA\u53C2:
+${truncateForLog(result)}`);
+            return result;
+          } catch (error) {
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            const stack = error instanceof Error ? error.stack : "";
+            await log("error", `[haimati_move] \u51FA\u53C2: \u9519\u8BEF: ${errorMsg}
+\u5806\u6808: ${stack}`);
+            return `\u9519\u8BEF: ${errorMsg}`;
+          }
+        }
+      }),
+      /**
+       * haimati_list - 列出海马体索引结构
+       */
+      haimati_list: tool({
+        description: "\u5217\u51FA\u6D77\u9A6C\u4F53\u8BB0\u5FC6\u7CFB\u7EDF\u7684\u5B8C\u6574\u7D22\u5F15\u7ED3\u6784\u3002",
+        args: {
+          category: tool.schema.string().optional().describe("\u53EF\u9009\u7684\u5206\u7C7B\u8DEF\u5F84\uFF0C\u5217\u51FA\u8BE5\u5206\u7C7B\u4E0B\u7684\u6761\u76EE"),
+          recursive: tool.schema.boolean().optional().default(false).describe("\u662F\u5426\u9012\u5F52\u904D\u5386\u5B50\u5206\u7C7B\uFF0C\u9ED8\u8BA4false")
+        },
+        async execute(args, context) {
+          const { directory } = context;
+          const indexPath = getIndexPath(directory);
+          await log("info", `[haimati_list] \u5165\u53C2: category="${args.category || "(\u65E0)"}, recursive=${args.recursive}"`);
+          if (!fs.existsSync(indexPath)) {
+            const result = `\u9519\u8BEF\uFF1A\u6D77\u9A6C\u4F53\u7D22\u5F15\u4E0D\u5B58\u5728`;
+            await log("warn", `[haimati_list] \u51FA\u53C2:
+${truncateForLog(result)}`);
+            return result;
+          }
+          try {
+            const entries = await readIndexAsync(directory);
+            if (args.category) {
+              const indexContent = fs.readFileSync(getIndexPath(directory), "utf-8");
+              const lines = indexContent.split("\n");
+              let targetDepth = 0;
+              let currentPath = [];
+              for (const line of lines) {
+                if (!line.trim()) continue;
+                const depth = getTreeDepth(line);
+                const entryMatch = line.match(/^\s*[│├└─\s]*(.+?)\s*-\s*(\d+)\s*$/);
+                if (entryMatch) continue;
+                const name = extractCategoryName(line);
+                if (name) {
+                  if (name === "/") {
+                    currentPath[depth] = "";
+                  } else {
+                    currentPath[depth] = name;
+                  }
+                  currentPath = currentPath.slice(0, depth + 1);
+                  const fullPath = currentPath.filter(Boolean).join("/");
+                  if (fullPath === args.category) {
+                    targetDepth = depth;
+                    break;
+                  }
+                }
+              }
+              const subCategories = [];
+              const directEntries = [];
+              currentPath = [];
+              for (const line of lines) {
+                if (!line.trim()) continue;
+                const depth = getTreeDepth(line);
+                const entryMatch = line.match(/^\s*[│├└─\s]*(.+?)\s*-\s*(\d+)\s*$/);
+                if (entryMatch) {
+                  const title = entryMatch[1].trim();
+                  const id = entryMatch[2];
+                  if (depth === targetDepth + 1) {
+                    const entryCategory = currentPath.slice(1, depth).filter(Boolean).join("/");
+                    if (entryCategory === args.category) {
+                      directEntries.push({ category: entryCategory, title, id });
+                    }
+                  }
+                  continue;
+                }
+                const name = extractCategoryName(line);
+                if (name) {
+                  if (name === "/") {
+                    currentPath[depth] = "";
+                  } else {
+                    currentPath[depth] = name;
+                  }
+                  currentPath = currentPath.slice(0, depth + 1);
+                  if (depth === targetDepth + 1) {
+                    const fullPath = currentPath.filter(Boolean).join("/");
+                    if (fullPath === args.category) {
+                      subCategories.push(name);
+                    }
+                  }
+                }
+              }
+              let result2 = `## ${args.category}
+
+`;
+              if (args.recursive) {
+                const allDescendants = entries.filter(
+                  (e) => e.category === args.category || e.category.startsWith(args.category + "/")
+                );
+                const grouped = /* @__PURE__ */ new Map();
+                for (const entry of allDescendants) {
+                  const rel = entry.category.slice(args.category.length + 1);
+                  const firstPart = rel.split("/")[0] || "(\u76F4\u63A5)";
+                  if (!grouped.has(firstPart)) {
+                    grouped.set(firstPart, []);
+                  }
+                  grouped.get(firstPart).push(entry);
+                }
+                for (const [group, groupEntries] of grouped) {
+                  result2 += `### ${group}/
+`;
+                  result2 += groupEntries.map((e) => `- ${e.title} - ${e.id}`).join("\n") + "\n\n";
+                }
+              } else {
+                if (subCategories.length > 0) {
+                  result2 += "**\u5B50\u5206\u7C7B\uFF1A**\n" + subCategories.map((c) => `- ${c}/`).join("\n") + "\n\n";
+                }
+                if (directEntries.length > 0) {
+                  result2 += "**\u76F4\u63A5\u6761\u76EE\uFF1A**\n" + directEntries.map((e) => `- ${e.title} - ${e.id}`).join("\n");
+                }
+              }
+              await log("info", `[haimati_list] \u51FA\u53C2:
+${truncateForLog(result2)}`);
+              return result2;
+            }
+            const tree = buildIndexTree(entries);
+            const result = `## \u6D77\u9A6C\u4F53\u7D22\u5F15
+
+${tree || "(\u7A7A)"}`;
+            await log("info", `[haimati_list] \u51FA\u53C2:
+${truncateForLog(result)}`);
+            return result;
+          } catch (error) {
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            const stack = error instanceof Error ? error.stack : "";
+            await log("error", `[haimati_list] \u51FA\u53C2: \u9519\u8BEF: ${errorMsg}
+\u5806\u6808: ${stack}`);
+            return `\u9519\u8BEF: ${errorMsg}`;
+          }
+        }
+      })
+    },
+    /**
+     * session.created - 会话创建时注入海马体规则
+     * 在每次新会话开始时，自动将海马体三大原则注入到上下文中
+     */
+    event: async ({ event: evt }) => {
+      if (evt.type !== "session.created") {
+        return;
+      }
+      try {
+        const sessionId = evt.properties?.info?.id;
+        if (!sessionId) {
+          await log("warn", "[session.created] \u65E0\u6CD5\u83B7\u53D6 sessionID\uFF0C\u8DF3\u8FC7\u6CE8\u5165");
+          return;
+        }
+        await ctx.client.session.prompt({
+          path: { id: sessionId },
+          body: {
+            noReply: true,
+            parts: [{
+              type: "text",
+              text: `## \u6D77\u9A6C\u4F53\u8BB0\u5FC6\u7CFB\u7EDF\u4F7F\u7528\u89C4\u5219
+
+\u4F60\u6709\u4E00\u4E2A\u6D77\u9A6C\u4F53\u8BB0\u5FC6\u7CFB\u7EDF\u53EF\u7528\uFF0C\u7528\u4E8E\u5B58\u50A8\u548C\u68C0\u7D22\u8DE8\u4F1A\u8BDD\u7684\u77E5\u8BC6\u3002
+
+### \u6D77\u9A6C\u4F53\u4E09\u5927\u539F\u5219
+
+1. **\u4FE1\u606F\u4E0D\u4E22\u5931**: \u5B8C\u6574\u4FDD\u7559\u6240\u6709\u6709\u4EF7\u503C\u7684\u4FE1\u606F\uFF0C\u8BB0\u4F4F
+   - \u5B8C\u6574\u7684\u4E1A\u52A1\u548C\u6280\u672F\u77E5\u8BC6
+   - \u4E0E\u7528\u6237\u7684\u9700\u6C42\u9897\u7C92\u5EA6\u5BF9\u9F50
+   - \u9009\u62E9\u7684\u51B3\u7B56\uFF0C\u4EE5\u53CA\u597D\u5904\u4E0E\u574F\u5904
+   - xxx\u662F\u4EC0\u4E48\u3001\u4E3A\u4EC0\u4E48xxx\uFF08\u4E3A\u4EC0\u4E48\u8FD9\u4E48\u53BB\u505A\uFF09\u3001xxx\u600E\u4E48\u529E\uFF08\u9047\u5230\u67D0\u67D0\u60C5\u51B5\uFF0C\u662F\u600E\u4E48\u529E\u7684\uFF09
+   - \u7B2C\u4E09\u65B9\u63A5\u53E3\u5B8C\u6574\u7684\u5165\u53C2\u3001\u51FA\u53C2\u3001\u8BF4\u660E\u3001\u8C03\u7528\u65F6\u673A
+   - \u5176\u4ED6\u5404\u79CD\u6709\u4EF7\u503C\u7684\u77E5\u8BC6
+
+2. **\u9519\u8BEF\u4FE1\u606F\u4FEE\u6B63**: \u4E0D\u518D\u4FDD\u7559\u5DF2\u88AB\u7EA0\u6B63\u7684\u9519\u8BEF\u4FE1\u606F\u3001\u4E0D\u4FDD\u7559\u5DF2\u7ECF\u8FC7\u671F\u7684\u5E9F\u5F03\u7684\u4FE1\u606F
+
+3. **\u62D2\u7EDD\u5197\u4F59**: \u4E0D\u8981\u91CD\u590D\u8BB0\u5F55\u76F8\u540C\u5185\u5BB9\uFF0C\u8282\u7EA6TOKEN
+
+### \u53EF\u7528\u5DE5\u5177
+
+**\u6CE8\u610F**\uFF1A\u4EE5\u4E0B\u5DE5\u5177\u5217\u8868\u5DF2\u66F4\u65B0\uFF0C\u8BF7\u4F7F\u7528\u5E8F\u53F7\u67E5\u8BE2\u4EE3\u66FF\u8DEF\u5F84\u67E5\u8BE2\u3002haimati_read/haimati_edit \u8FD4\u56DE\u7684 version \u7528\u4E8E\u5E76\u53D1\u63A7\u5236\u3002
+
+- \`haimati_read\` - \u8BFB\u53D6\u8BB0\u5FC6\u5185\u5BB9\uFF08\u53EA\u652F\u6301\u5E8F\u53F7\u67E5\u8BE2\uFF0C\u652F\u6301\u5206\u9875\uFF0C\u8FD4\u56DE\u5E26\u884C\u53F7\u548C\u7248\u672C\u53F7\uFF09
+- \`haimati_write\` - \u5199\u5165\u65B0\u8BB0\u5FC6\uFF08\u8986\u76D6\u5DF2\u6709\u5185\u5BB9\u65F6\u7248\u672C+1\uFF09
+- \`haimati_search\` - \u641C\u7D22\u8BB0\u5FC6\u5185\u5BB9\uFF08\u641C\u7D22\u8303\u56F4\uFF1A\u6807\u9898\u3001\u5206\u7C7B\u3001\u5E8F\u53F7\u3001\u4E66\u9875\u5185\u5BB9\u3002**\u6CE8\u610F\uFF1Amatch\u53C2\u6570\u5FC5\u586B\uFF0Cand=\u6240\u6709\u5173\u952E\u5B57\u90FD\u5339\u914D\uFF0Cor=\u4EFB\u610F\u5173\u952E\u5B57\u5339\u914D**\uFF09
+- \`haimati_edit\` - \u4FEE\u6539\u8BB0\u5FC6\u5185\u5BB9\uFF08\u90E8\u5206\u66FF\u6362\uFF0C\u901A\u8FC7\u884C\u53F7\u8303\u56F4\u66FF\u6362\u5185\u5BB9\uFF0C\u652F\u6301\u7248\u672C\u5E76\u53D1\u63A7\u5236\uFF09
+- \`haimati_move\` - \u4FEE\u6539\u8BB0\u5FC6\u7684\u5206\u7C7B\u8DEF\u5F84
+- \`haimati_delete\` - \u5220\u9664\u8BB0\u5FC6
+- \`haimati_list\` - \u5217\u51FA\u8BB0\u5FC6\u7D22\u5F15
+
+### \u4F7F\u7528\u65F6\u673A
+
+**\u4F1A\u8BDD\u5F00\u59CB\u524D**: \u4F7F\u7528 haimati_list \u6216 haimati_search \u8BFB\u53D6\u4E0E\u5F53\u524D\u4EFB\u52A1\u76F8\u5173\u7684\u8BB0\u5FC6\u5185\u5BB9\uFF0C\u518D\u5F00\u59CB\u5DE5\u4F5C\u3002
+
+**\u4F1A\u8BDD\u7ED3\u675F\u540E**: \u4F7F\u7528 haimati_write \u5C06\u65B0\u83B7\u5F97\u7684\u77E5\u8BC6\u3001\u7ECF\u9A8C\u3001\u51B3\u7B56\u5199\u5165\u6D77\u9A6C\u4F53\uFF0C\u4FDD\u6301\u4FE1\u606F\u7684\u6301\u7EED\u79EF\u7D2F\u3002`
+            }]
+          }
+        });
+        await log("info", `[session.created] \u6D77\u9A6C\u4F53\u89C4\u5219\u5DF2\u6CE8\u5165\u65B0\u4F1A\u8BDD (sessionID: ${sessionId})`);
+      } catch (error) {
+        const errorMsg = error instanceof Error ? error.message : String(error);
+        await log("error", `[session.created] \u6CE8\u5165\u6D77\u9A6C\u4F53\u89C4\u5219\u5931\u8D25: ${errorMsg}`);
+      }
+    }
+  };
+};
+export {
+  HaimatiPlugin
+};

package/dist/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "opencode-haimati",
+  "version": "1.0.2",
+  "description": "OpenCode plugin for a file-based memory system inspired by the hippocampus, providing long-term memory storage and retrieval across sessions.",
+  "main": "./dist/index.js",
+  "type": "module",
+  "license": "MIT",
+  "files": ["dist"],
+  "scripts": {
+    "build": "npx esbuild index.ts --bundle --platform=node --outdir=dist --format=esm --external:@opencode-ai/plugin && cp package.json dist/",
+    "prepublishOnly": "npm run build",
+    "test": "npx tsx test/index.ts"
+  },
+  "peerDependencies": {
+    "@opencode-ai/plugin": ">=0.15.0",
+    "typescript": ">=5.0.0"
+  },
+  "devDependencies": {
+    "@opencode-ai/plugin": "^0.15.0",
+    "@types/bun": "^1.3.1",
+    "typescript": "^5.9.3"
+  }
+}

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "opencode-haimati",
+  "version": "1.0.2",
+  "description": "OpenCode plugin for a file-based memory system inspired by the hippocampus, providing long-term memory storage and retrieval across sessions.",
+  "main": "./dist/index.js",
+  "type": "module",
+  "license": "MIT",
+  "files": ["dist"],
+  "scripts": {
+    "build": "npx esbuild index.ts --bundle --platform=node --outdir=dist --format=esm --external:@opencode-ai/plugin && cp package.json dist/",
+    "prepublishOnly": "npm run build",
+    "test": "npx tsx test/index.ts"
+  },
+  "peerDependencies": {
+    "@opencode-ai/plugin": ">=0.15.0",
+    "typescript": ">=5.0.0"
+  },
+  "devDependencies": {
+    "@opencode-ai/plugin": "^0.15.0",
+    "@types/bun": "^1.3.1",
+    "typescript": "^5.9.3"
+  }
+}