foliko 1.0.86 → 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"
-        }
-    }