foliko 1.1.68 → 1.1.69

package/plugins/storage-plugin.js

@@ -1,48 +1,88 @@
 /**
- * Storage 存储插件
- * 提供数据持久化存储，支持 JSON 文件存储
+ * Storage Plugin - JSONL-based key-value storage
+ * Supports delayed compaction to reduce file size
  */
 
-const { Plugin } = require('../src/core/plugin-base')
-const { logger } = require('../src/utils/logger')
-const log = logger.child('Storage')
-const { z } = require('zod')
-const fs = require('fs')
-const path = require('path')
+const { Plugin } = require('../src/core/plugin-base');
+const { logger } = require('../src/utils/logger');
+const log = logger.child('Storage');
+const { z } = require('zod');
+const path = require('path');
+const { StorageManager } = require('../src/core/storage-manager');
 
 class StoragePlugin extends Plugin {
   constructor(config = {}) {
-    super()
-    this.name = 'storage'
-    this.version = '1.0.0'
-    this.description = '数据持久化存储插件，支持键值对存储'
-    this.priority = 3
+    super();
+    this.name = 'storage';
+    this.version = '2.1.0';
+    this.description = '数据持久化存储插件，支持键值对存储（JSONL格式）+ 自动 compaction';
+    this.priority = 3;
 
-    this.system = true 
+    this.system = true;
 
     this.config = {
-      type: config.type || 'json',  // json 或 memory
-      path: config.path || '.agent/data',
-      namespace: config.namespace || 'default'
-    }
-
-    this._framework = null
-    this._store = new Map()
-    this._filePath = null
+      path: config.path || '.foliko/data',
+      namespace: config.namespace || 'default',
+      // Compaction 配置
+      compactionThreshold: config.compactionThreshold || 1000,
+      compactionIntervalMs: config.compactionIntervalMs || 5000,
+      autoCompact: config.autoCompact !== false,
+    };
+
+    this._framework = null;
+    this._storageManager = null;
   }
 
   install(framework) {
-    this._framework = framework
-    return this
+    this._framework = framework;
+    return this;
+  }
+
+  /**
+   * Initialize storage manager with compaction settings
+   */
+  _initStorage() {
+    if (this._storageManager) return;
+
+    const baseDir = path.resolve(process.cwd(), this.config.path);
+    const filePath = path.join(baseDir, `${this.config.namespace}.jsonl`);
+
+    // 传递 compaction 配置
+    this._storageManager = new StorageManager(filePath, true, {
+      compactionThreshold: this.config.compactionThreshold,
+      compactionIntervalMs: this.config.compactionIntervalMs,
+      autoCompact: this.config.autoCompact,
+    });
+  }
+
+  /**
+   * Get storage store (for internal use)
+   */
+  getStore() {
+    this._initStorage();
+    return this._storageManager;
+  }
+
+  /**
+   * Set value directly (for internal use by other plugins)
+   */
+  setDirect(key, value) {
+    this._initStorage();
+    return this._storageManager.set(key, value);
+  }
+
+  /**
+   * Delete key directly (for internal use by other plugins)
+   */
+  deleteDirect(key) {
+    this._initStorage();
+    return this._storageManager.delete(key);
   }
 
   start(framework) {
-    // 初始化存储
-    if (this.config.type === 'json') {
-      this._initJsonStore()
-    }
+    this._initStorage();
 
-    // 注册存储工具
+    // Register storage tools
     framework.registerTool({
       name: 'storage_set',
       description: '存储数据到键值存储',
@@ -53,23 +93,21 @@ class StoragePlugin extends Plugin {
       }),
       execute: async (args) => {
         try {
-          const ns = args.namespace || this.config.namespace
-          const fullKey = `${ns}:${args.key}`
-          this._store.set(fullKey, {
-            value: args.value,
-            updatedAt: new Date()
-          })
-
-          if (this.config.type === 'json') {
-            await this._persistToFile()
-          }
-
-          return { success: true, data: { key: args.key, namespace: ns } }
+          this._initStorage();
+          const ns = args.namespace ? `${args.namespace}:` : '';
+          const fullKey = `${ns}${args.key}`;
+          const entry = this._storageManager.set(fullKey, args.value);
+
+          return {
+            success: true,
+            data: { key: args.key, namespace: args.namespace || this.config.namespace }
+          };
         } catch (err) {
-          return { success: false, error: err.message }
+          log.error('storage_set error:', err.message);
+          return { success: false, error: err.message };
         }
       }
-    })
+    });
 
     framework.registerTool({
       name: 'storage_get',
@@ -79,46 +117,52 @@ class StoragePlugin extends Plugin {
         namespace: z.string().optional().describe('命名空间')
       }),
       execute: async (args) => {
-        const ns = args.namespace || this.config.namespace
-        const fullKey = `${ns}:${args.key}`
-        const entry = this._store.get(fullKey)
-
-        if (!entry) {
-          return { success: false, error: 'Key not found', key: args.key }
-        }
+        try {
+          this._initStorage();
+          const ns = args.namespace ? `${args.namespace}:` : '';
+          const fullKey = `${ns}${args.key}`;
+          const value = this._storageManager.get(fullKey);
 
-        return {
-          success: true,
-          data: {
-            key: args.key,
-            namespace: ns,
-            value: entry.value,
-            updatedAt: entry.updatedAt
+          if (value === null) {
+            return { success: false, error: 'Key not found', key: args.key };
           }
+
+          return {
+            success: true,
+            data: {
+              key: args.key,
+              namespace: args.namespace || this.config.namespace,
+              value
+            }
+          };
+        } catch (err) {
+          log.error('storage_get error:', err.message);
+          return { success: false, error: err.message };
         }
       }
-    })
+    });
 
     framework.registerTool({
       name: 'storage_delete',
-      description: '删除存储的数据',
+      description: '删除存储的数据（软删除，物理删除由 compaction 自动处理）',
       inputSchema: z.object({
         key: z.string().describe('存储键名'),
         namespace: z.string().optional().describe('命名空间')
       }),
       execute: async (args) => {
-        const ns = args.namespace || this.config.namespace
-        const fullKey = `${ns}:${args.key}`
-        const existed = this._store.has(fullKey)
-        this._store.delete(fullKey)
+        try {
+          this._initStorage();
+          const ns = args.namespace ? `${args.namespace}:` : '';
+          const fullKey = `${ns}${args.key}`;
+          const deleted = this._storageManager.delete(fullKey);
 
-        if (this.config.type === 'json') {
-          await this._persistToFile()
+          return { success: true, data: { deleted, key: args.key } };
+        } catch (err) {
+          log.error('storage_delete error:', err.message);
+          return { success: false, error: err.message };
         }
-
-        return { success: true, data: { deleted: existed, key: args.key } }
       }
-    })
+    });
 
     framework.registerTool({
       name: 'storage_list',
@@ -127,139 +171,154 @@ class StoragePlugin extends Plugin {
         namespace: z.string().optional().describe('命名空间，默认全局')
       }),
       execute: async (args) => {
-        const ns = args.namespace || this.config.namespace
-        const prefix = `${ns}:`
-        const keys = []
-
-        for (const key of this._store.keys()) {
-          if (key.startsWith(prefix)) {
-            keys.push(key.substring(prefix.length))
-          }
-        }
-
-        return {
-          success: true,
-          data: keys,
-          metadata: { namespace: ns, count: keys.length }
+        try {
+          this._initStorage();
+          const ns = args.namespace ? `${args.namespace}:` : '';
+          const keys = this._storageManager.list(ns);
+
+          return {
+            success: true,
+            data: keys.map(k => k.substring(ns.length)),
+            metadata: {
+              namespace: args.namespace || this.config.namespace,
+              count: keys.length
+            }
+          };
+        } catch (err) {
+          log.error('storage_list error:', err.message);
+          return { success: false, error: err.message };
         }
       }
-    })
+    });
 
     framework.registerTool({
       name: 'storage_clear',
-      description: '清空命名空间下的所有数据',
+      description: '清空命名空间下的所有数据（立即物理删除）',
       inputSchema: z.object({
         namespace: z.string().optional().describe('命名空间，默认全局')
       }),
       execute: async (args) => {
-        const ns = args.namespace || this.config.namespace
-        const prefix = `${ns}:`
-        let count = 0
-
-        for (const key of this._store.keys()) {
-          if (key.startsWith(prefix)) {
-            this._store.delete(key)
-            count++
+        try {
+          this._initStorage();
+          const ns = args.namespace ? `${args.namespace}:` : '';
+          const keys = this._storageManager.list(ns);
+          let count = 0;
+
+          for (const key of keys) {
+            if (this._storageManager.delete(key)) {
+              count++;
+            }
           }
-        }
 
-        if (this.config.type === 'json') {
-          await this._persistToFile()
+          return { success: true, data: { namespace: args.namespace || this.config.namespace, cleared: count } };
+        } catch (err) {
+          log.error('storage_clear error:', err.message);
+          return { success: false, error: err.message };
         }
-
-        return { success: true, data: { namespace: ns, cleared: count } }
       }
-    })
-
-    return this
-  }
-
-  /**
-   * 初始化 JSON 文件存储
-   */
-  _initJsonStore() {
-    this._filePath = path.resolve(process.cwd(), this.config.path, `${this.config.namespace}.json`)
-
-    // 确保目录存在
-    const dir = path.dirname(this._filePath)
-    if (!fs.existsSync(dir)) {
-      fs.mkdirSync(dir, { recursive: true })
-    }
-
-    // 加载已有数据
-    if (fs.existsSync(this._filePath)) {
-      try {
-        const content = fs.readFileSync(this._filePath, 'utf-8')
-        const data = JSON.parse(content)
+    });
 
-        for (const [key, entry] of Object.entries(data)) {
-          this._store.set(key, entry)
+    framework.registerTool({
+      name: 'storage_watch',
+      description: '监听键值变化（返回当前值）',
+      inputSchema: z.object({
+        key: z.string().describe('存储键名'),
+        namespace: z.string().optional().describe('命名空间')
+      }),
+      execute: async (args) => {
+        try {
+          this._initStorage();
+          const ns = args.namespace ? `${args.namespace}:` : '';
+          const fullKey = `${ns}${args.key}`;
+          const value = this._storageManager.watch(fullKey);
+
+          return {
+            success: true,
+            data: { key: args.key, value },
+            metadata: { watched: true }
+          };
+        } catch (err) {
+          log.error('storage_watch error:', err.message);
+          return { success: false, error: err.message };
         }
-
-        log.info(` Loaded ${this._store.size} entries from ${this._filePath}`)
-      } catch (err) {
-        log.warn(` Failed to load storage file: ${err.message}`)
       }
-    }
-  }
+    });
 
-  /**
-   * 持久化到文件
-   */
-  async _persistToFile() {
-    if (!this._filePath) return
-
-    try {
-      const data = Object.fromEntries(this._store)
-      fs.writeFileSync(this._filePath, JSON.stringify(data, null, 2), 'utf-8')
-    } catch (err) {
-      log.error(` Failed to persist: ${err.message}`)
-    }
-  }
-
-  /**
-   * 获取存储实例（供其他插件使用）
-   */
-  getStore() {
-    return this._store
-  }
+    /**
+     * 新增: 手动触发 compaction
+     * 当 tombstone 数量达到阈值时，compaction 会自动在后台执行
+     * 此工具可手动触发 compaction 立即清理
+     */
+    framework.registerTool({
+      name: 'storage_compact',
+      description: '手动触发 compaction，清理已删除的墓碑记录并重写文件',
+      inputSchema: z.object({
+        namespace: z.string().optional().describe('命名空间，默认全局')
+      }),
+      execute: async (args) => {
+        try {
+          this._initStorage();
+
+          const result = await this._storageManager.compact();
+
+          return {
+            success: true,
+            data: {
+              namespace: args.namespace || this.config.namespace,
+              compacted: result.compacted,
+              status: result.status
+            }
+          };
+        } catch (err) {
+          log.error('storage_compact error:', err.message);
+          return { success: false, error: err.message };
+        }
+      }
+    });
 
-  /**
-   * 直接设置值并自动持久化（供其他插件使用）
-   * @param {string} key - 键
-   * @param {any} value - 值
-   */
-  setDirect(key, value) {
-    this._store.set(key, value)
-    if (this.config.type === 'json') {
-      this._persistToFile()
-    }
-  }
+    /**
+     * 新增: 获取存储统计信息
+     */
+    framework.registerTool({
+      name: 'storage_stats',
+      description: '获取存储统计信息，包括条目数、墓碑数量、compaction 配置等',
+      inputSchema: z.object({
+        namespace: z.string().optional().describe('命名空间，默认全局')
+      }),
+      execute: async (args) => {
+        try {
+          this._initStorage();
+          const stats = this._storageManager.getCompactionStats();
+
+          return {
+            success: true,
+            data: {
+              namespace: args.namespace || this.config.namespace,
+              ...stats
+            }
+          };
+        } catch (err) {
+          log.error('storage_stats error:', err.message);
+          return { success: false, error: err.message };
+        }
+      }
+    });
 
-  /**
-   * 删除键并自动持久化（供其他插件使用）
-   * @param {string} key - 键
-   */
-  deleteDirect(key) {
-    this._store.delete(key)
-    if (this.config.type === 'json') {
-      this._persistToFile()
-    }
+    return this;
   }
 
   reload(framework) {
-    this._framework = framework
-    this._store.clear()
-
-    if (this.config.type === 'json') {
-      this._initJsonStore()
-    }
+    this._framework = framework;
+    this._initStorage();
   }
 
   uninstall(framework) {
-    this._store.clear()
-    this._framework = null
+    if (this._storageManager) {
+      this._storageManager.clear();
+      this._storageManager = null;
+    }
+    this._framework = null;
   }
 }
 
-module.exports = StoragePlugin
+module.exports = { StoragePlugin };

package/plugins/subagent-plugin.js

@@ -499,7 +499,7 @@ class SubAgentManagerPlugin extends Plugin {
 
     agent.registerTool({
       name: 'subagent_reload',
-      description: '重新加载子Agent配置（当新增或删除.agent/agents下的文件后使用）',
+      description: '重新加载子Agent配置（当新增或删除.foliko/agents下的文件后使用）',
       inputSchema: z.object({}),
       execute: async () => {
         try {
@@ -567,7 +567,7 @@ class SubAgentManagerPlugin extends Plugin {
 
     framework.registerTool({
       name: 'subagent_reload',
-      description: '重新加载子Agent配置（当新增或删除.agent/agents下的文件后使用）',
+      description: '重新加载子Agent配置（当新增或删除.foliko/agents下的文件后使用）',
       inputSchema: z.object({}),
       execute: async () => {
         try {
@@ -586,8 +586,8 @@ class SubAgentManagerPlugin extends Plugin {
    * 从 agentsDir 目录加载子Agent配置
    */
   _loadAgentsFromDir() {
-    // 默认使用 .agent/agents 目录
-    const agentsDir = this.config.agentsDir || path.join(process.cwd(), '.agent', 'agents')
+    // 默认使用 .foliko/agents 目录
+    const agentsDir = this.config.agentsDir || path.join(process.cwd(), '.foliko', 'agents')
     //log.info(' _loadAgentsFromDir called, agentsDir:', agentsDir)
     if (!fs.existsSync(agentsDir)) {
       log.info(' agentsDir not found or does not exist')