foliko 1.0.87 → 1.1.0

package/.agent/plugins/temp-repo/puppeteer-plugin/package.json

@@ -1,9 +0,0 @@
-{
-  "name": "puppeteer-plugin",
-  "version": "1.0.0",
-  "description": "Puppeteer 网页自动化操作插件，支持 Session 保存、页面截图、元素交互等",
-  "main": "index.js",
-  "dependencies": {
-    "puppeteer-core": "^24.40.0"
-  }
-}

package/.agent/plugins/test_plugin.py

@@ -1,304 +0,0 @@
-# .agent/plugins/test_plugin.py
-"""
-Python 测试插件 - 提供单元测试和覆盖率测试功能
-"""
-
-PLUGIN = {
-    "name": "test_plugin",
-    "version": "1.0.0",
-    "description": "Python 单元测试和覆盖率测试插件"
-}
-
-TOOLS = [
-    {
-        "name": "run_tests",
-        "description": "运行 Python 测试文件或目录中的测试用例",
-        "params": {
-            "path": "string",
-            "verbose": "boolean",
-            "pattern": "string"
-        }
-    },
-    {
-        "name": "create_test",
-        "description": "创建单元测试文件模板",
-        "params": {
-            "path": "string",
-            "class_name": "string",
-            "test_methods": "array",
-            "module_name": "string"
-        }
-    },
-    {
-        "name": "run_coverage",
-        "description": "运行测试并生成覆盖率报告",
-        "params": {
-            "path": "string",
-            "source": "string",
-            "report_type": "string"
-        }
-    },
-    {
-        "name": "assert_equal",
-        "description": "断言两个值相等（测试辅助）",
-        "params": {
-            "actual": "any",
-            "expected": "any",
-            "message": "string"
-        }
-    },
-    {
-        "name": "mock_function",
-        "description": "创建模拟函数用于测试",
-        "params": {
-            "return_value": "any",
-            "side_effect": "array",
-            "called_count": "number"
-        }
-    }
-]
-
-# === 工具实现 ===
-
-import os
-import json
-import subprocess
-import traceback
-from datetime import datetime
-
-
-def run_tests(params):
-    """运行 Python 测试文件或目录中的测试用例"""
-    path = params.get("path", ".")
-    verbose = params.get("verbose", True)
-    pattern = params.get("pattern", "test_*.py")
-
-    if not os.path.exists(path):
-        return {"success": False, "error": f"Path not found: {path}"}
-
-    # 构建 pytest 命令
-    cmd = ["pytest", path]
-    if verbose:
-        cmd.append("-v")
-
-    try:
-        result = subprocess.run(
-            cmd,
-            capture_output=True,
-            text=True,
-            timeout=60
-        )
-
-        output = result.stdout + result.stderr
-
-        return {
-            "success": result.returncode == 0,
-            "result": {
-                "passed": result.returncode == 0,
-                "output": output,
-                "return_code": result.returncode
-            }
-        }
-    except subprocess.TimeoutExpired:
-        return {"success": False, "error": "Test execution timed out"}
-    except Exception as e:
-        return {"success": False, "error": str(e)}
-
-
-def create_test(params):
-    """创建单元测试文件模板"""
-    path = params.get("path")
-    class_name = params.get("class_name", "TestModule")
-    test_methods = params.get("test_methods", ["test_case"])
-    module_name = params.get("module_name", "")
-
-    if not path:
-        return {"success": False, "error": "path is required"}
-
-    # 确保目录存在
-    os.makedirs(os.path.dirname(path) if os.path.dirname(path) else ".", exist_ok=True)
-
-    # 生成测试模板
-    template = f'''"""
-测试模块 - {datetime.now().strftime("%Y-%m-%d %H:%M:%S")}
-"""
-
-import unittest
-{"import " + module_name if module_name else ""}
-
-
-class {class_name}(unittest.TestCase):
-    """{class_name} 测试类"""
-'''
-
-    for method in test_methods:
-        template += f'''
-    def {method}(self):
-        """测试用例: {method}"""
-        # TODO: 实现测试逻辑
-        self.assertTrue(True)
-'''
-
-    template += '''
-
-if __name__ == "__main__":
-    unittest.main()
-'''
-
-    try:
-        with open(path, "w", encoding="utf-8") as f:
-            f.write(template)
-
-        return {
-            "success": True,
-            "result": {
-                "path": path,
-                "class_name": class_name,
-                "methods": test_methods
-            }
-        }
-    except Exception as e:
-        return {"success": False, "error": str(e)}
-
-
-def run_coverage(params):
-    """运行测试并生成覆盖率报告"""
-    path = params.get("path", ".")
-    source = params.get("source", "")
-    report_type = params.get("report_type", "term")
-
-    if not os.path.exists(path):
-        return {"success": False, "error": f"Path not found: {path}"}
-
-    # 构建 coverage 命令
-    cmd = ["coverage", "run", "-m", "pytest", path]
-    if source:
-        cmd = ["coverage", "run", "--source", source, "-m", "pytest", path]
-
-    try:
-        # 运行测试
-        subprocess.run(cmd, capture_output=True, timeout=60)
-
-        # 生成报告
-        if report_type == "term":
-            report_result = subprocess.run(
-                ["coverage", "report"],
-                capture_output=True,
-                text=True
-            )
-            output = report_result.stdout
-        elif report_type == "html":
-            subprocess.run(
-                ["coverage", "html", "-d", "htmlcov"],
-                capture_output=True,
-                timeout=30
-            )
-            output = "Coverage HTML report generated at htmlcov/"
-        elif report_type == "json":
-            report_result = subprocess.run(
-                ["coverage", "json"],
-                capture_output=True,
-                text=True
-            )
-            output = report_result.stdout
-        else:
-            output = "Unknown report type"
-
-        return {
-            "success": True,
-            "result": {
-                "report": output,
-                "type": report_type
-            }
-        }
-    except subprocess.TimeoutExpired:
-        return {"success": False, "error": "Coverage execution timed out"}
-    except FileNotFoundError:
-        return {"success": False, "error": "coverage module not installed. Run: pip install coverage"}
-    except Exception as e:
-        return {"success": False, "error": str(e)}
-
-
-def assert_equal(params):
-    """断言两个值相等（测试辅助）"""
-    actual = params.get("actual")
-    expected = params.get("expected")
-    message = params.get("message", "")
-
-    try:
-        # 处理 JSON 字符串比较
-        if isinstance(actual, str):
-            try:
-                actual = json.loads(actual)
-            except (json.JSONDecodeError, TypeError):
-                pass
-
-        if isinstance(expected, str):
-            try:
-                expected = json.loads(expected)
-            except (json.JSONDecodeError, TypeError):
-                pass
-
-        if actual == expected:
-            return {
-                "success": True,
-                "result": {
-                    "passed": True,
-                    "message": f"Assertion passed: {actual} == {expected}",
-                    "actual": actual,
-                    "expected": expected
-                }
-            }
-        else:
-            return {
-                "success": True,
-                "result": {
-                    "passed": False,
-                    "message": f"Assertion failed: {actual} != {expected}",
-                    "actual": actual,
-                    "expected": expected
-                }
-            }
-    except Exception as e:
-        return {"success": False, "error": str(e)}
-
-
-def mock_function(params):
-    """创建模拟函数用于测试"""
-    return_value = params.get("return_value")
-    side_effect = params.get("side_effect", [])
-    called_count = params.get("called_count", 0)
-
-    class MockResult:
-        def __init__(self):
-            self.call_count = 0
-            self.call_args = []
-            self.side_effects = side_effect
-
-        def __call__(self, *args, **kwargs):
-            self.call_count += 1
-            self.call_args.append({"args": args, "kwargs": kwargs})
-
-            # 如果有 side_effect，按顺序返回
-            if self.side_effects:
-                index = min(self.call_count - 1, len(self.side_effects) - 1)
-                return self.side_effects[index]
-
-            return return_value
-
-        def reset(self):
-            self.call_count = 0
-            self.call_args = []
-
-    mock = MockResult()
-    mock.call_count = called_count
-
-    return {
-        "success": True,
-        "result": {
-            "mock_type": "MockFunction",
-            "return_value": return_value,
-            "side_effects": side_effect,
-            "description": "Use this mock function in your tests"
-        }
-    }

package/examples/test-chat-debug.js

@@ -1,102 +0,0 @@
-/**
- * chat() 持续聊天调试测试
- * 专门测试 chat 方法为什么不返回数据
- */
-
-const { Framework } = require('../src');
-const AIPlugin = require('../plugins/ai-plugin');
-require('dotenv').config();
-
-async function main() {
-  console.log('=== chat() 持续聊天调试测试 ===\n');
-
-  // 创建框架
-  const framework = new Framework({ debug: true });
-
-  // 使用 MiniMax (Agent SDK)
-  await framework.loadPlugin(
-    new AIPlugin({
-      provider: 'minimax',
-      model: 'MiniMax-M2.7',
-      apiKey: process.env.MINIMAX_API_KEY || 'your-api-key',
-    })
-  );
-
-  // 注册一个简单的测试工具
-  const { z } = require('zod');
-  framework.registerTool({
-    name: 'test_tool',
-    description: '测试工具，返回传入的参数',
-    inputSchema: z.object({
-      msg: z.string().describe('要返回的消息'),
-    }),
-    execute: async (args) => {
-      console.log('[DEBUG] test_tool called with:', args);
-      return `工具收到: ${args.msg}`;
-    },
-  });
-
-  console.log('[Framework] Ready!');
-  console.log('[Tools]', framework.getTools().map((t) => t.name));
-
-  // 创建 Agent
-  const agent = framework.createAgent({
-    name: 'DebugAgent',
-    systemPrompt: '你是一个有帮助的助手。如果用户要求使用工具，请使用工具。',
-  });
-
-  // 监听所有事件
-  agent.on('tool-call', (tool) => {
-    console.log('[Event] tool-call:', tool.name, tool.args);
-  });
-
-  agent.on('tool-result', (result) => {
-    console.log('[Event] tool-result:', result.name, '->', JSON.stringify(result.result).substring(0, 200));
-  });
-
-  agent.on('error', (err) => {
-    console.error('[Event] error:', err.error);
-  });
-
-  // 测试函数
-  const testChat = async (question, round) => {
-    console.log(`\n========== Round ${round} ==========`);
-    console.log(`[User] ${question}`);
-
-    try {
-      // 打印 result 的完整结构
-      const result = await agent.chat(question);
-      console.log(`\n[DEBUG] result keys:`, Object.keys(result));
-      console.log(`[DEBUG] result:`, JSON.stringify(result, null, 2).substring(0, 500));
-
-      if (result.message) {
-        console.log(`\n[Agent] ${result.message}`);
-      } else {
-        console.log(`\n[WARNING] result.message is empty!`);
-      }
-
-      // 打印当前消息历史长度
-      const chatHandler = agent._chatHandler;
-      if (chatHandler) {
-        console.log(`[DEBUG] _messages.length:`, chatHandler._messages.length);
-        console.log(`[DEBUG] compression count:`, chatHandler._compressionCount);
-      }
-    } catch (err) {
-      console.error(`\n[Error]`, err.message);
-      console.error(err.stack);
-    }
-  };
-
-  // 执行多轮测试
-  await testChat('你好，介绍一下你自己', 1);
-  await testChat('请用 test_tool 工具返回 "hello world"', 2);
-  await testChat('今天天气不错，你觉得呢？', 3);
-  await testChat('帮我计算 123 + 456 等于多少', 4);
-  await testChat('再说一次你的名字', 5);
-
-  console.log('\n========== 测试完成 ==========');
-
-  await framework.destroy();
-}
-
-main().catch(console.error);

package/examples/test-chat-result.js

@@ -1,76 +0,0 @@
-/**
- * 测试 chat() 返回值的完整结构
- */
-
-const { Framework } = require('../src');
-const AIPlugin = require('../plugins/ai-plugin');
-require('dotenv').config();
-
-async function main() {
-  console.log('=== 测试 chat() 返回值结构 ===\n');
-
-  const framework = new Framework({ debug: true });
-
-  await framework.loadPlugin(
-    new AIPlugin({
-      provider: 'minimax',
-      model: 'MiniMax-M2.7',
-      apiKey: process.env.MINIMAX_API_KEY || 'your-api-key',
-    })
-  );
-
-  const { z } = require('zod');
-  framework.registerTool({
-    name: 'echo',
-    description: '返回输入的内容',
-    inputSchema: z.object({
-      msg: z.string().describe('要返回的消息'),
-    }),
-    execute: async (args) => {
-      return `工具收到: ${args.msg}`;
-    },
-  });
-
-  console.log('[Framework] Ready!');
-
-  const agent = framework.createAgent({
-    name: 'TestAgent',
-    systemPrompt: '你是一个有帮助的助手。',
-  });
-
-  // 测试 1：简单对话
-  console.log('\n--- 测试 1：简单对话 ---');
-  try {
-    const result = await agent.chat('你好');
-    console.log('[DEBUG] result:', JSON.stringify(result, null, 2));
-    console.log('[DEBUG] result 顶层 keys:', Object.keys(result));
-  } catch (err) {
-    console.error('[Error]', err.message);
-  }
-
-  // 测试 2：触发工具调用
-  console.log('\n--- 测试 2：触发工具调用 ---');
-  try {
-    const result = await agent.chat('请用 echo 工具返回 "hello"');
-    console.log('[DEBUG] result:', JSON.stringify(result, null, 2));
-    console.log('[DEBUG] result 顶层 keys:', Object.keys(result));
-  } catch (err) {
-    console.error('[Error]', err.message);
-  }
-
-  // 测试 3：多次对话（累积上下文）
-  console.log('\n--- 测试 3：多次对话 ---');
-  try {
-    await agent.chat('你好');
-    await agent.chat('今天天气不错');
-    const result = await agent.chat('我刚才说什么了？');
-    console.log('[DEBUG] result:', JSON.stringify(result, null, 2));
-  } catch (err) {
-    console.error('[Error]', err.message);
-  }
-
-  await framework.destroy();
-  console.log('\n[Done]');
-}
-
-main().catch(console.error);

package/examples/test-chat-stream-diff.js

@@ -1,63 +0,0 @@
-/**
- * 测试 chat 和 chatStream 的差异
- */
-
-const { Framework } = require('../src');
-const AIPlugin = require('../plugins/ai-plugin');
-const SessionPlugin = require('../plugins/session-plugin');
-require('dotenv').config();
-
-async function main() {
-  console.log('=== 测试 chat vs chatStream 差异 ===\n');
-
-  const framework = new Framework({ debug: false });
-
-  await framework.loadPlugin(
-    new AIPlugin({
-      provider: 'minimax',
-      model: 'MiniMax-M2.7',
-      apiKey: process.env.MINIMAX_API_KEY || 'your-api-key',
-    })
-  );
-  await framework.loadPlugin(new SessionPlugin());
-
-  const systemPrompt = `你是一个有帮助的助手。`;
-
-  const agent = framework.createAgent({
-    name: 'TestAgent',
-    systemPrompt: systemPrompt,
-  });
-
-  const sessionId = 'test_session';
-  const sessionPlugin = framework.pluginManager.get('session');
-  sessionPlugin.getOrCreateSession(sessionId, { metadata: {} });
-
-  // 测试 chat
-  console.log('--- Test 1: chat() ---');
-  const result1 = await agent.chat('你好，介绍一下自己', { sessionId });
-  console.log('chat result.message length:', result1.message?.length);
-  console.log('chat result.message:', result1.message?.substring(0, 100));
-
-  // 测试 chatStream
-  console.log('\n--- Test 2: chatStream() ---');
-  let streamText = '';
-  for await (const chunk of agent.chatStream('今天天气怎么样？', { sessionId })) {
-    if (chunk.type === 'text') {
-      streamText += chunk.text;
-    }
-  }
-  console.log('chatStream full text length:', streamText.length);
-  console.log('chatStream full text:', streamText.substring(0, 100));
-
-  // 测试更多轮对话后的 chat
-  console.log('\n--- Test 3: 多轮后 chat() ---');
-  await agent.chat('再说一次你的名字', { sessionId });
-  const result3 = await agent.chat('我叫什么？', { sessionId });
-  console.log('chat result.message length:', result3.message?.length);
-  console.log('chat result.message:', result3.message?.substring(0, 100));
-
-  await framework.destroy();
-  console.log('\n[Done]');
-}
-
-main().catch(console.error);