foliko 1.0.84 → 1.0.86

package/.agent/plugins/{puppeteer-plugin → temp-repo/puppeteer-plugin}/index.js

@@ -318,6 +318,7 @@ module.exports = function (Plugin) {
         description: '获取页面HTML内容（注意：复杂页面会导致token超标，建议使用 page_structure 获取页面结构）',
         inputSchema: z.object({
           contentOnly: z.boolean().optional().describe('仅获取body内容'),
+          toMarkdown: z.boolean().optional().default(true).describe('是否将HTML转换为Markdown格式，默认开启'),
           pageId: z.string().optional().describe('页面ID，默认当前页面'),
         }),
         execute: async (args) => {
@@ -325,19 +326,116 @@ module.exports = function (Plugin) {
             ? this.pages.get(args.pageId)
             : this.getCurrentPage();
 
-          const html = args.contentOnly
+          let html = args.contentOnly
             ? await page.evaluate(() => document.body ? document.body.innerHTML : '')
             : await page.content();
 
+          let content = html;
+          let isMarkdown = false;
+
+          // 如果需要转换为 Markdown（默认为 true）
+          const shouldConvertToMarkdown = args.toMarkdown !== false;
+          if (shouldConvertToMarkdown) {
+            content = this._htmlToMarkdown(html);
+            isMarkdown = true;
+          }
+
           return {
             success: true,
-            html: html,
-            length: html.length,
+            html: isMarkdown ? undefined : html,
+            markdown: isMarkdown ? content : undefined,
+            content: content,
+            length: content.length,
+            isMarkdown: isMarkdown,
             url: page.url()
           };
         }
       },
 
+      // HTML 转 Markdown 辅助方法
+      _htmlToMarkdown(html) {
+        if (!html) return '';
+        
+        // 移除脚本和样式标签内容
+        let markdown = html
+          .replace(/<script[^>]*>[\s\S]*?<\/script>/gi, '')
+          .replace(/<style[^>]*>[\s\S]*?<\/style>/gi, '')
+          .replace(/<!--[\s\S]*?-->/g, '');
+
+        // 标题转换
+        markdown = markdown.replace(/<h1[^>]*>([\s\S]*?)<\/h1>/gi, '# $1\n\n');
+        markdown = markdown.replace(/<h2[^>]*>([\s\S]*?)<\/h2>/gi, '## $1\n\n');
+        markdown = markdown.replace(/<h3[^>]*>([\s\S]*?)<\/h3>/gi, '### $1\n\n');
+        markdown = markdown.replace(/<h4[^>]*>([\s\S]*?)<\/h4>/gi, '#### $1\n\n');
+        markdown = markdown.replace(/<h5[^>]*>([\s\S]*?)<\/h5>/gi, '##### $1\n\n');
+        markdown = markdown.replace(/<h6[^>]*>([\s\S]*?)<\/h6>/gi, '###### $1\n\n');
+
+        // 换行和段落
+        markdown = markdown.replace(/<br\s*\/?>/gi, '\n');
+        markdown = markdown.replace(/<\/p>/gi, '\n\n');
+        markdown = markdown.replace(/<\/div>/gi, '\n');
+        markdown = markdown.replace(/<\/li>/gi, '\n');
+
+        // 列表
+        markdown = markdown.replace(/<ul[^>]*>/gi, '\n');
+        markdown = markdown.replace(/<ol[^>]*>/gi, '\n');
+        markdown = markdown.replace(/<li[^>]*>([\s\S]*?)<\/li>/gi, '- $1\n');
+
+        // 链接和图片
+        markdown = markdown.replace(/<a[^>]*href=["']([^"']*)["'][^>]*>([\s\S]*?)<\/a>/gi, '[$2]($1)');
+        markdown = markdown.replace(/<img[^>]*src=["']([^"']*)["'][^>]*alt=["']([^"']*)["'][^>]*\/?>/gi, '![$2]($1)');
+        markdown = markdown.replace(/<img[^>]*alt=["']([^"']*)["'][^>]*src=["']([^"']*)["'][^>]*\/?>/gi, '![$1]($2)');
+        markdown = markdown.replace(/<img[^>]*src=["']([^"']*)["'][^>]*\/?>/gi, '![]($1)');
+
+        // 粗体和斜体
+        markdown = markdown.replace(/<strong[^>]*>([\s\S]*?)<\/strong>/gi, '**$1**');
+        markdown = markdown.replace(/<b[^>]*>([\s\S]*?)<\/b>/gi, '**$1**');
+        markdown = markdown.replace(/<em[^>]*>([\s\S]*?)<\/em>/gi, '*$1*');
+        markdown = markdown.replace(/<i[^>]*>([\s\S]*?)<\/i>/gi, '*$1*');
+
+        // 代码
+        markdown = markdown.replace(/<code[^>]*>([\s\S]*?)<\/code>/gi, '`$1`');
+        markdown = markdown.replace(/<pre[^>]*>([\s\S]*?)<\/pre>/gi, '```\n$1\n```');
+
+        // 表格 (简单支持)
+        const tableRegex = /<table[^>]*>([\s\S]*?)<\/table>/gi;
+        markdown = markdown.replace(tableRegex, (match, tableContent) => {
+          let mdTable = '';
+          const rows = tableContent.match(/<tr[^>]*>([\s\S]*?)<\/tr>/gi) || [];
+          rows.forEach((row, idx) => {
+            const cells = row.match(/<t[hd][^>]*>([\s\S]*?)<\/t[hd]>/gi) || [];
+            const mdRow = cells.map(cell => {
+              return cell.replace(/<t[hd][^>]*>/, '').replace(/<\/t[hd]>/, '').trim();
+            }).join(' | ');
+            if (idx === 0) {
+              mdTable += mdRow + '\n' + mdRow.split('|').map(() => '---').join('|') + '\n';
+            } else {
+              mdTable += mdRow + '\n';
+            }
+          });
+          return mdTable + '\n';
+        });
+
+        // 移除所有剩余 HTML 标签
+        markdown = markdown.replace(/<[^>]+>/g, '');
+
+        // 清理实体编码
+        markdown = markdown
+          .replace(/&nbsp;/g, ' ')
+          .replace(/&amp;/g, '&')
+          .replace(/&lt;/g, '<')
+          .replace(/&gt;/g, '>')
+          .replace(/&quot;/g, '"')
+          .replace(/&#39;/g, "'")
+          .replace(/&nbsp;/g, ' ')
+          .replace(/&#(\d+);/g, (match, dec) => String.fromCharCode(dec));
+
+        // 清理多余空行
+        markdown = markdown.replace(/\n{3,}/g, '\n\n').trim();
+
+        return markdown;
+      },
+
       // 获取页面结构（优化版 - 返回精简的结构化数据，避免token超标）
       page_structure: {
         description: '获取页面关键结构信息（推荐使用），返回可交互元素的精简结构，避免获取完整HTML导致的token超标问题',

package/.agent/plugins/test_plugin.py

@@ -0,0 +1,304 @@
+# .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/.agent/plugins.json

@@ -1,5 +1,14 @@
-{
-  "weixin": {
-    "enabled": true
-  }
-}
+{
+  "email": {
+    "enabled": true,
+    "smtp": {
+      "host": "smtp.gmail.com",
+      "port": 587,
+      "secure": false
+    },
+    "imap": {
+      "host": "imap.gmail.com",
+      "port": 993
+    }
+  }
+}

package/.agent/python-scripts/test_sample.py

@@ -0,0 +1,24 @@
+"""
+测试模块 - 2026-04-02 02:52:12
+"""
+
+import unittest
+
+
+
+class TestMath(unittest.TestCase):
+    """TestMath 测试类"""
+
+    def test_add(self):
+        """测试用例: test_add"""
+        # TODO: 实现测试逻辑
+        self.assertTrue(True)
+
+    def test_subtract(self):
+        """测试用例: test_subtract"""
+        # TODO: 实现测试逻辑
+        self.assertTrue(True)
+
+
+if __name__ == "__main__":
+    unittest.main()