foliko 1.1.92 → 2.0.0

package/plugins/{python-plugin-loader.js → core/python-loader/index.js}

@@ -5,52 +5,12 @@
 
 const fs = require('fs')
 const path = require('path')
-const { Plugin } = require('../src/core/plugin-base')
-const { logger } = require('../src/utils/logger')
+const { Plugin } = require('../../../src/plugin/base')
+const { logger } = require('../../../src/common/logger')
 const log = logger.child('PythonPluginLoader')
 const { z } = require('zod')
 const { zodSchemaToMarkdown } = require('@chnak/zod-to-markdown')
-
-// 将 JSON Schema 转换为 Zod Schema
-function jsonSchemaToZod(jsonSchema) {
-  if (!jsonSchema || jsonSchema.type !== 'object') {
-    return z.object({})
-  }
-
-  const properties = jsonSchema.properties || {}
-  const required = jsonSchema.required || []
-
-  const shape = {}
-  for (const [key, prop] of Object.entries(properties)) {
-    let zodType
-    switch (prop.type) {
-      case 'string':
-        zodType = z.string()
-        break
-      case 'number':
-        zodType = z.number()
-        break
-      case 'boolean':
-        zodType = z.boolean()
-        break
-      case 'array':
-        zodType = z.array(z.any())
-        break
-      case 'object':
-        zodType = jsonSchemaToZod(prop)
-        break
-      default:
-        zodType = z.any()
-    }
-    // 如果不是 required 字段，则标记为 optional
-    if (!required.includes(key)) {
-      zodType = zodType.optional()
-    }
-    shape[key] = zodType
-  }
-
-  return z.object(shape)
-}
+const { jsonSchemaToZod } = require('../../../src/tool/schema')
 
 class PythonPluginLoader extends Plugin {
   constructor(config = {}) {
@@ -62,7 +22,7 @@ class PythonPluginLoader extends Plugin {
     this._agentDir = config.agentDir || '.foliko' // 默认从 .foliko 目录加载 Python 插件
     this._pythonPlugins = new Map()
     this._framework = null
-    this.system = true 
+    this.system = true
   }
 
   install(framework) {
@@ -80,20 +40,6 @@ class PythonPluginLoader extends Plugin {
     // 加载所有 Python 插件（会注册工具到 ExtensionExecutor）
     this._loadPythonPlugins()
 
-    // 监听 agent 创建事件，附加 Python 插件信息到系统提示词
-    // framework.on('agent:created', (agent) => {
-    //   this._refreshAgentPythonPluginsPrompt(agent)
-    // })
-
-    // 等待框架就绪后，刷新所有已有 agent 的 Python 插件提示词
-    // if (framework._ready) {
-    //   this._refreshAllAgentsPythonPluginsPrompt(framework)
-    // } else {
-    //   framework.once('framework:ready', () => {
-    //     this._refreshAllAgentsPythonPluginsPrompt(framework)
-    //   })
-    // }
-
     return this
   }
 
@@ -121,7 +67,7 @@ class PythonPluginLoader extends Plugin {
           if (Object.keys(params).length > 0) {
             try {
               const jsonSchema = this._paramsToJsonSchema(params)
-              const zodSchema = this._jsonSchemaToZod(jsonSchema)
+              const zodSchema = jsonSchemaToZod(jsonSchema)
               const schemaMd = zodSchemaToMarkdown(zodSchema)
               if (schemaMd) {
                 desc += `**参数:**\n\n${schemaMd}\n`
@@ -173,133 +119,7 @@ class PythonPluginLoader extends Plugin {
    * 将 JSON Schema 转换为 Zod schema
    */
   _jsonSchemaToZod(jsonSchema) {
-    if (!jsonSchema || !jsonSchema.properties) {
-      return z.object({})
-    }
-
-    try {
-      const shape = {}
-      const properties = jsonSchema.properties
-      const required = jsonSchema.required || []
-
-      for (const [key, prop] of Object.entries(properties)) {
-        shape[key] = this._jsonSchemaPropToZod(prop, required.includes(key))
-      }
-
-      return z.object(shape)
-    } catch (e) {
-      return z.object({})
-    }
-  }
-
-  /**
-   * 将 JSON Schema 属性转换为 Zod 类型（支持完整嵌套）
-   */
-  _jsonSchemaPropToZod(prop, isRequired) {
-    // 1. 处理 enum（枚举值）
-    if (prop.enum) {
-      let zodType = z.string().enum(prop.enum)
-      return isRequired ? zodType : zodType.optional()
-    }
-
-    const type = prop.type || 'string'
-
-    // 2. 简单类型
-    switch (type) {
-      case 'string':
-        return isRequired ? z.string() : z.string().optional()
-      case 'number':
-      case 'integer':
-        return isRequired ? z.number() : z.number().optional()
-      case 'boolean':
-        return isRequired ? z.boolean() : z.boolean().optional()
-      default:
-        break
-    }
-
-    // 3. 数组类型
-    if (type === 'array') {
-      let itemsZod = z.any()
-      if (prop.items) {
-        // 支持 oneOf（联合类型数组）
-        if (prop.items.oneOf) {
-          const unionTypes = prop.items.oneOf.map(item => this._jsonSchemaPropToZod(item, true))
-          if (unionTypes.length > 0) {
-            itemsZod = z.union(unionTypes)
-          }
-        } else {
-          itemsZod = this._jsonSchemaPropToZod(prop.items, true)
-        }
-      }
-      return isRequired ? z.array(itemsZod) : z.array(itemsZod).optional()
-    }
-
-    // 4. 对象类型
-    if (type === 'object') {
-      if (prop.properties && Object.keys(prop.properties).length > 0) {
-        const nested = {}
-        for (const [k, v] of Object.entries(prop.properties)) {
-          nested[k] = this._jsonSchemaPropToZod(v, prop.required?.includes(k) || false)
-        }
-        const objZod = z.object(nested)
-        return isRequired ? objZod : objZod.optional()
-      }
-      // 无 properties 的 object，视为 record
-      const recordZod = z.record(z.any())
-      return isRequired ? recordZod : recordZod.optional()
-    }
-
-    // 5. oneOf（联合类型）
-    if (prop.oneOf) {
-      const unionTypes = prop.oneOf.map(item => this._jsonSchemaPropToZod(item, true))
-      if (unionTypes.length > 0) {
-        const unionZod = z.union(unionTypes)
-        return isRequired ? unionZod : unionZod.optional()
-      }
-    }
-
-    // 6. Fallback
-    return isRequired ? z.any() : z.any().optional()
-  }
-
-  /**
-   * 刷新单个 agent 的 Python 插件提示词
-   */
-  _refreshAgentPythonPluginsPrompt(agent) {
-    const existingPrompt = agent._originalPrompt || ''
-    if (existingPrompt.includes('【Python 插件】')) {
-      return
-    }
-
-    const pyDesc = this._buildPythonPluginsDescription()
-    if (!pyDesc) return
-
-    // 将 Python 插件描述追加到系统提示词
-    //agent.setSystemPrompt(existingPrompt + '\n\n' + pyDesc)
-  }
-
-  /**
-   * 刷新所有 agent 的 Python 插件提示词
-   */
-  _refreshAllAgentsPythonPluginsPrompt(framework) {
-    const visited = new Set()
-
-    const traverse = (agent) => {
-      if (!agent || visited.has(agent)) return
-      visited.add(agent)
-      this._refreshAgentPythonPluginsPrompt(agent)
-
-      // 递归处理子 agent
-      const subAgents = agent.getSubAgents?.() || agent._subAgents || new Map()
-      for (const [name, subAgentInfo] of subAgents) {
-        traverse(subAgentInfo.agent)
-      }
-    }
-
-    const agents = framework._agents || []
-    for (const agent of agents) {
-      traverse(agent)
-    }
+    return jsonSchemaToZod(jsonSchema)
   }
 
   /**
@@ -496,7 +316,7 @@ class PythonPluginLoader extends Plugin {
       const inner = normalized.slice(1, -1)
       const properties = {}
       const required = []
-      
+
       const parts = this._splitByComma(inner)
       for (const part of parts) {
         const colonIdx = part.indexOf(':')

package/plugins/{rules-plugin.js → core/rules/index.js}

@@ -3,26 +3,21 @@
  * 控制工具调用权限、内容过滤、触发动作
  */
 
-const { Plugin } = require('../src/core/plugin-base')
-const { logger } = require('../src/utils/logger')
+const { Plugin } = require('../../../src/plugin/base')
+const { logger } = require('../../../src/common/logger')
 const log = logger.child('RulesPlugin')
 const { z } = require('zod')
 const fs = require('fs')
 const path = require('path')
+const os = require('os')
 
-/**
- * 内置规则类型
- */
 const RuleType = {
-  ALLOW: 'allow',      // 允许
-  DENY: 'deny',        // 拒绝
-  TRANSFORM: 'transform',  // 转换
-  RATE_LIMIT: 'rate_limit' // 限流
+  ALLOW: 'allow',
+  DENY: 'deny',
+  TRANSFORM: 'transform',
+  RATE_LIMIT: 'rate_limit'
 }
 
-/**
- * 规则评估结果
- */
 class RuleResult {
   constructor(allowed, rule = null, transform = null) {
     this.allowed = allowed
@@ -38,13 +33,14 @@ class RulesPlugin extends Plugin {
     this.version = '1.0.0'
     this.description = '规则引擎插件，用于控制工具调用权限、内容过滤、触发动作'
     this.priority = 25
-    this.system = true 
-    
+    this.system = true
+
     this.config = {
       rulesDir: config.rulesDir || '.foliko/rules',
       autoLoad: config.autoLoad !== false
     }
 
+    this._homeRulesDir = path.join(os.homedir(), '.foliko', 'rules')
     this._framework = null
     this._rules = []
     this._ruleStats = {
@@ -61,12 +57,11 @@ class RulesPlugin extends Plugin {
   }
 
   start(framework) {
-    // 自动加载规则文件
-    if (this.config.autoLoad && this.config.rulesDir) {
+    if (this.config.autoLoad && this.config.rulesDir && !this._loaded) {
+      this._loaded = true;
       this.loadFromDirectory(this.config.rulesDir)
     }
 
-    // 注册规则管理工具
     framework.registerTool({
       name: 'rules_list',
       description: '列出所有规则',
@@ -164,63 +159,131 @@ class RulesPlugin extends Plugin {
     return this
   }
 
-  /**
-   * 从目录加载规则文件
-   */
   loadFromDirectory(rulesDir) {
-    const resolvedDir = path.resolve(this._framework?.getCwd?.() ?? process.cwd(), rulesDir)
-
-    if (!fs.existsSync(resolvedDir)) {
-      //log.info(` Rules directory not found: ${resolvedDir}`)
-      return
+    const cwd = this._framework?.getCwd?.() ?? process.cwd()
+    const dirs = [
+      this._homeRulesDir,                                  // ~/.foliko/rules（优先）
+      path.resolve(cwd, rulesDir || this.config.rulesDir),  // 项目级
+    ]
+
+    for (const resolvedDir of dirs) {
+      if (!fs.existsSync(resolvedDir)) continue
+
+      try {
+        const files = fs.readdirSync(resolvedDir).filter(f => f.endsWith('.json') || f.endsWith('.md'))
+
+        for (const file of files) {
+          const filePath = path.join(resolvedDir, file)
+          const content = fs.readFileSync(filePath, 'utf-8')
+
+          if (file.endsWith('.json')) {
+            const rules = JSON.parse(content)
+            for (const rule of rules) {
+              if (rule.pattern) rule.pattern = new RegExp(rule.pattern)
+              rule.enabled = rule.enabled !== false
+              this._rules.push(rule)
+            }
+          } else if (file.endsWith('.md')) {
+            // 解析 YAML frontmatter
+            const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+            if (!match) continue;
+            const fm = this._parseFrontmatter(match[1]);
+            const rule = {
+              name: fm.name || fm.id || path.basename(file, '.md'),
+              type: fm.type || 'deny',
+              target: fm.target || (fm.trigger?.conditions?.[0]?.tool_name) || '*',
+              pattern: fm.condition ? new RegExp(fm.condition) : null,
+              description: fm.description || '',
+              action: fm.action || {},
+              enabled: fm.enabled !== false,
+            };
+            this._rules.push(rule);
+          }
+        }
+      } catch (err) {
+        log.error(` Failed to load rules from ${resolvedDir}: ${err.message}`)
+      }
     }
+  }
 
-    try {
-      const files = fs.readdirSync(resolvedDir).filter(f => f.endsWith('.json'))
+  _parseFrontmatter(yaml) {
+    const result = {};
+    const lines = yaml.split('\n');
+    let currentKey = null;
+    let currentIndent = 0;
+    const stack = [];
 
-      for (const file of files) {
-        const filePath = path.join(resolvedDir, file)
-        const content = fs.readFileSync(filePath, 'utf-8')
-        const rules = JSON.parse(content)
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith('#')) continue;
 
-        for (const rule of rules) {
-          if (rule.pattern) {
-            rule.pattern = new RegExp(rule.pattern)
-          }
-          rule.enabled = rule.enabled !== false
-          this._rules.push(rule)
+      const indent = line.length - line.trimStart().length;
+      const colonIndex = trimmed.indexOf(':');
+
+      if (colonIndex > 0 && !trimmed.startsWith('-')) {
+        const key = trimmed.substring(0, colonIndex).trim();
+        let value = trimmed.substring(colonIndex + 1).trim();
+
+        // 处理数组项后面的属性 (conditions 列表项)
+        if (trimmed.startsWith('- ') && colonIndex > 1) {
+          continue;
+        }
+
+        if (value === '' || value.startsWith('#')) {
+          currentKey = key;
+          currentIndent = indent;
+          if (!result[key]) result[key] = Array.isArray(result[key]) ? result[key] : {};
+          stack.push({ key, indent });
+          continue;
         }
 
-        //log.info(` Loaded ${rules.length} rules from ${file}`)
+        value = value.replace(/^["']|["']$/g, '');
+        if (value === 'true') value = true;
+        else if (value === 'false') value = false;
+
+        if (currentKey && indent > currentIndent) {
+          const parent = result[currentKey];
+          if (typeof parent === 'object' && !Array.isArray(parent)) {
+            parent[key] = value;
+          }
+        } else {
+          result[key] = value;
+          currentKey = null;
+        }
+      } else if (trimmed.startsWith('- ')) {
+        const item = trimmed.substring(2).trim();
+        if (currentKey) {
+          if (!Array.isArray(result[currentKey])) result[currentKey] = [];
+          const subColon = item.indexOf(':');
+          if (subColon > 0) {
+            const subKey = item.substring(0, subColon).trim();
+            let subVal = item.substring(subColon + 1).trim().replace(/^["']|["']$/g, '');
+            const obj = {};
+            obj[subKey] = subVal;
+            result[currentKey].push(obj);
+          } else {
+            result[currentKey].push(item);
+          }
+        }
       }
-    } catch (err) {
-      log.error(` Failed to load rules: ${err.message}`)
     }
+
+    return result;
   }
 
-  /**
-   * 评估目标是否符合规则
-   * @param {string} target - 目标 (工具名, *, @event-type)
-   * @param {Object} input - 输入参数
-   * @returns {RuleResult}
-   */
   evaluate(target, input = {}) {
     this._ruleStats.total++
 
-    // 按优先级排序规则 (先加载的在前)
     for (const rule of this._rules) {
       if (!rule.enabled) continue
 
-      // 匹配目标
       if (rule.target !== '*' && rule.target !== target) continue
 
-      // 匹配模式 (如果有)
       if (rule.pattern) {
         const targetStr = typeof input === 'string' ? input : JSON.stringify(input)
         if (!rule.pattern.test(targetStr)) continue
       }
 
-      // 评估规则
       if (rule.type === RuleType.DENY) {
         this._ruleStats.denied++
         return new RuleResult(false, rule)
@@ -237,35 +300,22 @@ class RulesPlugin extends Plugin {
       }
     }
 
-    // 没有匹配规则，默认允许
     this._ruleStats.allowed++
     return new RuleResult(true)
   }
 
-  /**
-   * 检查工具调用是否允许
-   */
   checkToolCall(toolName, args) {
     return this.evaluate(toolName, args)
   }
 
-  /**
-   * 检查消息是否允许
-   */
   checkMessage(message, context) {
     return this.evaluate('@message', { message, context })
   }
 
-  /**
-   * 添加规则
-   */
   addRule(rule) {
     this._rules.push(rule)
   }
 
-  /**
-   * 移除规则
-   */
   removeRule(name) {
     const index = this._rules.findIndex(r => r.name === name)
     if (index !== -1) {
@@ -279,12 +329,19 @@ class RulesPlugin extends Plugin {
     this._framework = framework
     this._rules = []
     this._ruleStats = { total: 0, allowed: 0, denied: 0, transformed: 0 }
+    this._loaded = false;
 
     if (this.config.autoLoad && this.config.rulesDir) {
       this.loadFromDirectory(this.config.rulesDir)
     }
   }
 
+  async onCwdChanged(oldCwd, newCwd, framework) {
+    this._rules = []
+    this._ruleStats = { total: 0, allowed: 0, denied: 0, transformed: 0 }
+    this._loaded = false
+  }
+
   uninstall(framework) {
     this._rules = []
     this._ruleStats = { total: 0, allowed: 0, denied: 0, transformed: 0 }
@@ -292,4 +349,4 @@ class RulesPlugin extends Plugin {
   }
 }
 
-module.exports = RulesPlugin
+module.exports = RulesPlugin