opencode-haimati 1.0.2 → 1.0.3

package/README.md

@@ -7,10 +7,12 @@
 - 🧠 类海马体记忆机制：模拟人脑记忆系统的分类存储
 - 📁 树形索引结构：通过 `.haimati/索引.md` 维护记忆索引
 - 📚 分组书页存储：记忆内容按序号分组存储于 `.haimati/书页/` 目录
-- 🔍 多模式查询：支持序号、路径、标题精确匹配和模糊搜索
-- ✏️ 完整 CRUD：读取、写入、更新、删除、移动记忆
+- 🔍 多模式搜索：支持序号精确查询和关键字模糊搜索
+- ✏️ 完整 CRUD：读取、写入、更新（部分替换）、删除、移动记忆
+- 🔄 版本并发控制：基于 version 的乐观锁，防止多会话并发冲突
 - 🔄 自动规则注入：新会话自动注入海马体使用原则
 - 📋 日志追踪：完整的操作日志记录
+- ⚡ 纯异步架构：所有文件操作非阻塞执行
 
 ## 安装
 
@@ -35,8 +37,10 @@ bun add -g opencode-haimati
 
 ```
 .haimati/
-├── 索引.md      # 树形结构索引
-└── 书页/        # 存储各记忆内容（按序号分组）
+├── .lock              # 序号分配锁
+├── 索引.md            # 树形结构索引
+├── next-id.txt        # 下一个可用序号
+└── 书页/              # 存储各记忆内容（按序号分组）
     ├── 001-050/
     │   ├── 001.md
     │   └── 002.md
@@ -46,13 +50,15 @@ bun add -g opencode-haimati
 
 ## 可用工具
 
-- `haimati_read` - 从海马体读取记忆（支持序号、路径、标题查询）
-- `haimati_write` - 写入新记忆
-- `haimati_search` - 搜索记忆内容
-- `haimati_update` - 更新已有记忆的内容
-- `haimati_move` - 修改记忆的分类路径
-- `haimati_delete` - 删除记忆
-- `haimati_list` - 列出记忆索引
+| 工具 | 说明 |
+|------|------|
+| `haimati_read` | 读取记忆内容（只支持序号查询，支持分页，返回带行号和版本号） |
+| `haimati_write` | 写入新记忆（覆盖已有内容时版本+1） |
+| `haimati_search` | 搜索记忆内容（标题、分类、序号、书页内容） |
+| `haimati_edit` | 修改记忆内容（部分替换，支持版本并发控制） |
+| `haimati_move` | 修改记忆的分类路径 |
+| `haimati_delete` | 删除记忆 |
+| `haimati_list` | 列出记忆索引 |
 
 ## 海马体三大原则
 
@@ -70,13 +76,35 @@ haimati_write({
   content: "WebSocket通信采用base64编码..."
 })
 
-// 读取记忆
+// 读取记忆（只支持序号查询）
 haimati_read({ query: "086" })
-// 或
-haimati_read({ query: "标立方/签章/签章服务WS通信机制" })
 
 // 搜索记忆
-haimati_search({ keyword: "WebSocket", limit: 10 })
+haimati_search({ keyword: "WebSocket", match: "or", limit: 10 })
+
+// 部分修改记忆
+haimati_edit({
+  query: "086",
+  offsetBegin: 3,
+  offsetEnd: 5,
+  content: "新的替换内容",
+  version: 1
+})
+
+// 移动记忆到新分类
+haimati_move({
+  query: "086",
+  newCategory: "标立方/客户端"
+})
+
+// 删除记忆
+haimati_delete({ query: "086" })
+
+// 列出所有记忆
+haimati_list({})
+
+// 列出指定分类下的记忆
+haimati_list({ category: "标立方", recursive: true })
 ```
 
 ## 索引格式示例
@@ -97,4 +125,4 @@ haimati_search({ keyword: "WebSocket", limit: 10 })
 
 ## 许可证
 
-MIT
+MIT

package/dist/index.js

@@ -3,24 +3,30 @@ import fs from "fs";
 import path from "path";
 import os from "os";
 import { tool } from "@opencode-ai/plugin";
+import { promisify } from "util";
+var fsReadFile = promisify(fs.readFile);
+var fsWriteFile = promisify(fs.writeFile);
+var fsUnlink = promisify(fs.unlink);
+var fsMkdir = promisify(fs.mkdir);
+var fsExists = promisify(fs.exists);
+var fsStat = promisify(fs.stat);
 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) {
+async function getConfigHaimatiPath(directory) {
   const configPath = path.join(directory, HAIMATI_CONFIG_FILE);
-  if (!fs.existsSync(configPath)) {
+  if (!await fsExists(configPath)) {
     return null;
   }
   try {
-    const content = fs.readFileSync(configPath, "utf-8");
+    const content = await fsReadFile(configPath, "utf-8");
     const lines = content.split("\n");
     for (const line of lines) {
       const trimmed = line.trim();
@@ -41,35 +47,36 @@ function getConfigHaimatiPath(directory) {
   }
   return null;
 }
-function getHaimatiDir(directory) {
-  const configPath = getConfigHaimatiPath(directory);
+async function getHaimatiDir(directory) {
+  const configPath = await getConfigHaimatiPath(directory);
   if (configPath) {
     return configPath;
   }
   return path.join(directory, HAIMATI_DIR);
 }
-function getIndexPath(directory) {
-  return path.join(getHaimatiDir(directory), INDEX_FILE);
+async function getIndexPath(directory) {
+  return path.join(await getHaimatiDir(directory), INDEX_FILE);
 }
-function getNextIdPath(directory) {
-  return path.join(getHaimatiDir(directory), NEXT_ID_FILE);
+async function getNextIdPath(directory) {
+  return path.join(await getHaimatiDir(directory), NEXT_ID_FILE);
 }
-function getLockPath(directory) {
-  return path.join(getHaimatiDir(directory), ".lock");
+async function getLockPath(directory) {
+  return path.join(await getHaimatiDir(directory), ".lock");
 }
-function getPagesDir(directory) {
-  return path.join(getHaimatiDir(directory), PAGES_DIR);
+async function getPagesDir(directory) {
+  return path.join(await getHaimatiDir(directory), PAGES_DIR);
 }
-function getPageGroupDir(directory, id) {
+async 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);
+  return path.join(await getPagesDir(directory), groupName);
 }
-function getPagePath(directory, id) {
-  return path.join(getPageGroupDir(directory, id), `${id}.md`);
+async function getPagePath(directory, id) {
+  return path.join(await getPageGroupDir(directory, id), `${id}.md`);
 }
+var fsAppendFile = promisify(fs.appendFile);
 function getLogFilePath() {
   const osTmpDir = os.tmpdir();
   return path.join(osTmpDir, "haimati_logs", LOG_FILE);
@@ -81,12 +88,12 @@ async function writeLogToFile(message) {
     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 });
+    if (!await fsExists(logDir)) {
+      await fsMkdir(logDir, { recursive: true });
     }
     let shouldOverwrite = false;
-    if (fs.existsSync(logPath)) {
-      const mtime = fs.statSync(logPath).mtime;
+    if (await fsExists(logPath)) {
+      const mtime = (await fsStat(logPath)).mtime;
       const fileDate = mtime.toISOString().split("T")[0];
       if (fileDate !== dateStr) {
         shouldOverwrite = true;
@@ -94,9 +101,9 @@ async function writeLogToFile(message) {
     }
     const logLine = `[${timeStr}] ${message}`;
     if (shouldOverwrite) {
-      fs.writeFileSync(logPath, logLine + "\n", "utf-8");
+      await fsWriteFile(logPath, logLine + "\n", "utf-8");
     } else {
-      fs.appendFileSync(logPath, logLine + "\n", "utf-8");
+      await fsAppendFile(logPath, logLine + "\n", "utf-8");
     }
   } catch (error) {
     console.error(`[haimati] \u5199\u5165\u65E5\u5FD7\u6587\u4EF6\u5931\u8D25:`, error);
@@ -181,7 +188,7 @@ function findEntryById(entries, id) {
 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) {
+async function searchEntries(entries, keyword, matchMode, directory, searchContent = false) {
   const keywords = keyword.toLowerCase().split(/\s+/).filter((k) => k.length > 0);
   if (keywords.length === 0) return [];
   const matchedWithScore = [];
@@ -197,7 +204,7 @@ async function searchEntriesAsync(entries, keyword, matchMode, directory, search
       }
     }
     if (searchContent && directory) {
-      const page = await readPageAsync(directory, e.id);
+      const page = await readPage(directory, e.id);
       if (page && page.content) {
         const contentLower = page.content.toLowerCase();
         for (const kw of keywords) {
@@ -221,12 +228,12 @@ async function searchEntriesAsync(entries, keyword, matchMode, directory, search
   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)) {
+async function readNextIdFromFile(directory) {
+  const nextIdPath = await getNextIdPath(directory);
+  if (!await fsExists(nextIdPath)) {
     return 1;
   }
-  const content = fs.readFileSync(nextIdPath, "utf-8");
+  const content = await fsReadFile(nextIdPath, "utf-8");
   const trimmed = content.trim();
   const parsed = parseInt(trimmed, 10);
   if (!isNaN(parsed) && parsed > 0) {
@@ -234,58 +241,55 @@ async function readNextIdFromFileAsync(directory) {
   }
   return 1;
 }
-async function initializeNextIdIfNeededAsync(directory) {
-  const nextIdPath = getNextIdPath(directory);
-  if (fs.existsSync(nextIdPath)) {
+async function initializeNextIdIfNeeded(directory) {
+  const nextIdPath = await getNextIdPath(directory);
+  if (await fsExists(nextIdPath)) {
     return;
   }
-  const entries = await readIndexAsync(directory);
+  const entries = await readIndex(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);
+  await writeNextIdToFile(directory, maxId + 1);
 }
-async function writeNextIdToFileAsync(directory, nextId) {
-  const haimatiDir = getHaimatiDir(directory);
-  if (!fs.existsSync(haimatiDir)) {
-    fs.mkdirSync(haimatiDir, { recursive: true });
+async function writeNextIdToFile(directory, nextId) {
+  const haimatiDir = await getHaimatiDir(directory);
+  if (!await fsExists(haimatiDir)) {
+    await fsMkdir(haimatiDir, { recursive: true });
   }
-  const nextIdPath = getNextIdPath(directory);
-  fs.writeFileSync(nextIdPath, String(nextId), "utf-8");
+  const nextIdPath = await getNextIdPath(directory);
+  await fsWriteFile(nextIdPath, String(nextId), "utf-8");
 }
-function acquireLock(directory) {
-  const haimatiDir = getHaimatiDir(directory);
-  if (!fs.existsSync(haimatiDir)) {
-    fs.mkdirSync(haimatiDir, { recursive: true });
+async function acquireLock(directory) {
+  const haimatiDir = await getHaimatiDir(directory);
+  if (!await fsExists(haimatiDir)) {
+    await fsMkdir(haimatiDir, { recursive: true });
   }
-  const lockPath = getLockPath(directory);
+  const lockPath = await getLockPath(directory);
   const startTime = Date.now();
-  while (fs.existsSync(lockPath)) {
+  while (await fsExists(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) {
-    }
+    await new Promise((resolve) => setTimeout(resolve, 50 + Math.random() * 20));
   }
-  fs.writeFileSync(lockPath, String(process.pid), "utf-8");
+  await fsWriteFile(lockPath, String(process.pid), "utf-8");
   return true;
 }
-function releaseLock(directory) {
-  const lockPath = getLockPath(directory);
-  if (fs.existsSync(lockPath)) {
-    fs.unlinkSync(lockPath);
+async function releaseLock(directory) {
+  const lockPath = await getLockPath(directory);
+  if (await fsExists(lockPath)) {
+    await fsUnlink(lockPath);
   }
 }
-async function readPageAsync(directory, id) {
-  const pagePath = getPagePath(directory, id);
-  if (!fs.existsSync(pagePath)) {
+async function readPage(directory, id) {
+  const pagePath = await getPagePath(directory, id);
+  if (!await fsExists(pagePath)) {
     return null;
   }
-  const content = fs.readFileSync(pagePath, "utf-8");
+  const content = await fsReadFile(pagePath, "utf-8");
   const lines = content.split("\n");
   if (lines.length < 2) {
     return null;
@@ -305,25 +309,25 @@ async function readPageAsync(directory, id) {
     version
   };
 }
-async function writePageAsync(directory, id, title, createdAt, content, version = 1) {
-  const pagesDir = getPagesDir(directory);
-  if (!fs.existsSync(pagesDir)) {
-    fs.mkdirSync(pagesDir, { recursive: true });
+async function writePage(directory, id, title, createdAt, content, version = 1) {
+  const pagesDir = await getPagesDir(directory);
+  if (!await fsExists(pagesDir)) {
+    await fsMkdir(pagesDir, { recursive: true });
   }
-  const pageGroupDir = getPageGroupDir(directory, id);
-  if (!fs.existsSync(pageGroupDir)) {
-    fs.mkdirSync(pageGroupDir, { recursive: true });
+  const pageGroupDir = await getPageGroupDir(directory, id);
+  if (!await fsExists(pageGroupDir)) {
+    await fsMkdir(pageGroupDir, { recursive: true });
   }
-  const pagePath = getPagePath(directory, id);
+  const pagePath = await getPagePath(directory, id);
   const fileContent = `${title}
 ${createdAt}
 ${content}${VERSION_SEPARATOR}${version}`;
-  fs.writeFileSync(pagePath, fileContent, "utf-8");
+  await fsWriteFile(pagePath, fileContent, "utf-8");
 }
-async function deletePageAsync(directory, id) {
-  const pagePath = getPagePath(directory, id);
-  if (fs.existsSync(pagePath)) {
-    fs.unlinkSync(pagePath);
+async function deletePage(directory, id) {
+  const pagePath = await getPagePath(directory, id);
+  if (await fsExists(pagePath)) {
+    await fsUnlink(pagePath);
     return true;
   }
   return false;
@@ -386,57 +390,57 @@ function buildIndexTree(entries) {
 function removeIndexEntry(entries, id) {
   return entries.filter((e) => e.id !== id);
 }
-async function readIndexAsync(directory) {
-  const indexPath = getIndexPath(directory);
-  if (!fs.existsSync(indexPath)) {
+async function readIndex(directory) {
+  const indexPath = await getIndexPath(directory);
+  if (!await fsExists(indexPath)) {
     return [];
   }
-  const content = fs.readFileSync(indexPath, "utf-8");
+  const content = await fsReadFile(indexPath, "utf-8");
   return parseIndex(content);
 }
-async function writeIndexAsync(directory, entries) {
-  const haimatiDir = getHaimatiDir(directory);
-  if (!fs.existsSync(haimatiDir)) {
-    fs.mkdirSync(haimatiDir, { recursive: true });
+async function writeIndex(directory, entries) {
+  const haimatiDir = await getHaimatiDir(directory);
+  if (!await fsExists(haimatiDir)) {
+    await fsMkdir(haimatiDir, { recursive: true });
   }
   const tree = buildIndexTree(entries);
-  const indexPath = getIndexPath(directory);
-  fs.writeFileSync(indexPath, tree, "utf-8");
+  const indexPath = await getIndexPath(directory);
+  await fsWriteFile(indexPath, tree, "utf-8");
 }
 async function allocateIdWithLock(directory, category, title, now, content) {
-  if (!acquireLock(directory)) {
+  if (!await acquireLock(directory)) {
     return null;
   }
   try {
-    await initializeNextIdIfNeededAsync(directory);
-    const entries = await readIndexAsync(directory);
+    await initializeNextIdIfNeeded(directory);
+    const entries = await readIndex(directory);
     const existingEntry = entries.find((e) => e.category === category && e.title === title);
     if (existingEntry) {
-      const page = await readPageAsync(directory, existingEntry.id);
+      const page = await readPage(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 writePage(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 currentNext = await readNextIdFromFile(directory);
     const newId = String(currentNext).padStart(3, "0");
-    await writePageAsync(directory, newId, title, now, content, 1);
+    await writePage(directory, newId, title, now, content, 1);
     const newEntry = {
       id: newId,
       category,
       title
     };
     entries.push(newEntry);
-    await writeIndexAsync(directory, entries);
-    await writeNextIdToFileAsync(directory, currentNext + 1);
+    await writeIndex(directory, entries);
+    await writeNextIdToFile(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);
+    await releaseLock(directory);
   }
 }
 var HaimatiPlugin = async (ctx) => {
@@ -466,16 +470,16 @@ var HaimatiPlugin = async (ctx) => {
          */
         async execute(args, context) {
           const { directory } = context;
-          const indexPath = getIndexPath(directory);
+          const indexPath = await getIndexPath(directory);
           await log("info", `[haimati_read] \u5165\u53C2: query="${args.query}", offset=${args.offset || 1}, limit=${args.limit || 2e3}`);
-          if (!fs.existsSync(indexPath)) {
+          if (!await fsExists(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);
+            const entries = await readIndex(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)) {
@@ -492,14 +496,15 @@ ${truncateForLog(result2)}`);
 ${truncateForLog(result2)}`);
               return result2;
             }
-            const page = await readPageAsync(directory, entry.id);
+            const page = await readPage(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 pageGroupDir = await getPageGroupDir(directory, entry.id);
+            await log("debug", `[haimati_read] \u8BFB\u53D6\u4E66\u9875: \u4E66\u9875/${pageGroupDir.split(/[\\/]/).pop()}/${entry.id}.md, version=${page.version}`);
             const contentLines = page.content.split("\n");
             const offset = args.offset || 1;
             const limit = args.limit || 2e3;
@@ -550,8 +555,9 @@ ${truncateForLog(args.content)}
               await log("warn", `[haimati_write] \u9501\u83B7\u53D6\u5931\u8D25\uFF0C\u91CD\u8BD5\u7B2C ${retry + 1} \u6B21`);
             }
             if (newId) {
+              const pageGroupDir = await getPageGroupDir(directory, 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`);
+              await log("debug", `[haimati_write] \u4E66\u9875\u548C\u7D22\u5F15\u5DF2\u66F4\u65B0: \u4E66\u9875/${pageGroupDir.split(/[\\/]/).pop()}/${newId}.md`);
               const result2 = `\u5DF2\u5199\u5165\u6D77\u9A6C\u4F53 #${newId}
 \u8DEF\u5F84: ${args.category}/${args.title}
 \u7248\u672C: 1`;
@@ -559,10 +565,10 @@ ${truncateForLog(args.content)}
 ${truncateForLog(result2)}`);
               return result2;
             }
-            const entries = await readIndexAsync(directory);
+            const entries = await readIndex(directory);
             const existingEntry = findEntryByPath(entries, args.category, args.title);
             if (existingEntry) {
-              const page = await readPageAsync(directory, existingEntry.id);
+              const page = await readPage(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}
@@ -599,21 +605,21 @@ ${truncateForLog(result)}`);
         },
         async execute(args, context) {
           const { directory } = context;
-          const indexPath = getIndexPath(directory);
+          const indexPath = await 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)) {
+          if (!await fsExists(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 entries = await readIndex(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 allMatched = await searchEntries(entries, keyword, match, directory, true);
             const totalCount = allMatched.length;
             const matched = allMatched.slice(offset, offset + limit);
             if (matched.length === 0) {
@@ -632,7 +638,7 @@ ${truncateForLog(result2)}`);
 `);
             }
             for (const entry of matched) {
-              const page = await readPageAsync(directory, entry.id);
+              const page = await readPage(directory, entry.id);
               const fullPath = `${entry.category}/${entry.title}`;
               let excerpt = "";
               if (page) {
@@ -683,18 +689,18 @@ ${truncateForLog(result)}`);
         },
         async execute(args, context) {
           const { directory } = context;
-          const indexPath = getIndexPath(directory);
+          const indexPath = await 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)) {
+          if (!await fsExists(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 entries = await readIndex(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`;
@@ -709,7 +715,7 @@ ${truncateForLog(result2)}`);
 ${truncateForLog(result2)}`);
               return result2;
             }
-            const page = await readPageAsync(directory, entry.id);
+            const page = await readPage(directory, entry.id);
             if (!page) {
               const result2 = `\u672A\u627E\u5230\u4E66\u9875: #${entry.id}`;
               await log("error", `[haimati_edit] \u51FA\u53C2:
@@ -733,15 +739,12 @@ ${truncateForLog(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);
+            await writePage(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}
@@ -768,16 +771,16 @@ ${truncateForLog(result)}`);
         },
         async execute(args, context) {
           const { directory } = context;
-          const indexPath = getIndexPath(directory);
+          const indexPath = await getIndexPath(directory);
           await log("info", `[haimati_delete] \u5165\u53C2: query="${args.query}"`);
-          if (!fs.existsSync(indexPath)) {
+          if (!await fsExists(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 entries = await readIndex(directory);
             const query = args.query.trim();
             let entry = null;
             if (/^\d+$/.test(query)) {
@@ -789,7 +792,7 @@ ${truncateForLog(result)}`);
                 const category = parts.join("/");
                 entry = findEntryByPath(entries, category, title);
               } else {
-                const results = await searchEntriesAsync(entries, query, "or", directory);
+                const results = await searchEntries(entries, query, "or", directory);
                 if (results.length === 1) {
                   entry = results[0];
                 } else if (results.length > 1) {
@@ -805,9 +808,9 @@ ${list}`;
 ${truncateForLog(result2)}`);
               return result2;
             }
-            await deletePageAsync(directory, entry.id);
+            await deletePage(directory, entry.id);
             const newEntries = removeIndexEntry(entries, entry.id);
-            await writeIndexAsync(directory, newEntries);
+            await writeIndex(directory, newEntries);
             const fullPath = `${entry.category}/${entry.title}`;
             const result = `\u5DF2\u5220\u9664\u6D77\u9A6C\u4F53 #${entry.id}
 \u8DEF\u5F84: ${fullPath}`;
@@ -834,16 +837,16 @@ ${truncateForLog(result)}`);
         },
         async execute(args, context) {
           const { directory } = context;
-          const indexPath = getIndexPath(directory);
+          const indexPath = await getIndexPath(directory);
           await log("info", `[haimati_move] \u5165\u53C2: query="${args.query}", newCategory="${args.newCategory}"`);
-          if (!fs.existsSync(indexPath)) {
+          if (!await fsExists(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 entries = await readIndex(directory);
             const query = args.query.trim();
             let entry = null;
             if (/^\d+$/.test(query)) {
@@ -855,7 +858,7 @@ ${truncateForLog(result)}`);
                 const category = parts.join("/");
                 entry = findEntryByPath(entries, category, title);
               } else {
-                const results = await searchEntriesAsync(entries, query, "or", directory);
+                const results = await searchEntries(entries, query, "or", directory);
                 if (results.length === 1) {
                   entry = results[0];
                 } else if (results.length > 1) {
@@ -881,7 +884,7 @@ ${truncateForLog(result2)}`);
               }
               return e;
             });
-            await writeIndexAsync(directory, newEntries);
+            await writeIndex(directory, newEntries);
             const result = `\u5DF2\u79FB\u52A8\u6D77\u9A6C\u4F53 #${entry.id}
 \u65E7\u8DEF\u5F84: ${oldPath}
 \u65B0\u8DEF\u5F84: ${newPath}`;
@@ -908,18 +911,18 @@ ${truncateForLog(result)}`);
         },
         async execute(args, context) {
           const { directory } = context;
-          const indexPath = getIndexPath(directory);
+          const indexPath = await getIndexPath(directory);
           await log("info", `[haimati_list] \u5165\u53C2: category="${args.category || "(\u65E0)"}, recursive=${args.recursive}"`);
-          if (!fs.existsSync(indexPath)) {
+          if (!await fsExists(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);
+            const entries = await readIndex(directory);
             if (args.category) {
-              const indexContent = fs.readFileSync(getIndexPath(directory), "utf-8");
+              const indexContent = await fsReadFile(await getIndexPath(directory), "utf-8");
               const lines = indexContent.split("\n");
               let targetDepth = 0;
               let currentPath = [];

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-haimati",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "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",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-haimati",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "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",