From 78fea7ccddbb64d36519f18adefb298c4c4cf513 Mon Sep 17 00:00:00 2001 From: shuiyu1123 Date: Sun, 5 Jul 2026 13:17:27 +0800 Subject: [PATCH] =?UTF-8?q?xiaoli-cli=207.0.0:=20=E9=87=8D=E6=9E=84?= =?UTF-8?q?=E5=BA=95=E5=B1=82=E6=9E=B6=E6=9E=84=20+=20=E7=A7=BB=E9=99=A4?= =?UTF-8?q?=E5=B7=A5=E5=85=B7=E6=88=AA=E6=96=AD?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 重构 core/ 底层 (7文件): app/runner/engine/parser/history/safety/display - FC原生调用为主，prompt-JSON保底 - 移除所有工具返回截断 (ai_search/git_tools/cmd_executor/browser_auto/network_tools/sub_agent/tool_search) - 删除无用文件 (旧服务器/WebUI/彩蛋/启动器等21个文件) - 清理 constants.py 死代码 - 版本号更新为 7.0.0 --- .gitignore | 49 + LICENSE | 21 + README.md | 354 ++++++ ai_cli.py | 19 + ai_engines/manual_engine.py | 290 +++++ ai_engines/ollama_engine.py | 491 ++++++++ ai_engines/openai_engine.py | 603 +++++++++ core/__init__.py | 2 + core/app.py | 274 +++++ core/display.py | 44 + core/engine.py | 170 +++ core/history.py | 84 ++ core/parser.py | 146 +++ core/runner.py | 146 +++ core/safety.py | 137 +++ core/types.py | 37 + logger.py | 47 + plugins/ai_search.py | 219 ++++ plugins/auto_engineer.py | 456 +++++++ plugins/browser_auto.py | 545 +++++++++ plugins/cmd_executor.py | 147 +++ plugins/code_editor.py | 1477 +++++++++++++++++++++++ plugins/compile_check.py | 564 +++++++++ plugins/file_manager.py | 354 ++++++ plugins/frontend_tester.py | 479 ++++++++ plugins/git_tools.py | 426 +++++++ plugins/gui_auto.py | 1036 ++++++++++++++++ plugins/id_generator.py | 383 ++++++ plugins/image_reader.py | 293 +++++ plugins/json_toolkit.py | 386 ++++++ plugins/markdown_tool.py | 540 +++++++++ plugins/memory_plugin.py | 253 ++++ plugins/network_tools.py | 295 +++++ plugins/regex_tester.py | 442 +++++++ plugins/scheduler.py | 441 +++++++ plugins/snippet_manager.py | 449 +++++++ plugins/speech_recognition.py | 549 +++++++++ plugins/sub_agent.py | 523 ++++++++ plugins/task_manager.py | 289 +++++ plugins/terminal.py | 411 +++++++ plugins/tool_search.py | 121 ++ plugins/workflow.py | 808 +++++++++++++ plugins_config.py | 28 + requirements.txt | 12 + scheduler_tasks.json | 1 + skills/__init__.py | 28 + skills/base.py | 382 ++++++ skills/code_stats.py | 140 +++ skills/file-manager/SKILL.md | 305 +++++ skills/file-manager/scripts/file_ops.py | 671 ++++++++++ unified_tool_manager.py | 671 ++++++++++ xcli_core/__init__.py | 1 + xcli_core/config.py | 108 ++ xcli_core/constants.py | 87 ++ xcli_core/memory.py | 800 ++++++++++++ xcli_core/notification.py | 205 ++++ xcli_core/tool_result.py | 119 ++ 57 files changed, 18358 insertions(+) create mode 100644 .gitignore create mode 100644 LICENSE create mode 100644 README.md create mode 100644 ai_cli.py create mode 100644 ai_engines/manual_engine.py create mode 100644 ai_engines/ollama_engine.py create mode 100644 ai_engines/openai_engine.py create mode 100644 core/__init__.py create mode 100644 core/app.py create mode 100644 core/display.py create mode 100644 core/engine.py create mode 100644 core/history.py create mode 100644 core/parser.py create mode 100644 core/runner.py create mode 100644 core/safety.py create mode 100644 core/types.py create mode 100644 logger.py create mode 100644 plugins/ai_search.py create mode 100644 plugins/auto_engineer.py create mode 100644 plugins/browser_auto.py create mode 100644 plugins/cmd_executor.py create mode 100644 plugins/code_editor.py create mode 100644 plugins/compile_check.py create mode 100644 plugins/file_manager.py create mode 100644 plugins/frontend_tester.py create mode 100644 plugins/git_tools.py create mode 100644 plugins/gui_auto.py create mode 100644 plugins/id_generator.py create mode 100644 plugins/image_reader.py create mode 100644 plugins/json_toolkit.py create mode 100644 plugins/markdown_tool.py create mode 100644 plugins/memory_plugin.py create mode 100644 plugins/network_tools.py create mode 100644 plugins/regex_tester.py create mode 100644 plugins/scheduler.py create mode 100644 plugins/snippet_manager.py create mode 100644 plugins/speech_recognition.py create mode 100644 plugins/sub_agent.py create mode 100644 plugins/task_manager.py create mode 100644 plugins/terminal.py create mode 100644 plugins/tool_search.py create mode 100644 plugins/workflow.py create mode 100644 plugins_config.py create mode 100644 requirements.txt create mode 100644 scheduler_tasks.json create mode 100644 skills/__init__.py create mode 100644 skills/base.py create mode 100644 skills/code_stats.py create mode 100644 skills/file-manager/SKILL.md create mode 100644 skills/file-manager/scripts/file_ops.py create mode 100644 unified_tool_manager.py create mode 100644 xcli_core/__init__.py create mode 100644 xcli_core/config.py create mode 100644 xcli_core/constants.py create mode 100644 xcli_core/memory.py create mode 100644 xcli_core/notification.py create mode 100644 xcli_core/tool_result.py diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..71c9d19 --- /dev/null +++ b/.gitignore @@ -0,0 +1,49 @@ +# Python +__pycache__/ +*.py[cod] +*$py.class +*.so +*.egg-info/ +dist/ +build/ +.eggs/ + +# 虚拟环境 +.venv/ +venv/ +env/ + +# IDE +.vscode/ +.idea/ +*.swp +*.swo + +# 配置（含敏感信息） +config.json + +# 日志 +*.log +logs/ + +# 聊天记录 +chat_history/ + +# 系统文件 +.DS_Store +Thumbs.db + +# 嵌入式 Python +embedded_python/ + +# 记忆系统数据（运行时生成） +MEMORY.md +memory/ + +# 生成的图片 +generated_*.png +screenshots/gen_*.png + +# 临时文件 +*.tmp +*.bak diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..683b79e --- /dev/null +++ b/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2026 shuiyu1123 + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/README.md b/README.md new file mode 100644 index 0000000..c969dfa --- /dev/null +++ b/README.md @@ -0,0 +1,354 @@ +# 小狸 Pro-CLI + +

+ xiaoli-cli logo +

+ +

+ 智能编程助手 — 代码编辑 · Git 集成 · 浏览器自动化 · 多 Agent 协作 · 图像生成 · 记忆系统 +

+ +

+ version + python + license + tests + plugins +

+ +--- + +## 简介 + +小狸 Pro-CLI 是一款基于 Python 的智能编程助手，集成了代码编辑、版本控制、浏览器自动化、图像生成、记忆系统等功能，支持多种 AI 引擎，帮助开发者提升工作效率。 + +## 特性 + +- **双 AI 引擎** — Ollama 本地模型 + OpenAI 兼容格式（DeepSeek、Grok、硅基流动等） +- **代码编辑与搜索** — 精准替换、批量编辑、符号提取、依赖分析、正则搜索、自动语法检查 +- **Git 版本控制** — 完整 Git 操作 + 工作流自动化（smart-commit、changelog） +- **浏览器自动化** — Playwright 驱动，导航、交互、截图、JS 执行、PDF 导出 +- **子 Agent 系统** — 多 Agent 并行协作，独立任务分配与结果回收 +- **图像生成** — 基于 ComfyUI 在线服务，自然语言/Tag 双模式，支持中文描述 +- **记忆系统** — 长期记忆 + 每日日记 + AI 写日记 + 全局搜索 + 自动保存对话 +- **远程通信** — PC 与手机 WebSocket 双向通信 +- **定时任务** — 支持相对时间、绝对时间、重复任务，到期自动激活 AI +- **系统通知** — 跨平台任务完成通知（Windows / macOS / Linux） +- **MCP 协议** — 18 个插件全部实现 MCP 定义，支持 Function Calling 原生调用 +- **进程保护** — 跨平台单实例保护 + 进程优先级提升 + Windows PPL 风格保护 + 看门狗监控 + 优雅关闭 +- **18 个插件 161+ 个操作** — 代码编辑、Git、浏览器、工程化、文件管理、图像生成、记忆等 +- **150+ 个自动化测试** — pytest 覆盖全部插件和核心模块 + +## 快速开始 + +### 安装 + +```bash +git clone https://gitee.com/shuiyu1123/xiaoli-cli.git +cd xiaoli-cli +pip install -r requirements.txt +``` + +### 启动 + +```bash +# CLI 模式 +python ai_cli.py + +# 指定引擎 +python ai_cli.py --engine openai + +# Windows 一键启动 +launcher.exe +``` + +## AI 引擎 + +| 引擎 | 类型 | 说明 | +|------|------|------| +| `ollama` | 本地 | Ollama 本地模型，无需 API 密钥 | +| `openai` | 云端/本地 | OpenAI 兼容格式，支持 DeepSeek、Grok、硅基流动、本地 vLLM 等 | + +### 配置示例 (config.json) + +```json +{ + "api": { + "engines": { + "ollama": { + "base_url": "http://localhost:11434", + "model": "gemma4:31b" + }, + "openai": { + "api_key": "your-key", + "base_url": "https://api.deepseek.com/v1", + "model": "deepseek-chat" + } + } + }, + "system": { + "default_engine": "ollama", + "max_history": 50 + } +} +``` + +## 插件列表 (23 个) + +> 更多社区插件请访问 [xiaoli-cli-plugins](https://gitee.com/shuiyu1123/xiaoli-cli-plugins)，使用 `/plugin install <插件码>` 一键安装。 + +### 核心生产力 + +| 插件 | 操作数 | 说明 | +|------|--------|------| +| `code_editor` | 24 | 代码编辑+搜索。精准替换、批量编辑、find/regex/symbols/imports/callers/todo/structure + 自动语法检查 | +| `git_tools` | 17 | Git 版本控制。status/diff/log/commit/branch + smart-commit/changelog/contributors/stale | +| `cmd_executor` | 1 | Shell 命令执行，跨平台，超时控制 | +| `file_manager` | 10 | 文件系统。list/read/write/copy/move/delete/search/info/mkdir/append | +| `auto_engineer` | 12 | 工程化。lint/format/test/build/deps + 复杂度/安全扫描/质量指标/项目初始化 | +| `task_manager` | 7 | 任务管理。add/list/complete/delete/clear，JSON 持久化 | + +### 高级功能 + +| 插件 | 操作数 | 说明 | +|------|--------|------| +| `sub_agent` | 8 | 子 Agent 系统。spawn/list/status/result/send/kill，多 Agent 并行协作 | +| `terminal` | 8 | 终端模拟器。AI 的虚拟键盘和屏幕，打字/按键/看屏幕，支持 Python REPL | + +### 辅助工具 + +| 插件 | 说明 | +|------|------| +| `browser_auto` | 浏览器自动化。导航/点击/填写/截图/JS执行（基于 Playwright） | +| `gui_auto` | 桌面 GUI 自动化。Windows UIA 元素识别/点击/输入（仅 Windows） | +| `memory_plugin` | 记忆系统。AI 写日记/搜索记忆/管理聊天记录 | +| `scheduler` | 定时任务。支持相对/绝对/重复任务，到期自动激活 AI | +| `tool_search` | 工具搜索。按关键词发现可用插件 | +| `workflow` | 工作流引擎。YAML 多步骤自动化，变量传递，条件分支 | +| `network_tools` | 网络工具。ping/get/status/headers/ip | +| `ai_search` | AI 搜索。jina.ai 智能搜索 + 网页内容提取 | +| `frontend_tester` | 前端测试。HTML/CSS/JS 语法检查、响应式验证 | +| `speech_recognition` | 语音识别。录音 + 语音转文字（Whisper） | +| `json_toolkit` | JSON 工具箱。格式化/压缩/校验/路径查询/差异比较 | +| `regex_tester` | 正则表达式测试器。匹配/提取/替换/解释 | +| `snippet_manager` | 代码片段管理器。保存/搜索/复用常用代码 | +| `markdown_tool` | Markdown 工具。TOC/统计/表格生成/待办提取 | +| `id_generator` | ID 生成器。UUID/NanoID/短ID/雪花ID/ULID | + +## 记忆系统 + +内置持久化记忆系统，AI 可以记住之前的工作： + +| 功能 | 说明 | +|------|------| +| 长期记忆 | `MEMORY.md` — AI 自己维护的精华记忆 | +| 每日日记 | `memory/YYYY-MM-DD.md` — 带时间戳和标签 | +| AI 写日记 | `memory_plugin diary_ai` — 自动标记 [AI观察] | +| 自动保存对话 | 每轮对话后自动存 JSON | +| 上下文压缩 | 超过 50 条自动 AI 总结，保留最近 10 条 | +| 全局搜索 | 搜索 MEMORY + 日记 + 聊天记录 | + +``` +memory_plugin diary 今天完成了API对接 +memory_plugin search 定时任务 +memory_plugin remember 用户偏好深色主题 +memory_plugin chat_search 图像生成 +``` + +## 远程通信 + +通过 WebSocket 实现 PC 与手机双向通信： + +```bash +/remote start 9079 mypassword # 启动本地服务 +/remote stop # 停止服务 +/remote status # 查看状态 +``` + +功能：手机发消息给 AI、AI 回复推到手机、文件传输、图片识别。 + +## 安全机制 + +### 模式切换 (`/safe`) + +| 模式 | 说明 | +|------|------| +| **普通模式** (默认) | AI 识别风险，有风险才请求确认 | +| **人工确认** | 所有指令都需要用户确认 | + +### 检查流程 + +``` +工具调用 → safety.check() + ├─ 快速预检（读取/查询类）→ 直接放行 + ├─ 普通模式 → AI 独立分析风险 + │ ├─ safe → 放行 + │ └─ unsafe → 展示风险等级+影响，y/n 确认 + └─ 特殊指令（rm/delete/chmod）→ 始终确认 +``` + +### 代码执行 + +独立的安全代码执行环境： +- AST 级危险代码检测 +- 模块白名单（阻断 25 个高危模块） +- 子进程隔离执行 +- 内存限制 + +## MCP 协议支持 + +所有 18 个插件均实现 MCP (Model Context Protocol) 定义，支持三种工具调用协议： + +| 协议 | 说明 | +|------|------| +| **MCP** | Model Context Protocol 标准定义 | +| **FC** | OpenAI Function Calling 原生调用 | +| **JSON** | 传统 `{"action": "use_tool", ...}` 格式 | + +## 命令列表 + +| 命令 | 说明 | +|------|------| +| `/help` | 显示帮助 | +| `/safe` | 切换安全模式 | +| `/engine list` | 列出可用引擎 | +| `/engine switch <引擎>` | 切换引擎 | +| `/engine.openai models` | 列出 OpenAI 引擎模型 | +| `/chat save/list/open` | 聊天记录管理 | +| `/file.read <路径>` | 读取文件 | +| `/remote` | 远程连接帮助 | +| `/notify` | 切换任务完成通知 | +| `/scheduler` / `/remind` | 管理定时任务 | +| `/memory` | 管理记忆系统 | +| `/quit` | 退出 | + +## Web UI + +WebSocket 实时交互界面，支持完整的 AI 对话体验。 + +```bash +# 方式 1: 启动 WebSocket 后端（推荐） +python webui_server.py --port 8080 +# 浏览器访问 http://localhost:8080 + +# 方式 2: 直接打开静态页面 +start webui.html # Windows +open webui.html # macOS +xdg-open webui.html # Linux +``` + +## 项目结构 + +``` +xiaoli-cli/ +├── ai_cli.py # 主入口 +├── webui.html # Web UI 界面 +├── webui_server.py # Web UI 后端 +├── launcher.py # 智能启动器 +├── config.json.example # 配置模板 +├── easter_egg.py # 彩蛋 +├── xcli_core/ # 核心模块 +│ ├── cli_core.py # 主循环 + 提示词构建 +│ ├── cli_base.py # 初始化 + 引擎/插件加载 +│ ├── cli_tools.py # 工具调用执行 +│ ├── cli_clawli.py # 远程模式 +│ ├── cli_code_exec.py # 代码执行 +│ ├── cli_display.py # 显示输出 +│ ├── cli_history.py # 聊天记录 +│ ├── config.py # 配置管理 +│ ├── constants.py # 常量定义 +│ ├── fc_tools.py # MCP → FC 格式转换 +│ ├── memory.py # 记忆系统 +│ ├── notification.py # 跨平台系统通知 +│ ├── plugin_manager.py # 插件管理器 +│ ├── safety.py # 统一安全层 +│ ├── sandbox.py # 代码安全沙箱 +├── ai_engines/ # AI 引擎 +│ ├── ollama_engine.py +│ └── openai_engine.py +├── plugins/ # 插件 (18 个) +│ ├── code_editor.py +│ ├── git_tools.py +│ ├── cmd_executor.py +│ ├── file_manager.py +│ ├── auto_engineer.py +│ ├── task_manager.py +│ ├── sub_agent.py +│ ├── browser_auto.py +│ ├── gui_auto.py +│ ├── ai_image.py +│ ├── image_generator.py +│ ├── memory_plugin.py +│ ├── scheduler.py +│ ├── tool_search.py +│ ├── network_tools.py +│ ├── ai_search.py +│ ├── frontend_tester.py +│ ├── speech_recognition.py +│ └── terminal.py +├── skills/ # 技能 +├── image_engine/ # 图像识别引擎 +├── tests/ # 测试套件 (150+ 用例) +├── love.txt # 彩蛋情话 +└── about.txt # 关于信息 +``` + +## 测试 + +```bash +# 运行全部测试 +python -m pytest tests/ -v + +# 语法检查 +python -c "import py_compile; py_compile.compile('ai_cli.py', doraise=True)" +``` + +## 插件开发 + +小狸支持 `Liugin`（自研协议）和 `Plugin`（通用协议）两种类名，均可被插件管理器自动识别： + +```python +class Plugin: + """我的插件""" + + def __init__(self): + self.usage = "使用说明" + self.cli = None + + def set_cli(self, cli): + self.cli = cli + + def get_tool_info(self): + return { + "name": "my_tool", + "description": "工具描述", + "keywords": ["关键词"], + "usage": self.usage + } + + def get_mcp_definition(self): + return { + "name": "my_tool", + "description": "工具描述", + "inputSchema": { + "type": "object", + "properties": { + "args": {"type": "string", "description": "参数"} + } + } + } + + def handle(self, args: str) -> str: + return "处理结果" +``` + +## 许可证 + +[MIT License](LICENSE) + +## 链接 + +- Gitee: https://gitee.com/shuiyu1123/xiaoli-cli +- 插件仓库: https://gitee.com/shuiyu1123/xiaoli-cli-plugins +- [更新日志](CHANGELOG.md) +- [使用指南](HELP.md) diff --git a/ai_cli.py b/ai_cli.py new file mode 100644 index 0000000..2326176 --- /dev/null +++ b/ai_cli.py @@ -0,0 +1,19 @@ +#!/usr/bin/env python3 +"""xiaoli-cli 7.0.0 入口""" +import sys, os +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) + +def main(): + try: + from core.app import XiaoliCLI + cli = XiaoliCLI() + cli.run() + except KeyboardInterrupt: + print("\n再见~") + except Exception as e: + print(f"启动失败: {e}") + import traceback; traceback.print_exc() + sys.exit(1) + +if __name__ == "__main__": + main() diff --git a/ai_engines/manual_engine.py b/ai_engines/manual_engine.py new file mode 100644 index 0000000..ae8feed --- /dev/null +++ b/ai_engines/manual_engine.py @@ -0,0 +1,290 @@ +#!/usr/bin/env python3 +""" +手动引擎 - 让人类在另一个终端扮演 AI +消息通过文件传递，另一个终端窗口显示消息并等待人工输入 +""" + +import os +import sys +import json +import time +import subprocess +import tempfile +import threading +from pathlib import Path + +# 添加项目根目录到sys.path +current_dir = os.path.dirname(os.path.abspath(__file__)) +project_root = os.path.dirname(current_dir) +sys.path.insert(0, project_root) + +# 通信用的临时目录 +COMM_DIR = os.path.join(tempfile.gettempdir(), "xiaoli_manual_engine") + + +class ManualAI: + """手动引擎 — 让人类在另一个终端扮演 AI""" + + requires_api_key = False + + def __init__(self): + self.name = "manual" + self.cli = None + self.conversation_history = [] + self.max_history = 10 + self._subprocess = None + self._session_id = str(int(time.time())) + self._started = False + + # 确保通信目录存在 + os.makedirs(COMM_DIR, exist_ok=True) + + def get_help_info(self): + return """手动引擎帮助信息 +======================== + +引擎名称: manual +描述: 让人类在另一个终端窗口扮演 AI，消息通过文件传递 + +工作原理: + 1. 切换到 manual 引擎时，自动打开一个新终端窗口 + 2. 用户在 CLI 中输入消息，消息会显示在新终端窗口中 + 3. 另一个终端窗口中的人阅读消息，手动输入回复并按回车 + 4. 回复传回 CLI，显示为 AI 的响应 + +使用说明: + 1. /engine switch manual — 切换到手动引擎，自动打开另一个终端 + 2. 在 CLI 中正常对话，消息会转发到另一个终端 + 3. 在另一个终端中手动输入回复 + 4. /engine.manual status — 查看连接状态 + 5. /engine.manual restart — 重启另一个终端窗口 + +注意: 需要图形桌面环境才能自动打开新终端窗口。 + 如果是无头服务器，请手动运行通信脚本。 +""" + + def _get_paths(self): + """获取通信文件路径""" + base = os.path.join(COMM_DIR, self._session_id) + return { + "msg_to_human": base + "_to_human.txt", + "msg_from_human": base + "_from_human.txt", + "ready": base + "_ready.flag", + "alive": base + "_alive.flag", + } + + def _spawn_terminal(self): + """在新终端窗口中启动人工回复脚本""" + paths = self._get_paths() + + # 写一个临时脚本 + script_content = self._generate_script(paths) + script_path = os.path.join(COMM_DIR, f"worker_{self._session_id}.py") + with open(script_path, 'w', encoding='utf-8') as f: + f.write(script_content) + + # 根据平台选择终端 + import platform + system = platform.system() + + try: + if system == "Windows": + self._subprocess = subprocess.Popen( + ["cmd", "/c", "start", "cmd", "/k", f"python \"{script_path}\""], + shell=True + ) + elif system == "Darwin": # macOS + self._subprocess = subprocess.Popen([ + "osascript", "-e", + f'tell app "Terminal" to do script "python3 \\"{script_path}\\""' + ]) + else: # Linux + # 尝试常见的终端模拟器 + terminals = [ + ["x-terminal-emulator", "-e", f"python3 {script_path}"], + ["gnome-terminal", "--", "python3", script_path], + ["konsole", "-e", f"python3 {script_path}"], + ["xfce4-terminal", "-e", f"python3 {script_path}"], + ["xterm", "-e", f"python3 {script_path}"], + ] + launched = False + for cmd in terminals: + try: + self._subprocess = subprocess.Popen(cmd) + launched = True + break + except FileNotFoundError: + continue + if not launched: + print(f"\033[33m[manual] 无法自动打开终端窗口，请手动运行:\033[0m") + print(f"\033[36m python3 {script_path}\033[0m") + return False + + # 等待对方就绪 + ready_path = paths["ready"] + for _ in range(30): # 最多等 15 秒 + if os.path.exists(ready_path): + self._started = True + return True + time.sleep(0.5) + + # 超时但不报错，可能终端启动慢 + self._started = True + return True + + except Exception as e: + print(f"\033[31m[manual] 启动终端失败: {e}\033[0m") + print(f"\033[33m[manual] 请手动运行: python3 {script_path}\033[0m") + return False + + def _generate_script(self, paths): + """生成人工回复脚本的内容""" + return f'''#!/usr/bin/env python3 +"""小狸手动引擎 — 人工回复终端""" +import os +import sys +import time +import signal + +MSG_IN = r"{paths['msg_to_human']}" +MSG_OUT = r"{paths['msg_from_human']}" +READY = r"{paths['ready']}" +ALIVE = r"{paths['alive']}" + +# 标记自己已就绪 +with open(READY, 'w') as f: + f.write("ready") + +# 定期刷新 alive 标记 +def keep_alive(): + try: + with open(ALIVE, 'w') as f: + f.write(str(time.time())) + except: + pass + +keep_alive() + +print() +print("\\033[36m╔══════════════════════════════════════════╗\\033[0m") +print("\\033[36m║ 小狸手动引擎 — 人工回复终端 ║\\033[0m") +print("\\033[36m║ 在这里输入回复，按回车发送 ║\\033[0m") +print("\\033[36m║ 输入 quit 退出 ║\\033[0m") +print("\\033[36m╚══════════════════════════════════════════╝\\033[0m") +print() +sys.stdout.flush() + +last_msg_time = 0 + +while True: + keep_alive() + + # 检查是否有新消息 + try: + if os.path.exists(MSG_IN): + mtime = os.path.getmtime(MSG_IN) + if mtime > last_msg_time: + last_msg_time = mtime + with open(MSG_IN, 'r', encoding='utf-8') as f: + msg = f.read() + if msg: + print("\\033[33m[用户消息]\\033[0m") + print(msg) + print() + sys.stdout.flush() + except: + pass + + # 检查用户输入（非阻塞） + try: + import select + if select.select([sys.stdin], [], [], 0.3)[0]: + line = sys.stdin.readline().strip() + if line: + if line.lower() == "quit": + print("\\033[31m[已退出手动引擎]\\033[0m") + break + # 写回复 + with open(MSG_OUT, 'w', encoding='utf-8') as f: + f.write(line) + print(f"\\033[32m[已发送] {{line}}\\033[0m") + print() + sys.stdout.flush() + except: + # Windows 没有 select，用阻塞方式 + try: + import msvcrt + if msvcrt.kbhit(): + line = input().strip() + if line: + if line.lower() == "quit": + print("\\033[31m[已退出手动引擎]\\033[0m") + break + with open(MSG_OUT, 'w', encoding='utf-8') as f: + f.write(line) + print(f"\\033[32m[已发送] {{line}}\\033[0m") + print() + sys.stdout.flush() + except: + time.sleep(0.3) +''' + + def generate_response(self, user_input, tool_results=None, system_prompt=None): + """生成响应 — 转发给另一个终端的人工""" + paths = self._get_paths() + + # 如果还没启动终端，现在启动 + if not self._started: + if not self._spawn_terminal(): + return "[manual] 手动引擎未就绪，无法打开终端窗口。请手动启动通信脚本。" + + # 清除旧的回复文件 + from_human = paths["msg_from_human"] + if os.path.exists(from_human): + os.remove(from_human) + + # 把用户消息写入文件 + msg = user_input + if tool_results: + msg = f"[工具结果] {tool_results.get('result', '无结果')}\n\n{user_input}" + + to_human = paths["msg_to_human"] + with open(to_human, 'w', encoding='utf-8') as f: + f.write(msg) + + print(f"\033[36m[manual] 消息已发送到人工终端，等待回复...\033[0m") + + # 等待回复 + timeout = 300 # 最多等 5 分钟 + waited = 0 + while waited < timeout: + if os.path.exists(from_human): + try: + with open(from_human, 'r', encoding='utf-8') as f: + response = f.read().strip() + if response: + # 清理回复文件 + os.remove(from_human) + return response + except: + pass + time.sleep(0.5) + waited += 0.5 + + return "[manual] 等待人工回复超时（5分钟）" + + def handle_command(self, command): + """处理 manual 引擎专属命令""" + if command == "status": + paths = self._get_paths() + alive = os.path.exists(paths["alive"]) + return f"会话ID: {self._session_id}\n终端状态: {'已连接' if alive else '未连接'}\n通信目录: {COMM_DIR}" + elif command == "restart": + self._started = False + self._session_id = str(int(time.time())) + if self._spawn_terminal(): + return "手动引擎终端已重启" + else: + return "重启失败，无法打开终端" + else: + return f"未知命令: {command}\n可用: status, restart" diff --git a/ai_engines/ollama_engine.py b/ai_engines/ollama_engine.py new file mode 100644 index 0000000..f484229 --- /dev/null +++ b/ai_engines/ollama_engine.py @@ -0,0 +1,491 @@ +import os +import sys +import json +import requests +import threading +import time +from colorama import Fore, Style + +# 延迟导入 ollama，避免程序启动时卡住 +# 如果导入失败，ollama_client 将为 None +try: + import ollama + ollama_client = ollama +except Exception as e: + print(f"{Fore.YELLOW}警告: 无法导入 ollama 库: {e}{Style.RESET_ALL}") + print(f"{Fore.YELLOW}请确保已安装 ollama 包 (pip install ollama){Style.RESET_ALL}") + ollama_client = None + +# 添加项目根目录到sys.path +current_dir = os.path.dirname(os.path.abspath(__file__)) +project_root = os.path.dirname(current_dir) +sys.path.insert(0, project_root) + + +def _safe_get(obj, key, default=None): + """兼容 dict 和 pydantic 对象的安全取值（新版 ollama 返回 pydantic 模型，不支持 .get()）""" + if obj is None: + return default + # 1. 先尝试 dict 访问 + try: + return obj[key] + except (KeyError, TypeError): + pass + # 2. 尝试属性访问（pydantic 模型） + val = getattr(obj, key, None) + if val is not None: + return val + # 3. 尝试 model_dump 后的 dict 访问 + try: + return obj.model_dump()[key] + except (AttributeError, KeyError, TypeError): + return default + + +class OllamaAI: + """基于Ollama的本地AI引擎""" + requires_api_key = False # Ollama是本地引擎，不需要API密钥 + + def get_help_info(self): + """获取引擎帮助信息""" + help_text = """ +Ollama AI引擎插件帮助信息 +======================== + +引擎名称: Ollama +描述: 基于Ollama的本地AI引擎,支持多种大型语言模型 + +可用命令: + /engine.ollama models - 列出本地可用的模型 + /engine.ollama remote-models - 显示可下载的模型列表 + /engine.ollama search <关键词> - 搜索可下载的模型 + /engine.ollama set <模型名> - 设置当前使用的模型 + /engine.ollama pull <模型名> - 从Ollama库拉取模型 + +注意: 本引擎强制使用流式输出，AI回复会实时显示。 + +使用说明: +1. 确保Ollama服务已在本地运行 +2. 使用/engine.switch ollama切换到此引擎 +3. 使用上述命令管理模型和与AI交互 + +思考模式: + - 支持深度思考模型（如 QwQ、DeepSeek-R1） + - 思考过程会自动以灰色文本显示 +""" + return help_text + + def __init__(self): + self.name = "ollama" + self.cli = None # 引用CLI实例以访问插件 + # 初始化对话历史 + self.conversation_history = [] + + # 直接从 config.json 读取配置 + config_file = os.path.join(project_root, "config.json") + try: + with open(config_file, 'r', encoding='utf-8') as f: + config = json.load(f) + engine_config = config.get("api", {}).get("engines", {}).get("ollama", {}) + self.api_key = engine_config.get("api_key", "") + self.base_url = engine_config.get("base_url", "") + self.model = engine_config.get("model", "") + self.max_history = config.get("system", {}).get("max_history", 10) + except Exception as e: + # 如果读取失败，使用空值 + self.api_key = "" + self.base_url = "" + self.model = "" + self.max_history = 10 + + # 共享对话历史引用（由CLI设置） + self.shared_conversation_history = None + + # 取消标志 + self._cancelled = False + + # 直接启用思考标记，由主程序自动处理深度思考模型的响应 + self.thinking_start_marker = "" + self.thinking_end_marker = "" + + # 检测Ollama服务是否运行 + self.is_service_running = self.check_ollama_service() + + if self.is_service_running: + print(f"{Fore.GREEN}Ollama服务检测成功,引擎已启用{Style.RESET_ALL}") + else: + print(f"{Fore.RED}Ollama服务未运行,引擎将不可用{Style.RESET_ALL}") + + def cancel(self): + """取消正在进行的请求""" + self._cancelled = True + + def apply_config(self, base_url=None, api_key=None, model=None): + """应用新配置到当前引擎实例（内存），并持久化到 config.json""" + if base_url is not None: + self.base_url = base_url.rstrip('/') + if api_key is not None: + self.api_key = api_key + if model is not None: + self.model = model + # 持久化到 config.json + try: + import os, json + config_file = os.path.join(project_root, "config.json") + with open(config_file, 'r', encoding='utf-8') as f: + config = json.load(f) + engine_cfg = config.setdefault("api", {}).setdefault("engines", {}).setdefault("ollama", {}) + engine_cfg["base_url"] = self.base_url + engine_cfg["api_key"] = self.api_key + engine_cfg["model"] = self.model + with open(config_file, 'w', encoding='utf-8') as f: + json.dump(config, f, ensure_ascii=False, indent=2) + except Exception as e: + logger.warning(f"持久化引擎配置失败: {e}") + + def check_ollama_service(self): + """检测Ollama服务是否运行""" + # 检查 ollama 库是否可用 + if ollama_client is None: + return False + try: + # 尝试调用Ollama API获取版本信息 + response = ollama_client.list() + # 如果没有异常,说明服务运行正常 + return True + except Exception as e: + # 如果出现异常,说明服务未运行 + return False + + def generate_response(self, user_input, tool_results=None, system_prompt=None, stream_start_event=None): + """ + 生成AI响应 - 使用Ollama API + + Args: + user_input: 用户输入 + tool_results: 工具执行结果 + system_prompt: 系统提示词 + """ + try: + # 检查Ollama服务是否运行 + if not self.is_service_running: + return "错误:Ollama服务未运行,请启动Ollama服务后再使用此引擎." + + # 检查模型是否已配置 + if not self.model or not self.model.strip(): + return ("错误:Ollama模型未配置。请执行以下操作:\n" + " 1. /engine.ollama models → 查看本地可用模型\n" + " 2. /engine.ollama set <模型名> → 设置要使用的模型\n" + " 或编辑 config.json 中 api.engines.ollama.model 字段") + + # 如果有工具结果,将其作为上下文返回给AI处理 + if tool_results: + tool_result_text = f"工具执行结果: {tool_results.get('result', '无结果')}" + messages = self._build_messages_with_history(system_prompt, tool_result_text) + else: + messages = self._build_messages_with_history(system_prompt, user_input) + + # 构建调用参数 + # 重置取消标志 + self._cancelled = False + # 获取流式回调 + stream_cb = None + thinking_cb = None + + kwargs = { + "model": self.model, + "messages": messages, + "stream": True if stream_cb else False + } + + # 添加采样参数（从引擎配置读取） + options = {} + for key in ("temperature", "top_k", "top_p", "num_predict", "num_ctx"): + val = self.engine_config.get(key) + if val is not None: + options[key] = val + if options: + kwargs["options"] = options + + # 使用Ollama Python库调用API + response = ollama_client.chat(**kwargs) + + # ── 非流式模式 ── + message = _safe_get(response, "message", {}) + + # 普通文本响应 + content = _safe_get(message, "content", "") or "" + + # 处理深度思考：Ollama 把 thinking 和 content 分开返回 + # 合并到一起，用 标记包裹，让主程序处理 + thinking_content = _safe_get(message, "thinking", "") or "" + if thinking_content: + thinking_content = thinking_content.encode('utf-8', 'replace').decode('utf-8') + content = content.encode('utf-8', 'replace').decode('utf-8') + return f"{thinking_content}{content}" + + # 清理无效的 UTF-8 代理字符 + content = content.encode('utf-8', 'replace').decode('utf-8') + return content + + except Exception as e: + return f"Ollama API调用失败: {str(e)}" + + def _build_messages_with_history(self, system_prompt, user_input): + """构建包含历史记录的消息列表（支持 FC tool 消息）""" + messages = [] + + # 添加系统提示词 + if system_prompt: + clean_prompt = system_prompt.encode('utf-8', 'replace').decode('utf-8') + messages.append({ + "role": "system", + "content": clean_prompt + }) + + # 添加历史对话记录（使用共享历史） + if self.shared_conversation_history is not None: + for msg in self.shared_conversation_history[-self.max_history:]: + if not isinstance(msg, dict) or "role" not in msg: + continue + + role = msg["role"] + + # 普通 user/assistant 消息 + if "content" in msg: + clean_content = msg["content"] + if isinstance(clean_content, str): + clean_content = clean_content.encode('utf-8', 'replace').decode('utf-8') + messages.append({"role": role, "content": clean_content}) + + # 清理用户输入 + if user_input: + clean_input = user_input.encode('utf-8', 'replace').decode('utf-8') + messages.append({ + "role": "user", + "content": clean_input + }) + + return messages + + + + def _call_api_with_history(self, content, system_prompt=None): + """使用对话历史调用API""" + if not self.is_service_running: + return "错误:Ollama服务未运行,请启动Ollama服务后再使用此引擎." + + # 构建消息列表 + messages = [] + # 添加系统提示词(如果提供) + if system_prompt: + messages.append({ + "role": "system", + "content": system_prompt + }) + # 添加历史对话记录（使用共享历史） + if self.shared_conversation_history is not None: + # 确保历史记录格式正确 + for msg in self.shared_conversation_history[-self.max_history:]: + if isinstance(msg, dict) and "role" in msg and "content" in msg: + messages.append(msg) + else: + # 如果格式不正确，跳过该条记录 + continue + # 添加当前内容 + messages.append({ + "role": "tool", + "content": content + }) + + # 使用Ollama Python库调用API + response = ollama_client.chat( + model=self.model, + messages=messages, + stream=False + ) + + return response["message"]["content"] + + def set_model(self, model_name): + """设置要使用的模型""" + if not self.is_service_running: + print(f"{Fore.RED}错误:Ollama服务未运行,无法切换模型{Style.RESET_ALL}") + return + + self.model = model_name + print(f"{Fore.GREEN}已切换Ollama模型为: {model_name}{Style.RESET_ALL}") + + def list_models(self): + """列出本地可用的模型""" + if not self.is_service_running: + return ["错误:Ollama服务未运行"] + + try: + response = ollama_client.list() + models_list = _safe_get(response, "models", []) + result = [] + for model in models_list: + name = _safe_get(model, "model", "") or _safe_get(model, "name", "") + if name: + result.append(name) + return result if result else ["未找到本地模型"] + except Exception as e: + return [f"获取模型列表失败: {str(e)}"] + + def list_remote_models(self, limit=10): + """获取可下载的模型列表(仅展示前N个)""" + if not self.is_service_running: + return ["错误:Ollama服务未运行"] + + try: + # 使用Ollama Python库获取可下载的模型列表 + # 注意:Ollama库本身没有直接获取可下载模型列表的API + # 这里返回一些常见的模型作为示例 + # 实际应用中可能需要从Ollama官网或其他来源获取此信息 + common_models = [ + "llama3.1:latest", + "llama3:latest", + "mistral:latest", + "gemma2:latest", + "phi3:latest", + "qwen2:latest", + "command-r:latest", + "dolphin-mistral:latest", + "nous-hermes2:latest", + "llava:latest", + "codellama:latest", + "mxbai-embed-large:latest", + "all-minilm:latest", + "stable-diffusion:latest", + "moondream:latest" + ] + return common_models[:limit] + except Exception as e: + return [f"获取远程模型列表失败: {str(e)}"] + + def search_models(self, query, limit=10): + """模糊搜索可下载的模型""" + if not self.is_service_running: + return ["错误:Ollama服务未运行"] + + try: + # 使用Ollama Python库获取可下载的模型列表 + # 注意:Ollama库本身没有直接获取可下载模型列表的API + all_models = [ + "llama3.1:latest", "llama3:latest", "llama2:latest", + "mistral:latest", "mistral-openorca:latest", + "gemma2:latest", "gemma:latest", + "phi3:latest", "phi2:latest", + "qwen2:latest", "qwen:latest", + "command-r:latest", "command-r-plus:latest", + "dolphin-mistral:latest", "dolphin-llama3:latest", + "nous-hermes2:latest", "nous-hermes:latest", + "llava:latest", "bakllava:latest", + "codellama:latest", "codeup:latest", + "mxbai-embed-large:latest", "nomic-embed-text:latest", + "all-minilm:latest", "bge-m3:latest", + "stable-diffusion:latest", "moondream:latest", + "llama3-groq:latest", "eva-qwen2:latest" + ] + + # 进行模糊搜索(简单匹配,包含查询词的模型) + matched_models = [model for model in all_models if query.lower() in model.lower()] + + # 限制返回数量 + return matched_models[:limit] + except Exception as e: + return [f"搜索模型失败: {str(e)}"] + + def pull_model(self, model_name): + """从Ollama库拉取模型""" + if not self.is_service_running: + print(f"{Fore.RED}错误:Ollama服务未运行,无法拉取模型{Style.RESET_ALL}") + return False + + try: + print(f"{Fore.YELLOW}正在拉取模型 {model_name}...{Style.RESET_ALL}") + + # 使用Ollama Python库拉取模型 + response = ollama_client.pull(model_name, stream=True) + + # 逐块处理响应 + for part in response: + status = _safe_get(part, "status", None) + if status: + print(f"{Fore.YELLOW}{status}{Style.RESET_ALL}") + # 检查是否完成 + completed = _safe_get(part, "completed", None) + total = _safe_get(part, "total", None) + if completed is not None and total is not None: + if completed == total: + print(f"{Fore.GREEN}模型 {model_name} 拉取完成!{Style.RESET_ALL}") + + print(f"{Fore.GREEN}模型 {model_name} 拉取成功!{Style.RESET_ALL}") + return True + except Exception as e: + print(f"{Fore.RED}拉取模型 {model_name} 失败: {str(e)}{Style.RESET_ALL}") + return False + + def handle_command(self, command): + """处理引擎特定命令""" + if not self.is_service_running: + print(f"{Fore.RED}Ollama服务未运行,无法执行命令{Style.RESET_ALL}") + return False + + if command == "models": + # 显示本地可用模型 + models = self.list_models() + print(f"{Fore.GREEN}本地可用的Ollama模型:{Style.RESET_ALL}") + for model in models: + status = " (当前使用)" if model == self.model else "" + print(f"{Fore.GREEN} - {model}{status}{Style.RESET_ALL}") + return True + + elif command == "remote-models": + # 显示可下载的模型(前10个) + models = self.list_remote_models() + print(f"{Fore.GREEN}可下载的Ollama模型(前10个):{Style.RESET_ALL}") + for i, model in enumerate(models, 1): + print(f"{Fore.GREEN} {i}. {model}{Style.RESET_ALL}") + return True + + elif command.startswith("search "): + # 搜索模型 + query = command[7:].strip() # 移除 'search ' + if query: + models = self.search_models(query) + if models: + print(f"{Fore.GREEN}搜索 '{query}' 的结果(前10个):{Style.RESET_ALL}") + for i, model in enumerate(models, 1): + print(f"{Fore.GREEN} {i}. {model}{Style.RESET_ALL}") + else: + print(f"{Fore.YELLOW}未找到与 '{query}' 匹配的模型{Style.RESET_ALL}") + return True + else: + print(f"{Fore.RED}请提供搜索关键词.用法: /engine.search <关键词>{Style.RESET_ALL}") + return False + + elif command.startswith("set "): + # 设置模型 + model_name = command[4:].strip() # 移除 'set ' + if model_name: + self.set_model(model_name) + return True + else: + print(f"{Fore.RED}请提供模型名称.用法: /engine.set <模型名>{Style.RESET_ALL}") + return False + + elif command.startswith("pull "): + # 拉取模型 + model_name = command[5:].strip() # 移除 'pull ' + if model_name: + success = self.pull_model(model_name) + return success + else: + print(f"{Fore.RED}请提供模型名称.用法: /engine.pull <模型名>{Style.RESET_ALL}") + return False + + else: + print(f"{Fore.RED}未知的Ollama命令.可用命令: models, remote-models, search, set, pull{Style.RESET_ALL}") + return False \ No newline at end of file diff --git a/ai_engines/openai_engine.py b/ai_engines/openai_engine.py new file mode 100644 index 0000000..3b159f0 --- /dev/null +++ b/ai_engines/openai_engine.py @@ -0,0 +1,603 @@ +""" +OpenAI 兼容格式引擎 +支持所有兼容 OpenAI API 格式的服务（如 DeepSeek、Grok、硅基流动、本地 vLLM 等） +""" + +import os +import sys +import json +import requests +from colorama import Fore, Style +import logging + +# 设置日志 +logger = logging.getLogger(__name__) + +# 添加项目根目录到sys.path +current_dir = os.path.dirname(os.path.abspath(__file__)) +project_root = os.path.dirname(current_dir) +sys.path.insert(0, project_root) + + +class OpenaiAI: + """OpenAI 兼容格式 AI 引擎 - 支持所有兼容 OpenAI API 的服务""" + requires_api_key = True + + def get_help_info(self): + """获取引擎帮助信息""" + help_text = """ +OpenAI 兼容格式引擎帮助信息 +============================ + +引擎名称: openai +描述: 通用 OpenAI API 兼容引擎，支持所有兼容 OpenAI 格式的服务 + +支持的服务: + - OpenAI 官方 API + - DeepSeek API + - Grok (xAI) API + - 硅基流动 (SiliconFlow) API + - 本地 vLLM / LiteLLM / OneAPI 等转发服务 + - 任何兼容 /chat/completions 接口的服务 + +配置方式 (config.json): + { + "api": { + "engines": { + "openai": { + "api_key": "你的API密钥", + "base_url": "https://api.openai.com/v1", + "model": "gpt-4o" + } + } + } + } + +可用命令: + /engine.openai models - 列出可用模型（需要服务端支持） + /engine.openai set <模型名> - 切换模型 + /engine.openai info - 显示当前配置信息 + /engine.openai think - 查看深度思考状态 + /engine.openai think on - 开启深度思考 + /engine.openai think off - 关闭深度思考 + /engine.openai think high - 开启并设置推理强度 (low/medium/high) + +使用说明: +1. 在 config.json 中配置 api_key、base_url、model +2. 使用 /engine switch openai 切换到此引擎 +3. 直接输入自然语言与 AI 对话 + +注意: + - base_url 填写 API 的基础地址，无需包含 /chat/completions + - 例如 OpenAI 官方填 https://api.openai.com/v1 + - 本地服务填 http://localhost:8000/v1 +""" + return help_text + + def __init__(self): + self.name = "openai" + self.cli = None + + # 从 config.json 读取配置 + config_file = os.path.join(project_root, "config.json") + try: + with open(config_file, 'r', encoding='utf-8') as f: + config = json.load(f) + engine_config = config.get("api", {}).get("engines", {}).get("openai", {}) + self.engine_config = engine_config # 保存为属性 + self.api_key = engine_config.get("api_key", "") + self.base_url = engine_config.get("base_url", "").rstrip('/') + self.model = engine_config.get("model", "") + self.max_history = config.get("system", {}).get("max_history", 10) + # 深度思考配置 + self.deep_think = engine_config.get("deep_think", False) + self.reasoning_effort = engine_config.get("reasoning_effort", "medium") + except Exception as e: + logger.warning(f"读取配置文件失败: {e}") + self.api_key = "" + self.base_url = "" + self.model = "" + self.max_history = 10 + self.deep_think = False + self.reasoning_effort = "medium" + + # 初始化对话历史 + self.conversation_history = [] + self.shared_conversation_history = None + + # 思考标记（兼容深度思考模型） + self.thinking_start_marker = "" + self.thinking_end_marker = "" + + # 检查配置 + if not self.api_key: + print(f"{Fore.YELLOW}警告: openai 引擎的 API 密钥未设置{Style.RESET_ALL}") + if not self.base_url: + print(f"{Fore.YELLOW}警告: openai 引擎的 base_url 未设置{Style.RESET_ALL}") + else: + print(f"{Fore.GREEN}OpenAI 兼容引擎已启用 (base_url: {self.base_url}){Style.RESET_ALL}") + + def _get_headers(self): + """构建请求头""" + headers = { + 'Content-Type': 'application/json' + } + if self.api_key: + headers['Authorization'] = f'Bearer {self.api_key}' + return headers + + def _get_api_url(self): + """获取完整的 API 地址""" + url = self.base_url + if not url: + return "" + if not url.endswith('/chat/completions'): + url = url.rstrip('/') + '/chat/completions' + return url + + def generate_response(self, user_input, tool_results=None, system_prompt=None): + """ + 生成 AI 响应 + + Args: + user_input: 用户输入 + tool_results: 工具执行结果 + system_prompt: 系统提示词 + """ + try: + if not self.base_url: + return "错误: openai 引擎的 base_url 未配置，请在 config.json 中设置" + + # 处理工具结果 + if tool_results: + tool_result_text = f"工具执行结果: {tool_results.get('result', '无结果')}" + messages = self._build_messages_with_history(system_prompt, tool_result_text) + else: + messages = self._build_messages_with_history(system_prompt, user_input) + + # 构建请求体 + body = { + "model": self.model, + "messages": messages, + "stream": False + } + + # 添加采样参数（从引擎配置读取） + for key in ("temperature", "top_p"): + val = self.engine_config.get(key) + if val is not None: + body[key] = val + # top_k 部分 OpenAI 兼容 API 不支持，仅在配置明确时添加 + top_k = self.engine_config.get("top_k") + if top_k is not None: + body["top_k"] = top_k + + # ── 深度思考模式 ── + self._inject_thinking_prompt = None # 清除标记 + if self.deep_think: + body = self._apply_deep_think(body) + # 不支持原生思考的模型，注入提示词 + if self._inject_thinking_prompt: + thinking_hint = self._get_thinking_prompt(self._inject_thinking_prompt) + if thinking_hint and messages: + # 追加到系统提示词末尾 + if messages[0].get("role") == "system": + messages[0]["content"] += thinking_hint + else: + messages.insert(0, {"role": "system", "content": thinking_hint}) + body["messages"] = messages + + # 发送请求（带重试） + api_url = self._get_api_url() + import time + max_retries = 3 + response = None + + for attempt in range(max_retries): + try: + response = requests.post( + url=api_url, + json=body, + headers=self._get_headers(), + timeout=None + ) + if response.status_code < 500 or attempt == max_retries - 1: + break + print(f"{Fore.YELLOW}API 返回 {response.status_code}，第 {attempt+1}/{max_retries} 次重试...{Style.RESET_ALL}") + time.sleep(2) + except requests.exceptions.ConnectionError: + if attempt == max_retries - 1: + return f"无法连接到 API 服务: {self.base_url}，请检查服务是否运行" + print(f"{Fore.YELLOW}连接失败，第 {attempt+1}/{max_retries} 次重试...{Style.RESET_ALL}") + time.sleep(2) + + if response is None: + return "API 调用失败（重试后仍无响应）" + + if response.status_code == 200: + response_data = response.json() + if "choices" in response_data and len(response_data["choices"]) > 0: + message = response_data["choices"][0].get("message", {}) + + # 普通文本响应 + ai_response = message.get("content", "") or "" + reasoning = message.get("reasoning_content", "") or "" + + # 清理无效的 UTF-8 代理字符 + if ai_response: + ai_response = ai_response.encode('utf-8', 'replace').decode('utf-8') + ai_response = self._process_thinking_content(ai_response) + + # 处理 reasoning_content 字段（合并到返回值，用 标记包裹） + if reasoning: + reasoning = reasoning.encode('utf-8', 'replace').decode('utf-8') + print(f"{Fore.LIGHTBLACK_EX}[深度思考: {reasoning[:500]}{'...' if len(reasoning) > 500 else ''}]{Style.RESET_ALL}") + if ai_response: + return f"{reasoning}{ai_response}" + else: + return f"{reasoning}" + + return ai_response or "" + else: + return f"API 返回格式错误: {response_data}" + elif response.status_code == 401: + return "API 认证失败，请检查 api_key 是否正确" + elif response.status_code == 404: + return f"API 端点不存在，请检查 base_url 是否正确: {api_url}" + elif response.status_code == 400: + return f"API 调用失败: {response.status_code} - {response.text}" + else: + return f"API 调用失败: {response.status_code} - {response.text}" + + except requests.exceptions.ConnectionError: + return f"无法连接到 API 服务: {self.base_url}，请检查服务是否运行" + except Exception as e: + return f"API 调用失败: {str(e)}" + + def _build_messages_with_history(self, system_prompt, user_input): + """构建包含历史记录的消息列表""" + messages = [] + + # 添加系统提示词 + if system_prompt: + clean_prompt = system_prompt.encode('utf-8', 'replace').decode('utf-8') + messages.append({ + "role": "system", + "content": clean_prompt + }) + + # 添加历史对话记录（使用共享历史） + if self.shared_conversation_history is not None: + for msg in self.shared_conversation_history[-self.max_history:]: + if not isinstance(msg, dict) or "role" not in msg: + continue + + role = msg["role"] + + # 普通 user/assistant 消息 + if "content" in msg: + clean_content = msg["content"] + if isinstance(clean_content, str): + clean_content = clean_content.encode('utf-8', 'replace').decode('utf-8') + messages.append({"role": role, "content": clean_content}) + + # 添加当前用户输入 + if user_input: + clean_input = user_input.encode('utf-8', 'replace').decode('utf-8') + messages.append({ + "role": "user", + "content": clean_input + }) + + return messages + + def _call_api_with_history(self, content, system_prompt=None): + """使用对话历史调用 API""" + if not self.base_url: + return "错误: openai 引擎的 base_url 未配置" + + messages = [] + if system_prompt: + messages.append({"role": "system", "content": system_prompt}) + if self.shared_conversation_history is not None: + for msg in self.shared_conversation_history[-self.max_history:]: + if isinstance(msg, dict) and "role" in msg and "content" in msg: + messages.append(msg) + messages.append({"role": "user", "content": content}) + + body = { + "model": self.model, + "messages": messages, + "stream": False + } + + try: + response = requests.post( + url=self._get_api_url(), + json=body, + headers=self._get_headers(), + timeout=None + ) + + if response.status_code == 200: + response_data = response.json() + if "choices" in response_data and len(response_data["choices"]) > 0: + ai_response = response_data["choices"][0]["message"]["content"] + ai_response = ai_response.encode('utf-8', 'replace').decode('utf-8') + return self._process_thinking_content(ai_response) + return f"API 调用失败: {response.status_code} - {response.text}" + except Exception as e: + return f"API 调用失败: {str(e)}" + + def _process_thinking_content(self, response): + """处理思考内容，将思考部分以灰色文本显示""" + import re + + if not self.thinking_start_marker or not self.thinking_end_marker: + return response + + if self.thinking_start_marker in response and self.thinking_end_marker in response: + parts = response.split(self.thinking_start_marker) + if len(parts) > 1: + remaining = parts[1] + if self.thinking_end_marker in remaining: + thinking_part, reply_part = remaining.split(self.thinking_end_marker, 1) + thinking_content = thinking_part.strip() + reply_content = reply_part.strip() + if thinking_content: + print(f"{Fore.LIGHTBLACK_EX}[思考: {thinking_content}]{Style.RESET_ALL}") + # 如果回复内容为空，返回原始 response 而非空字符串（不丢内容） + return reply_content if reply_content else response + + return response + + def _apply_deep_think(self, body: dict) -> dict: + """ + 通用深度思考适配。 + 原生支持的模型用 API 参数，不支持的用提示词模拟。 + """ + model = (self.model or "").lower() + effort = self.reasoning_effort # low / medium / high + + # ── 原生支持：API 参数 ── + + # DeepSeek / MiMo + if "deepseek" in model or "mimo" in model: + body["enable_thinking"] = True + body.pop("temperature", None) + if effort: + body["reasoning_effort"] = effort + return body + + # OpenAI o-series (o1, o3, o4-mini 等) + if model.startswith("o") and (model[1:2].isdigit() or model[1:3] in ("1-", "3-", "4-")): + body["reasoning"] = {"effort": effort} + return body + + # Anthropic Claude (通过 OpenAI 兼容层) + if "claude" in model or "anthropic" in model: + body["thinking"] = {"type": "enabled", "budget_tokens": self._thinking_budget(effort)} + return body + + # Grok + if "grok" in model: + body["thinking"] = {"enabled": True} + return body + + # Gemini thinking 模型 + if "gemini" in model and "thinking" in model: + return body # 模型名自带 thinking，不需要额外参数 + + # ── 不支持原生思考：用提示词模拟 ── + self._inject_thinking_prompt = effort + return body + + @staticmethod + def _thinking_budget(effort: str) -> int: + """思考 token 预算""" + return {"low": 2048, "medium": 8192, "high": 32768}.get(effort, 8192) + + def _get_thinking_prompt(self, effort: str) -> str: + """根据思考等级生成提示词（注入系统提示词末尾）""" + if effort == "low": + return "" + + if effort == "medium": + return ( + "\n\n【思考模式：中等】\n" + "回答前请先逐步思考：\n" + "1. 分析用户的核心需求\n" + "2. 列出关键因素和约束\n" + "3. 考虑可能的方案\n" + "4. 选择最优方案并解释理由\n" + "然后再给出最终回答。" + ) + + # high + return ( + "\n\n【思考模式：深度推理】\n" + "你必须使用结构化深度推理框架回答问题。严格遵循以下步骤：\n\n" + "## 第一步：问题分解\n" + "- 将问题拆解为子问题\n" + "- 识别关键约束和边界条件\n" + "- 明确输入输出要求\n\n" + "## 第二步：多角度分析\n" + "- 从至少 3 个不同角度分析问题\n" + "- 评估每种方案的优缺点\n" + "- 考虑边界情况和异常场景\n\n" + "## 第三步：方案设计\n" + "- 选择最优方案并详细说明理由\n" + "- 给出具体的实现步骤\n" + "- 预判可能的问题并给出预防措施\n\n" + "## 第四步：验证与优化\n" + "- 检验方案是否满足所有约束\n" + "- 考虑是否有更优解\n" + "- 给出最终答案和注意事项\n\n" + "## 输出格式\n" + "先输出推理过程（用 [思考] 标记），再输出最终答案。\n" + "推理过程要详细但不啰嗦，最终答案要简洁明确。" + ) + + def set_model(self, model_name): + """设置模型""" + self.model = model_name + print(f"{Fore.GREEN}已切换模型为: {model_name}{Style.RESET_ALL}") + + def list_models(self): + """列出可用模型（调用 API 的 /models 端点）""" + if not self.base_url: + return ["错误: base_url 未配置"] + + try: + models_url = self.base_url.rstrip('/') + if models_url.endswith('/chat/completions'): + models_url = models_url[:-len('/chat/completions')] + models_url = models_url.rstrip('/') + '/models' + + response = requests.get( + url=models_url, + headers=self._get_headers(), + timeout=10 + ) + + if response.status_code == 200: + data = response.json() + if "data" in data: + models = [m.get("id", "unknown") for m in data["data"]] + return models + else: + return ["API 返回格式不标准，无法解析模型列表"] + else: + return [f"获取模型列表失败: {response.status_code}"] + except Exception as e: + return [f"获取模型列表失败: {str(e)}"] + + def generate_with_tools(self, messages, tools=None, system_prompt=None): + """ + 原生 Function Calling 模式 + 返回 dict: {"content": str, "tool_calls": list, "reasoning_content": str, "raw": dict} + """ + try: + from colorama import Fore, Style + except ImportError: + Fore = Style = type('D', (), {'LIGHTBLACK_EX': '', 'RESET_ALL': ''})() + + import requests + import time + + if system_prompt: + messages = [{"role": "system", "content": system_prompt}] + messages + + body = { + "model": self.model, + "messages": messages, + "stream": False, + "temperature": self.engine_config.get("temperature", 0.7), + } + top_p = self.engine_config.get("top_p") + if top_p is not None: + body["top_p"] = top_p + top_k = self.engine_config.get("top_k") + if top_k is not None: + body["top_k"] = top_k + + if tools: + body["tools"] = tools + body["tool_choice"] = "auto" + + api_url = self._get_api_url() + max_retries = 3 + + for attempt in range(max_retries): + try: + response = requests.post( + url=api_url, json=body, headers=self._get_headers(), timeout=None + ) + + if response.status_code == 200: + response_data = response.json() + if "choices" in response_data and len(response_data["choices"]) > 0: + message = response_data["choices"][0].get("message", {}) + content_text = message.get("content", "") or "" + reasoning = message.get("reasoning_content", "") or "" + tool_calls = message.get("tool_calls", []) + + if reasoning: + print(f"{Fore.LIGHTBLACK_EX}[深度思考: {reasoning[:500]}{'...' if len(reasoning) > 500 else ''}]{Style.RESET_ALL}") + + return { + "content": content_text, + "tool_calls": tool_calls, + "reasoning_content": reasoning, + "raw": response_data + } + else: + return {"content": f"API 返回格式错误", "tool_calls": [], "raw": response_data} + + elif response.status_code >= 500 and attempt < max_retries - 1: + print(f"{Fore.YELLOW}API 返回 {response.status_code}，第 {attempt+1}/{max_retries} 次重试...{Style.RESET_ALL}") + time.sleep(2) + continue + else: + return {"content": f"API 调用失败: {response.status_code}", "tool_calls": [], "raw": {}} + + except requests.exceptions.ConnectionError: + if attempt < max_retries - 1: + print(f"{Fore.YELLOW}连接失败，第 {attempt+1}/{max_retries} 次重试...{Style.RESET_ALL}") + time.sleep(2) + continue + return {"content": f"无法连接到 API: {api_url}", "tool_calls": [], "raw": {}} + except Exception as e: + return {"content": f"引擎调用失败: {e}", "tool_calls": [], "raw": {}} + + return {"content": f"API 调用失败（重试{max_retries}次后仍失败）", "tool_calls": [], "raw": {}} + + def handle_command(self, command): + """处理引擎特定命令""" + if command == "models": + models = self.list_models() + print(f"{Fore.GREEN}可用模型列表:{Style.RESET_ALL}") + for model in models: + status = " (当前使用)" if model == self.model else "" + print(f"{Fore.GREEN} - {model}{status}{Style.RESET_ALL}") + return True + + elif command.startswith("set "): + model_name = command[4:].strip() + if model_name: + self.set_model(model_name) + return True + else: + print(f"{Fore.RED}请提供模型名称. 用法: /engine.openai set <模型名>{Style.RESET_ALL}") + return False + + elif command == "info": + print(f"{Fore.GREEN}OpenAI 兼容引擎配置:{Style.RESET_ALL}") + print(f" base_url: {self.base_url}") + print(f" model: {self.model}") + print(f" api_key: {'已设置' if self.api_key else '未设置'}") + print(f" deep_think: {'开启' if self.deep_think else '关闭'}") + if self.deep_think: + print(f" reasoning: {self.reasoning_effort}") + return True + + elif command.startswith("think"): + # /engine.openai think [on|off|low|medium|high] + arg = command.replace("think", "").strip().lower() + if arg in ("off", "0", "false"): + self.deep_think = False + print(f"{Fore.YELLOW}深度思考已关闭{Style.RESET_ALL}") + elif arg in ("on", "1", "true", ""): + self.deep_think = True + print(f"{Fore.GREEN}深度思考已开启 (reasoning_effort: {self.reasoning_effort}){Style.RESET_ALL}") + elif arg in ("low", "medium", "high"): + self.deep_think = True + self.reasoning_effort = arg + print(f"{Fore.GREEN}深度思考已开启 (reasoning_effort: {arg}){Style.RESET_ALL}") + else: + print(f"{Fore.RED}用法: /engine.openai think [on|off|low|medium|high]{Style.RESET_ALL}") + return True + + else: + print(f"{Fore.RED}未知命令. 可用: models, set, info, think{Style.RESET_ALL}") + return False diff --git a/core/__init__.py b/core/__init__.py new file mode 100644 index 0000000..2691046 --- /dev/null +++ b/core/__init__.py @@ -0,0 +1,2 @@ +"""xiaoli-cli 3.0.0 核心""" +from .app import XiaoliCLI diff --git a/core/app.py b/core/app.py new file mode 100644 index 0000000..14cf6fb --- /dev/null +++ b/core/app.py @@ -0,0 +1,274 @@ +"""xiaoli-cli 7.0.0 主类""" +import os, sys, json, importlib +from datetime import datetime + +from .types import ToolCall, ToolResult +from .history import History +from .safety import Safety +from .display import Display +from .engine import EngineAdapter +from .runner import Runner + + +class XiaoliCLI: + def __init__(self): + self.shared_conversation_history = [] + self.max_history = 999999 + self.current_engine = None + self.engines = {} + self.engine_name = "openai" + self.liugin_manager = None + self.tools = [] + self.liugin_commands = {} + self.chat_dir = "chat_history" + self.memory_manager = None + + self._load_config() + self._load_engines() + self._load_plugins() + self._init_memory() + self._init_core() + self._register_commands() + print("xiaoli-cli 7.0.0 初始化完成") + + def _load_config(self): + try: + from xcli_core.config import get_system_config + self.engine_name = get_system_config("default_engine", "openai") + except Exception: + self.engine_name = "openai" + + def _load_engines(self): + print("正在加载AI引擎...") + d = os.path.join(os.path.dirname(os.path.dirname(__file__)), "ai_engines") + if not os.path.isdir(d): + return + for fn in os.listdir(d): + if fn.endswith("_engine.py") and not fn.startswith("__"): + mn = fn[:-3] + try: + mod = importlib.import_module(f"ai_engines.{mn}") + for an in dir(mod): + obj = getattr(mod, an) + if isinstance(obj, type) and an.endswith("AI") and hasattr(obj, "generate_response"): + eng = obj() + eng.cli = self + eng.shared_conversation_history = self.shared_conversation_history + self.engines[eng.name] = eng + print(f" 已加载: {eng.name} ({an})") + except Exception as e: + print(f" [ERROR] {mn}: {e}") + if self.engine_name not in self.engines and self.engines: + self.engine_name = list(self.engines.keys())[0] + self.current_engine = self.engines.get(self.engine_name) + print(f" 共 {len(self.engines)} 个引擎，当前: {self.engine_name}") + + def _load_plugins(self): + print("正在加载插件...") + try: + from unified_tool_manager import UnifiedToolManager + self.liugin_manager = UnifiedToolManager(self) + pd = os.path.join(os.path.dirname(os.path.dirname(__file__)), "plugins") + sd = os.path.join(os.path.dirname(os.path.dirname(__file__)), "skills") + self.liugin_manager.initialize(pd, sd) + self.tools = self.liugin_manager.tools if hasattr(self.liugin_manager, "tools") else [] + print(f" 已加载 {len(self.tools)} 个插件") + except Exception as e: + print(f" [ERROR] 插件加载失败: {e}") + import traceback; traceback.print_exc() + + def _init_memory(self): + try: + from xcli_core.memory import MemoryManager + self.memory_manager = MemoryManager(self) + except Exception: + pass + + def _init_core(self): + self.history = History(self.max_history) + self.safety = Safety(self, lambda: self.current_engine) + self.display = Display() + self.engine_adapter = EngineAdapter(self.current_engine) + self.runner = Runner(self.engine_adapter, self.liugin_manager, + self.history, self.safety, self.display) + self.runner.set_prompt_builder(self._build_prompt) + + def _build_prompt(self): + p = '你叫小狸，是一个强大的智能编程助手。\n\n' + p += '【工具调用】\n当你需要执行操作时，直接调用工具。\n工具执行后，根据结果继续回复或调用下一个工具。\n\n' + p += '【补充回复】\n如果你需要补充之前的回复，输出：\n' + p += '{"action": "continue", "content": "要补充的内容"}\n\n' + p += '【核心工具】\n' + p += '1. code_editor - 代码编辑\n2. code_search - 代码搜索\n3. git_tools - Git\n' + p += '4. cmd_executor - Shell命令\n5. file_manager - 文件管理\n6. browser_auto - 浏览器\n' + p += '7. sub_agent - 子Agent\n8. auto_engineer - 工程化\n9. network_tools - 网络\n' + p += '10. ai_search - 网页内容 (url/search/web)\n\n' + p += '说话时可适当加nyan表现可爱性格。' + return p + + def register_liugin_command(self, name, handler): + self.liugin_commands[name] = handler + + def process_conversation(self, user_input): + return self.runner.run(user_input) + + def switch_engine(self, name): + if name in self.engines: + self.engine_name = name + self.current_engine = self.engines[name] + self.current_engine.shared_conversation_history = self.shared_conversation_history + self.engine_adapter = EngineAdapter(self.current_engine) + self.runner.set_engine(self.engine_adapter) + self.safety._engine = lambda: self.current_engine + try: + from xcli_core.config import set_system_config + set_system_config("default_engine", name) + except Exception: + pass + return f"已切换到: {name}" + return f"引擎 {name} 不存在" + + def _register_commands(self): + self._commands = { + "/help": self._cmd_help, + "/engine": self._cmd_engine, + "/mode": self._cmd_mode, + "/clear": self._cmd_clear, + "/history": self._cmd_history, + "/tools": self._cmd_tools, + "/exit": self._cmd_exit, + "/quit": self._cmd_exit, + "/save": self._cmd_save, + "/config": self._cmd_config, + "/new": self._cmd_new, + } + + def handle_command(self, user_input): + parts = user_input.strip().split(None, 1) + cmd = parts[0].lower().lstrip("/") + args = parts[1] if len(parts) > 1 else "" + h = self._commands.get("/" + cmd) + if h: + return h(args) + if cmd in self.liugin_commands: + try: + r = self.liugin_commands[cmd](args) + if r: print(r) + except Exception as e: + print(f"命令失败: {e}") + return "" + return None + + def _cmd_help(self, a): + return "\n".join(["/help - 帮助", "/engine [list|] - 引擎", + "/mode [0-3] - 安全模式", "/clear - 清空历史", + "/history - 历史", "/tools - 工具", "/save - 保存", + "/new - 新对话", "/config - 配置", "/exit - 退出"]) + + def _cmd_engine(self, a): + if not a or a == "list": + lines = [f"当前: {self.engine_name}", "可用:"] + for n in self.engines: + lines.append(f" {n}{' <==' if n == self.engine_name else ''}") + return "\n".join(lines) + return self.switch_engine(a) + + def _cmd_mode(self, a): + if not a: return f"当前模式: {self.safety.get_mode()}" + try: + m = int(a) + self.safety.set_mode(m) + names = {0: "无限制", 1: "普通", 2: "人工", 3: "计划"} + return f"已切换: {names.get(m, '未知')}" + except ValueError: + return "用法: /mode [0-3]" + + def _cmd_clear(self, a): + self.history.clear() + self.shared_conversation_history.clear() + return "已清空" + + def _cmd_history(self, a): + msgs = self.history.snapshot() + if not msgs: return "无历史" + lines = [f"共 {len(msgs)} 条:"] + for m in msgs[-10:]: + c = m.content[:50] + "..." if len(m.content) > 50 else m.content + lines.append(f" [{m.role}] {c}") + return "\n".join(lines) + + def _cmd_tools(self, a): + if not self.tools: return "无工具" + lines = [f"共 {len(self.tools)} 个:"] + for t in self.tools: + lines.append(f" {t.get('name','')}: {t.get('description','')[:60]}") + return "\n".join(lines) + + def _cmd_save(self, a): + try: + os.makedirs(self.chat_dir, exist_ok=True) + ts = datetime.now().strftime("%Y%m%d_%H%M%S") + fp = os.path.join(self.chat_dir, f"{ts}_chat.json") + msgs = self.history.snapshot() + data = [{"role": m.role, "content": m.content} for m in msgs] + with open(fp, "w", encoding="utf-8") as f: + json.dump(data, f, ensure_ascii=False, indent=2) + return f"已保存: {fp}" + except Exception as e: + return f"失败: {e}" + + def _cmd_new(self, a): + self._cmd_save("") + self.history.clear() + self.shared_conversation_history.clear() + return "新对话" + + def _cmd_config(self, a): + try: + with open("config.json", "r", encoding="utf-8") as f: + return json.dumps(json.load(f), ensure_ascii=False, indent=2)[:1000] + except Exception as e: + return f"失败: {e}" + + def _cmd_exit(self, a): + self._cmd_save("") + return "__EXIT__" + + def run(self): + try: + from colorama import init, Fore, Style + init() + except ImportError: + class _D: + CYAN = GREEN = YELLOW = RESET_ALL = '' + Fore = Style = _D() + print() + print(f" {Fore.CYAN}+========================================+{Style.RESET_ALL}") + print(f" {Fore.CYAN}| xiaoli-cli 7.0.0 (重构版) |{Style.RESET_ALL}") + print(f" {Fore.CYAN}| 小狸 AI 编程助手 |{Style.RESET_ALL}") + print(f" {Fore.CYAN}+========================================+{Style.RESET_ALL}") + print() + print(f" 引擎: {Fore.GREEN}{self.engine_name}{Style.RESET_ALL if hasattr(Style,'RESET_ALL') else ''}") + print(f" 工具: {Fore.GREEN}{len(self.tools)}{Style.RESET_ALL if hasattr(Style,'RESET_ALL') else ''} 个插件") + print(f" FC: {'支持' if self.engine_adapter.supports_fc() else '不支持'}") + print(f" 输入 /help 查看命令") + print() + while True: + try: + ui = input(f"{Fore.CYAN}[用户ID: xiaoli]{Style.RESET_ALL if hasattr(Style,'RESET_ALL') else ''} ").strip() + if not ui: continue + if ui.startswith("/"): + r = self.handle_command(ui) + if r == "__EXIT__": + print(f" {Fore.YELLOW}再见~{Style.RESET_ALL if hasattr(Style,'RESET_ALL') else ''}") + break + if r: print(r) + continue + self.process_conversation(ui) + print() + except KeyboardInterrupt: + print(f"\n {Fore.YELLOW}(Ctrl+C, /exit退出){Style.RESET_ALL if hasattr(Style,'RESET_ALL') else ''}") + except EOFError: + break + except Exception as e: + print(f" {Fore.RED}错误: {e}{Style.RESET_ALL if hasattr(Style,'RESET_ALL') else ''}") diff --git a/core/display.py b/core/display.py new file mode 100644 index 0000000..08ff021 --- /dev/null +++ b/core/display.py @@ -0,0 +1,44 @@ +"""显示输出""" +import sys + +try: + from colorama import Fore, Style, init + init() +except ImportError: + class _D: + CYAN = GREEN = YELLOW = RED = LIGHTBLACK_EX = RESET_ALL = '' + Fore = Style = _D() + + +class Display: + def text(self, text, is_continue=False): + if text: + print(text) + + def thinking(self, text): + if text: + t = text[:500] + "..." if len(text) > 500 else text + print(f"{Style.LIGHTBLACK_EX if hasattr(Style,'LIGHTBLACK_EX') else Fore.LIGHTBLACK_EX}[深度思考: {t}]{Style.RESET_ALL}") + + def tool_start(self, tc): + args = tc.args[:80] + "..." if len(tc.args) > 80 else tc.args + print(f" {Fore.GREEN}OK 工具:{Fore.RESET_ALL if hasattr(Fore,'RESET_ALL') else Style.RESET_ALL} {tc.name}") + print(f" {Fore.CYAN}参数:{Style.RESET_ALL} {args}") + + def tool_result(self, tc, result): + text = result.data if result.data is not None else result.error_message + if text: + s = str(text) + if len(s) > 2000: + lines = s.split("\n") + if len(lines) > 30: + s = "\n".join(lines[:30]) + f"\n... (共{len(lines)}行)" + print(f" {Fore.CYAN}结果:{Style.RESET_ALL}") + for line in s.split("\n"): + print(f" {line}") + + def info(self, msg): + print(f"{Fore.YELLOW}{msg}{Style.RESET_ALL}") + + def error(self, msg): + print(f"{Fore.RED}{msg}{Style.RESET_ALL}") diff --git a/core/engine.py b/core/engine.py new file mode 100644 index 0000000..4edb876 --- /dev/null +++ b/core/engine.py @@ -0,0 +1,170 @@ +"""引擎适配 — FC为主，prompt-JSON保底""" +import json, re, uuid +from .types import EngineResponse, ToolCall + + +class EngineAdapter: + def __init__(self, engine): + self._engine = engine + self._fc = hasattr(engine, 'generate_with_tools') + + def supports_fc(self): + return self._fc + + def name(self): + return getattr(self._engine, 'name', 'unknown') + + def generate(self, messages, tools=None, system_prompt=None): + if self._fc and tools: + return self._gen_fc(messages, tools, system_prompt) + return self._gen_legacy(messages, system_prompt) + + def _gen_fc(self, messages, tools, system_prompt): + try: + raw = self._engine.generate_with_tools(messages, tools, system_prompt=system_prompt) + text = "" + thinking = "" + tool_calls = None + if isinstance(raw, dict): + text = raw.get("content", "") or "" + thinking = raw.get("reasoning_content", "") or "" + tc_list = raw.get("tool_calls", []) or [] + if tc_list: + tool_calls = [] + for tc in tc_list: + func = tc.get("function", {}) + cid = tc.get("id", str(uuid.uuid4())[:8]) + name = func.get("name", "") + args_str = func.get("arguments", "{}") + arguments = None + try: + if isinstance(args_str, str) and args_str: + arguments = json.loads(args_str) + except json.JSONDecodeError: + pass + args = self._to_legacy(name, arguments) if arguments else (args_str or "") + tool_calls.append(ToolCall(id=cid, name=name, args=args, + arguments=arguments, raw=tc)) + return EngineResponse(text=text, thinking=thinking, tool_calls=tool_calls, raw=raw) + except Exception as e: + return EngineResponse(text=f"引擎调用失败: {e}") + + def _gen_legacy(self, messages, system_prompt): + user_input = "" + for msg in reversed(messages): + if msg.get("role") == "user": + user_input = msg.get("content", "") + break + try: + resp = self._engine.generate_response(user_input, system_prompt=system_prompt) + except Exception as e: + return EngineResponse(text=f"引擎调用失败: {e}") + if not resp: + return EngineResponse() + text, thinking = self._strip_thinking(resp) + return EngineResponse(text=text, thinking=thinking, raw=resp) + + def _strip_thinking(self, text): + if not text: + return "", "" + thinking = "" + if "" in text and "" in text: + m = re.search(r'(.*?)(.*)', text, re.DOTALL) + if m: + thinking = m.group(1).strip() + text = m.group(2).strip() + start = getattr(self._engine, 'thinking_start_marker', None) + end = getattr(self._engine, 'thinking_end_marker', None) + if start and end and start in text and end in text: + parts = text.split(start) + if len(parts) >= 2: + rest = parts[1] + if end in rest: + tp, rp = rest.split(end, 1) + thinking = (thinking + "\n" + tp.strip()).strip() if thinking else tp.strip() + text = (parts[0] + rp).strip() + return text, thinking + + def _to_legacy(self, tool_name, args): + """FC dict参数 → 旧插件字符串参数""" + if not args: + return "" + if tool_name == "ai_search": + url = args.get("url", "") + q = args.get("query", args.get("search", "")) + if url: return f"url {url}" + if q: return f"search {q}" + if tool_name == "network_tools": + op = args.get("operation", args.get("op", "get")) + t = args.get("target", args.get("url", args.get("host", ""))) + if op and t: return f"{op} {t}" + if tool_name == "code_editor": + op = args.get("operation", args.get("action", "")) + fp = args.get("file", args.get("path", args.get("filename", ""))) + ct = args.get("content", args.get("text", args.get("code", ""))) + old = args.get("old", args.get("old_code", args.get("find", ""))) + new = args.get("new", args.get("new_code", args.get("replace", ""))) + ln = args.get("line", args.get("line_number", "")) + sl = args.get("start", args.get("start_line", "")) + el = args.get("end", args.get("end_line", "")) + pat = args.get("pattern", args.get("file_pattern", "")) + d = args.get("directory", args.get("dir", ".")) + if op == "create" and fp and ct: return f"create {fp}\n{ct}" + if op == "write" and fp and ct: return f"write {fp}\n{ct}" + if op == "append" and fp and ct: return f"append {fp}\n{ct}" + if op in ("read_range", "read"): return f"read_range {fp} {sl or 1} {el or 50}" + if op == "edit": return f"edit {fp}\n{old}\n<<<>>>\n{new}" + if op == "insert": return f"insert {fp} {ln}\n{ct}" + if op in ("find", "search"): return f"find {pat} {d}" + if op == "syntax_check": return f"syntax_check {fp}" + return json.dumps(args, ensure_ascii=False) + if tool_name == "code_search": + op = args.get("operation", "find") + pat = args.get("pattern", args.get("query", args.get("search", ""))) + d = args.get("directory", args.get("dir", ".")) + return f"{op} {pat} {d}" + if tool_name == "git_tools": + op = args.get("operation", "status") + a = args.get("args", "") + return f"{op} {a}" if a else op + if tool_name == "cmd_executor": + return args.get("command", args.get("cmd", args.get("shell", ""))) + if tool_name == "file_manager": + op = args.get("operation", args.get("action", "list")) + p = args.get("path", args.get("file", ".")) + ct = args.get("content", args.get("text", "")) + if op in ("read", "list", "info"): return f"{op} {p}" + if op == "write" and ct: return f'write {p} -c "{ct}"' + if op == "append" and ct: return f'append {p} -c "{ct}"' + if op and p: return f"{op} {p}" + if tool_name == "browser_auto": + op = args.get("operation", "") + url = args.get("url", "") + if op == "open" and url: return f"open {url}" + if tool_name == "auto_engineer": + op = args.get("operation", "") + t = args.get("target", args.get("path", "")) + if op and t: return f"{op} {t}" + return op + if tool_name == "sub_agent": + op = args.get("operation", "list") + if op == "create": + task = args.get("task", args.get("prompt", "")) + return f"create {task}" + return op + if tool_name in ("task_manager", "scheduler"): + return args.get("operation", "list") + # 通用 + if "operation" in args: + op = args["operation"] + rest = " ".join(str(v) for k, v in args.items() if k != "operation") + return f"{op} {rest}".strip() + return " ".join(str(v) for v in args.values()) + + def handle_command(self, cmd): + if hasattr(self._engine, 'handle_command'): + return self._engine.handle_command(cmd) + return False + + def get_raw(self): + return self._engine diff --git a/core/history.py b/core/history.py new file mode 100644 index 0000000..894ad22 --- /dev/null +++ b/core/history.py @@ -0,0 +1,84 @@ +"""线程安全对话历史""" +import json +import threading +from .types import Message + + +class History: + def __init__(self, max_size=999999): + self._msgs = [] + self._lock = threading.RLock() + self._max = max_size + + def add_user(self, text): + with self._lock: + self._msgs.append(Message("user", text)) + self._trim() + + def add_assistant(self, text, tool_calls=None): + with self._lock: + m = Message("assistant", text) + if tool_calls: + m.tool_calls = tool_calls + self._msgs.append(m) + self._trim() + + def add_tool(self, call_id, name, result): + with self._lock: + self._msgs.append(Message("tool", result, tool_call_id=call_id, name=name)) + self._trim() + + def add_cancel(self, name, args): + with self._lock: + self._msgs.append(Message("user", f"工具 {name} 已取消。参数: {args}")) + self._trim() + + def _trim(self): + if len(self._msgs) > self._max: + self._msgs = self._msgs[-self._max:] + + def render(self, system_prompt="", current=None, fc=False): + """渲染为消息列表。fc=True 用 role:tool，否则工具结果用 role:user""" + with self._lock: + result = [] + if system_prompt: + result.append({"role": "system", "content": system_prompt}) + for m in self._msgs: + if m.role == "tool" and not fc: + result.append({"role": "user", "content": m.content}) + else: + entry = {"role": m.role, "content": m.content} + if fc and m.role == "tool" and m.tool_call_id: + entry["tool_call_id"] = m.tool_call_id + if m.name: + entry["name"] = m.name + if fc and m.role == "assistant" and m.tool_calls: + # content 为空时设为 None（OpenAI 规范：有 tool_calls 时 content 可为 null） + if not entry.get("content"): + entry["content"] = None + # arguments 必须是 JSON 字符串（OpenAI 规范） + entry["tool_calls"] = [ + {"id": tc.id, "type": "function", + "function": { + "name": tc.name, + "arguments": json.dumps(tc.arguments, ensure_ascii=False) if tc.arguments + else json.dumps({"args": tc.args}, ensure_ascii=False) + }} + for tc in m.tool_calls + ] + result.append(entry) + if current: + result.append({"role": "user", "content": current}) + return result + + def snapshot(self): + with self._lock: + return list(self._msgs) + + def clear(self): + with self._lock: + self._msgs.clear() + + def __len__(self): + with self._lock: + return len(self._msgs) diff --git a/core/parser.py b/core/parser.py new file mode 100644 index 0000000..ef1fe0c --- /dev/null +++ b/core/parser.py @@ -0,0 +1,146 @@ +"""JSON解析 — 保底方案""" +import json, re, uuid +from .types import ToolCall, Plan + + +def parse_prompt_json(text): + """解析prompt-JSON，返回 (text_content, tool_calls_or_None)""" + text = text.strip() + json_str = _extract_json(text) + if json_str is None: + return text, None + try: + data = json.loads(json_str) + except json.JSONDecodeError: + return text, None + idx = text.find(json_str) + prefix = text[:idx].strip() if idx > 0 else "" + if isinstance(data, list): + calls = [c for c in (_make(c) for c in data) if c] + return prefix, calls if calls else None + if isinstance(data, dict): + c = _make(data) + if c: + return prefix, [c] + return prefix, data + return text, None + + +def _extract_json(text): + """平衡括号扫描""" + depth = 0 + start = -1 + in_str = False + esc = False + for i, c in enumerate(text): + if esc: + esc = False + continue + if c == '\\' and in_str: + esc = True + continue + if c == '"' and not esc: + in_str = not in_str + continue + if in_str: + continue + if c == '{': + if depth == 0: + start = i + depth += 1 + elif c == '}': + depth -= 1 + if depth == 0 and start != -1: + candidate = text[start:i+1] + if '"action"' in candidate or '"tool"' in candidate: + return candidate + start = -1 + elif c == '[' and depth == 0: + bd = 1 + j = i + 1 + in_s = False + e2 = False + while j < len(text) and bd > 0: + cj = text[j] + if e2: + e2 = False + elif cj == '\\' and in_s: + e2 = True + elif cj == '"' and not e2: + in_s = not in_s + elif not in_s: + if cj == '[': bd += 1 + elif cj == ']': bd -= 1 + j += 1 + if bd == 0: + candidate = text[i:j] + if '"action"' in candidate or '"tool"' in candidate: + return candidate + return None + + +def _make(data): + """dict → ToolCall""" + if not isinstance(data, dict): + return None + cid = data.get("id", str(uuid.uuid4())[:8]) + name = "" + args = "" + arguments = None + if data.get("action") == "use_tool": + name = data.get("tool", data.get("name", "")) + ra = data.get("args", data.get("arguments", "")) + if isinstance(ra, str): args = ra + elif isinstance(ra, dict): + arguments = ra + args = json.dumps(ra, ensure_ascii=False) + else: args = str(ra) + elif "name" in data and "arguments" in data: + name = data["name"] + ra = data["arguments"] + if isinstance(ra, str): + args = ra + try: arguments = json.loads(ra) + except: pass + elif isinstance(ra, dict): + arguments = ra + args = json.dumps(ra, ensure_ascii=False) + elif "tool" in data and "args" in data: + name = data["tool"] + ra = data["args"] + if isinstance(ra, str): args = ra + elif isinstance(ra, dict): + arguments = ra + args = json.dumps(ra, ensure_ascii=False) + else: + return None + if not name: + return None + return ToolCall(id=cid, name=name, args=args, arguments=arguments, raw=data) + + +def interpret(resp, fc_mode): + """EngineResponse → Plan""" + # FC模式 + if fc_mode and resp.tool_calls: + return Plan(action="use_tool", text=resp.text or "", tool_calls=resp.tool_calls) + # prompt-JSON + text, parsed = parse_prompt_json(resp.text) + if parsed is None: + return Plan(action="final", text=resp.text) + if isinstance(parsed, list): + return Plan(action="use_tool", text=text, tool_calls=parsed) + if isinstance(parsed, dict): + action = parsed.get("action", "") + if action == "use_tool": + c = _make(parsed) + if c: + return Plan(action="use_tool", text=text, tool_calls=[c]) + return Plan(action="final", text=resp.text) + if action == "continue" or parsed.get("continue"): + msg = parsed.get("content", parsed.get("message", "")) + return Plan(action="continue", text=msg or text) + if "message" in parsed: + return Plan(action="final", text=parsed["message"]) + return Plan(action="final", text=text or resp.text) + return Plan(action="final", text=resp.text) diff --git a/core/runner.py b/core/runner.py new file mode 100644 index 0000000..17c5c4f --- /dev/null +++ b/core/runner.py @@ -0,0 +1,146 @@ +"""对话循环 — 唯一循环，无重复""" +import threading +from datetime import datetime +from .types import ToolCall, ToolResult +from xcli_core.tool_result import ErrorCode +from .parser import interpret + + +class Runner: + def __init__(self, engine, manager, history, safety, display): + self._engine = engine # EngineAdapter + self._mgr = manager # UnifiedToolManager + self._history = history # History + self._safety = safety # Safety + self._display = display # Display + self._cancel = threading.Event() + self._max_rounds = 50 + self._prompt_builder = None + + def set_prompt_builder(self, b): + self._prompt_builder = b + + def set_engine(self, e): + self._engine = e + + def run(self, user_input): + self._history.add_user(user_input) + self._cancel.clear() + return self._loop(user_input) + + def _loop(self, seed): + rounds = 0 + current = seed + fc = self._engine.supports_fc() + final_text = "" + + while rounds < self._max_rounds: + rounds += 1 + if self._cancel.is_set(): + self._display.info("(用户取消)") + break + + # 系统提示词 + sp = self._prompt_builder() if self._prompt_builder else "" + if not fc: + sp = (sp + "\n" + self._mgr.get_tools_prompt()) if sp else self._mgr.get_tools_prompt() + + # 生成 + if fc: + msgs = self._history.render(sp, current, fc=True) + tools = self._get_tools() + else: + msgs = self._history.render(sp, current, fc=False) + tools = None + + resp = self._engine.generate(msgs, tools, sp) + + if resp.thinking: + self._display.thinking(resp.thinking) + + # 空响应 + if not resp.text and not resp.tool_calls: + break + + # 解释 + plan = interpret(resp, fc) + + # 显示+历史 + if plan.text: + self._history.add_assistant(plan.text) + self._display.text(plan.text) + + if plan.action == "final": + final_text = plan.text + break + if plan.action == "continue": + current = None + continue + if plan.action == "use_tool": + results = self._exec_tools(plan.tool_calls, fc) + if results is None: + break + current = None + continue + else: + self._display.info(f"(达到最大轮数{self._max_rounds})") + + return final_text + + def _exec_tools(self, calls, fc): + if self._cancel.is_set(): + for tc in calls: + self._history.add_cancel(tc.name, tc.args) + return None + + results = [] + for tc in calls: + r = self._exec_one(tc) + results.append((tc, r)) + + now = datetime.now().strftime("%Y-%m-%d %H:%M:%S") + if fc: + self._history.add_assistant("", tool_calls=calls) + for tc, r in results: + text = r.data if r.data is not None else (r.error_message or "") + self._history.add_tool(tc.id, tc.name, str(text or "")) + else: + if len(results) == 1: + tc, r = results[0] + text = r.data if r.data is not None else (r.error_message or "") + self._history.add_user(f"工具调用结果 (时间: {now}):\n{text}") + else: + parts = [f"工具{i+1}结果:\n{r.data if r.data is not None else (r.error_message or '')}" + for i, (tc, r) in enumerate(results)] + self._history.add_user(f"批量工具结果 (时间: {now}):\n" + "\n".join(parts)) + return results + + def _exec_one(self, tc): + if self._cancel.is_set(): + return ToolResult.fail("用户取消", code=ErrorCode.NOT_IMPLEMENTED, tool_name=tc.name) + allowed, reason = self._safety.check(tc) + if not allowed: + return ToolResult.fail(f"被拒绝: {reason}", code=ErrorCode.PERMISSION_DENIED, tool_name=tc.name) + self._display.tool_start(tc) + r = self._mgr.execute(tc.name, tc.args) + self._display.tool_result(tc, r) + return r + + def _get_tools(self): + """生成FC工具定义""" + defs = [] + for tool in self._mgr.tools: + mcp = tool.get("mcp_definition") + if mcp: + defs.append({"type": "function", "function": { + "name": mcp.get("name", tool.get("name", "")), + "description": mcp.get("description", tool.get("description", "")), + "parameters": mcp.get("inputSchema", {"type": "object", "properties": {}}) + }}) + else: + defs.append({"type": "function", "function": { + "name": tool.get("name", ""), + "description": tool.get("description", ""), + "parameters": {"type": "object", "properties": {}} + }}) + return defs diff --git a/core/safety.py b/core/safety.py new file mode 100644 index 0000000..8a4caaf --- /dev/null +++ b/core/safety.py @@ -0,0 +1,137 @@ +"""安全检查""" +import json, re, threading +from .types import ToolCall + +MODE_UNRESTRICTED = 0 +MODE_NORMAL = 1 +MODE_MANUAL = 2 +MODE_PLAN = 3 + +WHITELIST = { + "code_editor": ["read_range", "find ", "regex ", "symbols", "imports", "stats", + "structure", "context", "todo", "diff "], + "git_tools": ["status", "log", "diff", "branch", "remote", "show", "blame"], + "file_manager": ["list", "read", "info", "search"], + "ai_search": ["url ", "search ", "web "], + "network_tools": ["ping", "status", "headers"], + "code_search": ["find", "regex", "symbols"], + "task_manager": ["list"], + "sub_agent": ["list", "status"], + "auto_engineer": ["metrics", "security", "complexity", "suggest"], +} + + +class Safety: + def __init__(self, cli=None, engine_provider=None): + self._cli = cli + self._engine = engine_provider or (lambda: None) + self._lock = threading.Lock() + self._cache = {} + try: + from xcli_core.config import get_system_config + self.mode = get_system_config("safety_mode", MODE_NORMAL) + except Exception: + self.mode = MODE_NORMAL + + def check(self, tool_call): + """返回 (allowed, reason)""" + # 白名单 + patterns = WHITELIST.get(tool_call.name, []) + args_lower = tool_call.args.strip().lower() + for p in patterns: + if args_lower.startswith(p.lower()): + return True, "白名单放行" + + # 无限制/计划模式 + if self.mode in (MODE_UNRESTRICTED, MODE_PLAN): + return True, "模式自动放行" + + # 人工模式 + if self.mode == MODE_MANUAL: + return self._confirm(tool_call) + + # 普通模式：AI分析 + return self._ai_analyze(tool_call) + + def _ai_analyze(self, tool_call): + engine = self._engine() + if not engine: + return self._confirm(tool_call) + + key = f"{tool_call.name}:{tool_call.args[:100]}" + with self._lock: + if key in self._cache: + cached = self._cache[key] + if cached.get("safe"): + return True, "AI分析通过(缓存)" + return self._confirm(tool_call) + + prompt = f"""分析工具调用的安全性。只返回JSON： +{{"safe": true/false, "level": "低/中/高", "reason": "原因"}} + +工具: {tool_call.name} +参数: {tool_call.args[:200]} + +safe=true: 读取/查看/无害操作 +safe=false: 删除/执行命令/修改配置""" + + try: + resp = engine.generate_response(prompt, system_prompt="只返回JSON") + result = self._parse(resp) + if result: + with self._lock: + self._cache[key] = result + if result.get("safe") is True: + return True, "AI分析通过" + return self._confirm(tool_call) + except Exception: + pass + return self._confirm(tool_call) + + def _parse(self, resp): + if not resp: + return None + resp = resp.strip() + # 去thinking + if "" in resp: + resp = resp.split("")[-1].strip() + # 去markdown + if resp.startswith("```"): + resp = resp.split("\n", 1)[-1] if "\n" in resp else resp[3:] + if resp.endswith("```"): + resp = resp[:-3] + try: + return json.loads(resp.strip()) + except json.JSONDecodeError: + m = re.search(r'\{.*?"safe".*?\}', resp, re.DOTALL) + if m: + try: + return json.loads(m.group()) + except json.JSONDecodeError: + pass + return None + + def _confirm(self, tool_call): + try: + from colorama import Fore, Style + except ImportError: + Fore = Style = type('D', (), {'RED': '', 'CYAN': '', 'YELLOW': '', 'RESET_ALL': ''})() + print(f" {Fore.RED}工具: {tool_call.name}{Style.RESET_ALL}") + print(f" {Fore.CYAN}参数: {tool_call.args[:100]}{Style.RESET_ALL}") + try: + choice = input(f" {Fore.YELLOW}是否执行? (y/n): {Style.RESET_ALL}").strip().lower() + allowed = choice in ('y', 'yes', '是') + return allowed, "用户确认" if allowed else "用户拒绝" + except (EOFError, KeyboardInterrupt): + return True, "非交互模式自动放行" + + def get_mode(self): + return self.mode + + def set_mode(self, mode): + self.mode = mode + try: + from xcli_core.config import set_system_config + set_system_config("safety_mode", mode) + except Exception: + pass diff --git a/core/types.py b/core/types.py new file mode 100644 index 0000000..7c933ac --- /dev/null +++ b/core/types.py @@ -0,0 +1,37 @@ +"""核心数据类型""" +from dataclasses import dataclass, field +from typing import Any, Optional +from xcli_core.tool_result import ToolResult + + +@dataclass +class ToolCall: + id: str + name: str + args: str + arguments: Optional[dict] = None + raw: dict = field(default_factory=dict) + + +@dataclass +class EngineResponse: + text: str = "" + thinking: str = "" + tool_calls: Optional[list] = None + raw: Any = None + + +@dataclass +class Plan: + action: str = "final" # final | continue | use_tool + text: str = "" + tool_calls: list = field(default_factory=list) + + +@dataclass +class Message: + role: str # system | user | assistant | tool + content: str + tool_call_id: Optional[str] = None + tool_calls: Optional[list] = None + name: Optional[str] = None diff --git a/logger.py b/logger.py new file mode 100644 index 0000000..a6a9bf4 --- /dev/null +++ b/logger.py @@ -0,0 +1,47 @@ +""" +增强日志记录模块 +提供结构化日志记录功能 +""" +import logging +import os +from datetime import datetime + +def setup_logger(): + """设置日志记录器""" + # 创建logs目录 + log_dir = os.path.join(os.path.dirname(__file__), 'logs') + if not os.path.exists(log_dir): + os.makedirs(log_dir) + + # 创建日志文件名 + log_file = os.path.join(log_dir, f"app_{datetime.now().strftime('%Y%m%d')}.log") + + # 配置日志记录器 + logging.basicConfig( + level=logging.INFO, + format='%(asctime)s - %(levelname)s - %(message)s', + handlers=[ + logging.FileHandler(log_file, encoding='utf-8'), + logging.StreamHandler() # 同时输出到控制台 + ] + ) + + return logging.getLogger(__name__) + +# 全局日志记录器 +logger = setup_logger() + +def log_error(operation, error, user_id=None): + """记录错误日志""" + user_info = f" [用户ID: {user_id}]" if user_id else "" + logger.error(f"{operation} 失生错误{user_info}: {str(error)}") + +def log_info(operation, message, user_id=None): + """记录信息日志""" + user_info = f" [用户ID: {user_id}]" if user_id else "" + logger.info(f"{operation}{user_info}: {message}") + +def log_warning(operation, message, user_id=None): + """记录警告日志""" + user_info = f" [用户ID: {user_id}]" if user_id else "" + logger.warning(f"{operation}{user_info}: {message}") \ No newline at end of file diff --git a/plugins/ai_search.py b/plugins/ai_search.py new file mode 100644 index 0000000..afdf101 --- /dev/null +++ b/plugins/ai_search.py @@ -0,0 +1,219 @@ +import json +import time +from urllib.parse import quote +import requests + + +class Liugin: + """网页内容工具 — jina.ai 代理 + AI 直连""" + + _UA = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36' + _HEADERS = { + 'User-Agent': _UA, + 'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8', + 'Accept-Language': 'zh-CN,zh;q=0.9,en;q=0.8', + } + + def __init__(self): + self.usage = """网页内容工具 + +【jina.ai 代理组】— 通过 jina.ai 服务，返回干净文本: + ai_url <网址> - jina 提取网页正文 + ai_search <搜索词> - jina 网络搜索 + ai_web <搜索词> - jina 网络搜索（同 ai_search） + +【AI 直连组】— 直接 HTTP 请求，模型自行处理: + url <网址> - 直接获取网页原始内容 + search <搜索词> - 直接搜索（模型自行选择搜索引擎） + web <搜索词> - 同 search + +JSON 格式示例: + {"action": "use_tool", "tool": "ai_search", "args": "ai_url https://www.example.com"} + {"action": "use_tool", "tool": "ai_search", "args": "ai_search Python教程"} + {"action": "use_tool", "tool": "ai_search", "args": "url https://api.example.com/data"} + +⚠️ 使用原则: + - 优先使用 AI 直连组 (url/search/web)，自己获取和处理网页内容 + - 仅当直连失败、网页需要 JS 渲染、或需要 jina 的智能提取时才用 jina 代理组 + - 不要滥用 jina，它有速率限制 +""" + self.cli = None + self.timeout = 30 + self.max_retries = 2 + + def set_cli(self, cli): + self.cli = cli + self.cli.register_liugin_command('ai_search', self.command_handler) + + def command_handler(self, args): + parts = args.strip().split(maxsplit=1) + if len(parts) < 1: + return "请提供操作: ai_url/ai_search/ai_web/url/search/web <参数>" + operation = parts[0].lower() + remaining_args = parts[1] if len(parts) > 1 else "" + return self.handle(f"{operation} {remaining_args}") + + def get_tool_info(self): + return { + "name": "ai_search", + "description": "网页内容工具。ai_url/ai_search/ai_web 用 jina.ai 代理；url/search/web 直接 HTTP 请求让模型自行处理。优先用直连组，jina 仅作备用。", + "keywords": ["网址", "url", "网页", "web", "search", "搜索", "fetch", "提取", "jina", + "ai_url", "ai_search", "ai_web", "内容", "获取", "联网"], + "usage": self.usage + } + + def handle(self, args): + try: + parts = args.strip().split(maxsplit=1) + if len(parts) < 1: + return "错误：参数不足。可用操作: ai_url/ai_search/ai_web/url/search/web <参数>" + + operation = parts[0].lower() + param = parts[1].strip() if len(parts) > 1 else "" + + if not param: + return f"错误：请提供参数。格式: {operation} <网址或搜索词>" + + # ── jina.ai 代理组 ── + if operation == "ai_url": + return self._jina_extract(param) + + elif operation == "ai_search": + return self._jina_search(param) + + elif operation == "ai_web": + return self._jina_search(param) + + # ── AI 直连组 ── + elif operation == "url": + return self._fetch_raw(param) + + elif operation == "search": + return self._direct_search(param) + + elif operation == "web": + return self._direct_search(param) + + else: + return f"不支持的操作 '{operation}'。可用: ai_url/ai_search/ai_web/url/search/web" + except Exception as e: + return f"操作错误: {str(e)}" + + # ═══════════════════════════════════════ + # jina.ai 代理组 + # ═══════════════════════════════════════ + + def _jina_extract(self, url): + """jina.ai 提取网页正文""" + jina_url = f"https://r.jina.ai/{url}" + result = self._execute_curl(jina_url) + if result.startswith("错误："): + return result + return f"[jina 提取] 网页内容 (来自 {url}):\n\n{result}" + + def _jina_search(self, query): + """jina.ai 网络搜索""" + encoded = quote(query, safe='') + jina_url = f"https://s.jina.ai/{encoded}" + result = self._execute_curl(jina_url) + if result.startswith("错误："): + return result + return f"[jina 搜索] 结果 (搜索词: {query}):\n\n{result}" + + # ═══════════════════════════════════════ + # AI 直连组 + # ═══════════════════════════════════════ + + def _fetch_raw(self, url): + """直接 HTTP GET 获取网页原始内容""" + if not url.startswith('http://') and not url.startswith('https://'): + url = 'https://' + url + + try: + response = requests.get( + url, timeout=self.timeout, headers=self._HEADERS, allow_redirects=True + ) + if response.status_code != 200: + return f"错误：HTTP {response.status_code}" + + if not response.encoding or response.encoding.lower() == 'iso-8859-1': + response.encoding = response.apparent_encoding or 'utf-8' + + content = response.text.strip() + if not content: + return "错误：未获取到内容" + + return f"[直连] 原始网页内容 (来自 {url}):\n\n{content}" + except requests.exceptions.Timeout: + return f"错误：请求超时 (>{self.timeout}秒)" + except requests.exceptions.ConnectionError: + return "错误：网络连接失败" + except Exception as e: + return f"错误：{str(e)}" + + def _direct_search(self, query): + """直接搜索 — 用搜索引擎获取结果页，模型自行解析""" + encoded = quote(query, safe='') + # 用必应搜索，返回结果页 HTML，模型自行提取链接和摘要 + search_url = f"https://www.bing.com/search?q={encoded}" + + try: + response = requests.get( + search_url, timeout=self.timeout, headers=self._HEADERS, allow_redirects=True + ) + if response.status_code != 200: + return f"错误：HTTP {response.status_code}" + + if not response.encoding or response.encoding.lower() == 'iso-8859-1': + response.encoding = response.apparent_encoding or 'utf-8' + + content = response.text.strip() + if not content: + return "错误：未获取到搜索结果" + + return f"[直连] 搜索结果页 (搜索词: {query}):\n\n{content}" + except requests.exceptions.Timeout: + return f"错误：请求超时 (>{self.timeout}秒)" + except requests.exceptions.ConnectionError: + return "错误：网络连接失败" + except Exception as e: + return f"错误：{str(e)}" + + # ═══════════════════════════════════════ + # 通用请求（jina 用，带重试） + # ═══════════════════════════════════════ + + def _execute_curl(self, url): + last_error = None + for attempt in range(self.max_retries + 1): + try: + response = requests.get( + url, timeout=self.timeout, headers=self._HEADERS, allow_redirects=True + ) + if response.status_code != 200: + return f"错误：HTTP {response.status_code}" + + if not response.encoding or response.encoding.lower() == 'iso-8859-1': + response.encoding = response.apparent_encoding or 'utf-8' + + content = response.text.strip() + if not content: + return "错误：未获取到内容" + + return content + except requests.exceptions.Timeout: + last_error = f"请求超时 (>{self.timeout}秒)" + if attempt < self.max_retries: + time.sleep(1) + except requests.exceptions.ConnectionError: + last_error = "网络连接失败" + if attempt < self.max_retries: + time.sleep(1) + except requests.exceptions.RequestException as e: + last_error = str(e) + break + except Exception as e: + last_error = str(e) + break + + return f"错误：{last_error}" diff --git a/plugins/auto_engineer.py b/plugins/auto_engineer.py new file mode 100644 index 0000000..ce588cc --- /dev/null +++ b/plugins/auto_engineer.py @@ -0,0 +1,456 @@ +""" +工程化工具插件 - 代码质量 + 项目分析 +合并原 auto_engineer + project_analyzer，消除重复 +""" +import os +import ast +import re +import json +import subprocess +from typing import Tuple, List + + +class Liugin: + """工程化工具 - lint/format/test/build + 代码分析""" + + def __init__(self): + self.usage = """工程化与分析工具 + +质量检查: + lint [目录] [文件模式] - 代码质量检查 (ruff/flake8) + format [目录] [文件模式] - 代码格式化 (ruff/black) + test [目录] [参数] - 运行测试 (pytest) + build [命令] - 构建项目 + deps - 检查过时依赖 + deps-check - 安全漏洞检查 + pre-commit - 运行 pre-commit 检查 + +项目分析: + complexity [目录] - 圈复杂度分析 + duplicates [目录] - 重复代码检测 + security [目录] - 安全风险扫描 + metrics [目录] - 代码质量指标 + suggest [目录] - 改进建议 + info - 项目信息摘要 + init [类型] - 初始化项目 (python/web) +""" + self.cli = None + + def set_cli(self, cli): + self.cli = cli + + def get_tool_info(self): + return { + "name": "auto_engineer", + "description": "工程化工具 - lint/format/test/build + 代码复杂度/安全/质量分析", + "keywords": ["lint", "format", "test", "build", "代码质量", "格式化", "测试", + "复杂度", "安全", "分析", "依赖", "项目"], + "usage": self.usage + } + + def get_mcp_definition(self): + return { + "name": "auto_engineer", + "description": "工程化与分析工具", + "inputSchema": { + "type": "object", + "properties": { + "operation": {"type": "string"}, + "target": {"type": "string"}, + "options": {"type": "string"} + }, + "required": ["operation"] + } + } + + def convert_mcp_args(self, arguments): + op = arguments.get("operation", "") + target = arguments.get("target", "") + return f"{op} {target}".strip() + + # ── 工具方法 ── + + def _run(self, cmd: str, cwd: str = None, timeout: int = 60) -> Tuple[bool, str]: + try: + result = subprocess.run( + cmd, shell=True, capture_output=True, text=True, + cwd=cwd or os.getcwd(), timeout=timeout + ) + output = result.stdout + (("\n" + result.stderr) if result.stderr else "") + return result.returncode == 0, output.strip() + except subprocess.TimeoutExpired: + return False, f"命令超时 ({timeout}s)" + except Exception as e: + return False, str(e) + + def _find_tool(self, *tools) -> str: + for tool in tools: + mod = tool.replace("-", "_") + ok, _ = self._run(f"python3 -c 'import {mod}'", timeout=5) + if ok: + return tool + ok, _ = self._run(f"which {tool}", timeout=5) + if ok: + return tool + return None + + def _walk_py(self, target: str) -> List[str]: + files = [] + skip = {'.git', '__pycache__', '.venv', 'venv', 'node_modules'} + for root, dirs, fnames in os.walk(target): + dirs[:] = [d for d in dirs if d not in skip] + for f in fnames: + if f.endswith('.py'): + files.append(os.path.join(root, f)) + return files + + # ── 路由 ── + + def handle(self, args: str) -> str: + parts = args.strip().split(maxsplit=2) + if not parts: + return self.usage + + op = parts[0].lower() + target = parts[1] if len(parts) > 1 else "." + options = parts[2] if len(parts) > 2 else "" + + handlers = { + "lint": self._lint, + "format": self._format, + "test": self._test, + "build": self._build, + "deps": self._deps, + "deps-check": self._deps_check, + "pre-commit": self._pre_commit, + "complexity": self._complexity, + "duplicates": self._duplicates, + "security": self._security, + "metrics": self._metrics, + "suggest": self._suggest, + "info": self._info, + "init": self._init_project, + } + + handler = handlers.get(op) + if not handler: + return f"错误：不支持的操作 '{op}'" + try: + return handler(target, options) + except Exception as e: + return f"执行错误: {e}" + + # ══════════════════════════════════════ + # 质量检查 + # ══════════════════════════════════════ + + def _lint(self, target: str, options: str) -> str: + tool = self._find_tool("ruff", "flake8") + if not tool: + return " 未安装 lint 工具。安装: pip install ruff" + cmd = f"ruff check {target} {options}" if tool == "ruff" else f"flake8 {target} {options}" + ok, output = self._run(cmd, timeout=120) + if not output: + return f" lint 检查通过 ({tool})" + lines = output.split('\n') + count = len([l for l in lines if l.strip() and not l.startswith(' ')]) + return f"{'' if not ok else ''} lint ({tool}): {count} 个问题\n\n{output[:2000]}" + + def _format(self, target: str, options: str) -> str: + tool = self._find_tool("ruff", "black") + if not tool: + return " 未安装格式化工具。安装: pip install ruff" + cmd = f"ruff format {target} {options}" if tool == "ruff" else f"black {target} {options}" + ok, output = self._run(cmd, timeout=120) + return f"{'' if ok else ''} 格式化 ({tool})\n{output[:1000]}" + + def _test(self, target: str, options: str) -> str: + ok, output = self._run(f"pytest {target} {options} -v", timeout=120) + if not ok and "no tests ran" in output.lower(): + return f" 未找到测试文件\n{output[:1000]}" + for line in output.split('\n'): + if 'passed' in line or 'failed' in line: + return f"{'' if ok else ''} 测试\n{line}\n\n{output[:2000]}" + return f"{'' if ok else ''} 测试\n{output[:2000]}" + + def _build(self, target: str, options: str) -> str: + if not target or target == ".": + if os.path.exists("Makefile"): + cmd = "make" + elif os.path.exists("pyproject.toml"): + cmd = "python3 -m build" + elif os.path.exists("package.json"): + cmd = "npm run build" + else: + return " 未找到构建配置" + else: + cmd = target + ok, output = self._run(cmd, timeout=300) + return f"{'' if ok else ''} 构建: {cmd}\n{output[:2000]}" + + def _deps(self, target: str, options: str) -> str: + ok, output = self._run("pip list --outdated --format=json", timeout=30) + if not ok: + return f" 检查失败\n{output}" + try: + outdated = json.loads(output) + if not outdated: + return " 所有依赖都是最新版本" + lines = [f" {len(outdated)} 个依赖可更新:\n"] + for pkg in outdated[:20]: + lines.append(f" {pkg['name']:30} {pkg['version']:12} → {pkg['latest_version']}") + return '\n'.join(lines) + except json.JSONDecodeError: + return f" 依赖状态:\n{output[:2000]}" + + def _deps_check(self, target: str, options: str) -> str: + tool = self._find_tool("pip-audit", "safety") + if not tool: + return " 未安装安全检查工具。安装: pip install pip-audit" + cmd = "pip-audit" if tool == "pip-audit" else "safety check" + ok, output = self._run(cmd, timeout=60) + return f"{'' if ok else ''} 安全检查 ({tool})\n{output[:2000]}" + + def _pre_commit(self, target: str, options: str) -> str: + ok, output = self._run("pre-commit run --all-files", timeout=120) + return f"{'' if ok else ''} pre-commit\n{output[:2000]}" + + # ══════════════════════════════════════ + # 项目分析 + # ══════════════════════════════════════ + + def _complexity(self, target: str, options: str) -> str: + files = self._walk_py(target) + results = [] + for fp in files: + try: + with open(fp, 'r', encoding='utf-8') as f: + tree = ast.parse(f.read()) + except Exception: + continue + for node in ast.walk(tree): + if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)): + complexity = 1 + for child in ast.walk(node): + if isinstance(child, (ast.If, ast.While, ast.For, ast.ExceptHandler)): + complexity += 1 + elif isinstance(child, ast.BoolOp): + complexity += len(child.values) - 1 + if complexity > 5: + rel = os.path.relpath(fp, target) + results.append((rel, node.lineno, node.name, complexity)) + + if not results: + return " 所有函数复杂度正常 (≤5)" + + results.sort(key=lambda x: x[3], reverse=True) + lines = [f" 高复杂度函数 ({len(results)} 个):\n"] + for file, line, func, c in results[:20]: + icon = "" if c > 10 else "" + lines.append(f" {icon} {file}:{line} {func}() 复杂度={c}") + return '\n'.join(lines) + + def _duplicates(self, target: str, options: str) -> str: + files = self._walk_py(target) + func_defs = {} + for fp in files: + try: + with open(fp, 'r', encoding='utf-8') as f: + tree = ast.parse(f.read()) + except Exception: + continue + rel = os.path.relpath(fp, target) + for node in ast.walk(tree): + if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)): + func_defs.setdefault(node.name, []).append(f"{rel}:{node.lineno}") + + dupes = {k: v for k, v in func_defs.items() if len(v) > 1} + if not dupes: + return " 没有重复函数名" + lines = [f" 重复函数名 ({len(dupes)} 个):\n"] + for name, locs in sorted(dupes.items(), key=lambda x: -len(x[1])): + lines.append(f" {name} ({len(locs)} 处):") + for loc in locs[:5]: + lines.append(f" • {loc}") + return '\n'.join(lines) + + def _security(self, target: str, options: str) -> str: + files = self._walk_py(target) + patterns = [ + (r'\beval\s*\(', 'eval() - 代码注入', 'HIGH'), + (r'\bexec\s*\(', 'exec() - 代码注入', 'HIGH'), + (r'subprocess\.call\s*\(\s*shell\s*=\s*True', 'shell=True - 命令注入', 'HIGH'), + (r'pickle\.loads?\s*\(', 'pickle 反序列化', 'HIGH'), + (r'password\s*=\s*["\']', '硬编码密码', 'HIGH'), + (r'api_key\s*=\s*["\']', '硬编码 API Key', 'HIGH'), + ] + risks = [] + for fp in files: + try: + with open(fp, 'r', encoding='utf-8') as f: + for i, line in enumerate(f, 1): + for pat, desc, level in patterns: + if re.search(pat, line, re.IGNORECASE): + rel = os.path.relpath(fp, target) + risks.append((rel, i, level, desc, line.strip())) + except Exception: + continue + + if not risks: + return " 没有发现安全风险" + lines = [f" 安全风险 ({len(risks)} 个):\n"] + for file, line, level, desc, code in risks[:20]: + lines.append(f" {'' if level == 'HIGH' else ''} {file}:{line} [{level}] {desc}") + lines.append(f" {code[:60]}") + return '\n'.join(lines) + + def _metrics(self, target: str, options: str) -> str: + files = self._walk_py(target) + total = blank = comment = code = funcs = classes = max_lines = 0 + long_files = [] + + for fp in files: + try: + with open(fp, 'r', encoding='utf-8') as f: + lines = f.readlines() + except Exception: + continue + fl = len(lines) + total += fl + max_lines = max(max_lines, fl) + if fl > 300: + long_files.append((os.path.relpath(fp, target), fl)) + for line in lines: + s = line.strip() + if not s: + blank += 1 + elif s.startswith('#'): + comment += 1 + else: + code += 1 + try: + with open(fp, 'r', encoding='utf-8') as f: + tree = ast.parse(f.read()) + for node in ast.walk(tree): + if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)): + funcs += 1 + elif isinstance(node, ast.ClassDef): + classes += 1 + except Exception: + pass + + rate = comment / max(code, 1) * 100 + lines = [ + f" 代码指标 ({target}):\n", + f" 文件: {len(files)} | 总行: {total} | 代码: {code}", + f" 注释: {comment} ({rate:.1f}%) | 空行: {blank}", + f" 函数: {funcs} | 类: {classes} | 最大文件: {max_lines} 行", + ] + if long_files: + lines.append(f"\n 超过 300 行的文件 ({len(long_files)}):") + for f, l in sorted(long_files, key=lambda x: -x[1])[:5]: + lines.append(f" • {f}: {l} 行") + return '\n'.join(lines) + + def _suggest(self, target: str, options: str) -> str: + files = os.listdir(target) if os.path.isdir(target) else [] + py_files = self._walk_py(target) + suggestions = [] + + if 'README.md' not in files: + suggestions.append(" 添加 README.md") + if 'pyproject.toml' not in files: + suggestions.append(" 使用 pyproject.toml") + if '.gitignore' not in files: + suggestions.append(" 添加 .gitignore") + + test_files = [f for f in py_files if 'test' in os.path.basename(f).lower()] + if not test_files and len(py_files) > 5: + suggestions.append(" 添加单元测试") + + uses_print = 0 + uses_log = 0 + for f in py_files: + with open(f, errors='ignore') as fh: + content = fh.read() + if 'print(' in content: + uses_print += 1 + if 'logging' in content: + uses_log += 1 + + if uses_print > uses_log and uses_print > 3: + suggestions.append(" 考虑用 logging 替代 print") + + return " 改进建议:\n" + '\n'.join(f" {s}" for s in suggestions) if suggestions else " 项目结构良好" + + # ══════════════════════════════════════ + # 项目信息与初始化 + # ══════════════════════════════════════ + + def _info(self, target: str, options: str) -> str: + info = [] + files = os.listdir(target or ".") + + if "pyproject.toml" in files: + info.append(" 项目类型: Python (pyproject.toml)") + elif "setup.py" in files: + info.append(" 项目类型: Python (setup.py)") + elif "package.json" in files: + info.append(" 项目类型: Node.js") + else: + info.append(" 项目类型: 未知") + + ok, ver = self._run("python3 --version", timeout=5) + if ok: + info.append(f" Python: {ver}") + + ok, req = self._run("pip list --format=json", timeout=10) + if ok: + try: + info.append(f" 依赖: {len(json.loads(req))} 个") + except Exception: + pass + + ok, git = self._run("git log --oneline -1", timeout=5) + if ok: + info.append(f" 最新提交: {git}") + + ok, branch = self._run("git branch --show-current", timeout=5) + if ok: + info.append(f" 分支: {branch}") + + py_count = len([f for f in self._walk_py(target or ".")]) + info.append(f" Python 文件: {py_count}") + + return '\n'.join(info) + + def _init_project(self, target: str, options: str) -> str: + ptype = target if target != "." else "python" + if ptype == "python": + dirs = ["src", "tests", "docs"] + files = { + "pyproject.toml": '[project]\nname = "my-project"\nversion = "0.1.0"\n', + "README.md": "# My Project\n", + ".gitignore": "__pycache__/\n*.pyc\n.venv/\n", + } + elif ptype == "web": + dirs = ["src", "public", "tests"] + files = { + "package.json": '{\n "name": "my-project",\n "version": "1.0.0"\n}\n', + ".gitignore": "node_modules/\ndist/\n", + } + else: + return f" 不支持: {ptype}。支持: python, web" + + created = [] + for d in dirs: + os.makedirs(d, exist_ok=True) + created.append(f" {d}/") + for f, content in files.items(): + if not os.path.exists(f): + os.makedirs(os.path.dirname(f) or ".", exist_ok=True) + with open(f, 'w') as fp: + fp.write(content) + created.append(f" {f}") + + return f" 已初始化 {ptype} 项目\n" + '\n'.join(created) diff --git a/plugins/browser_auto.py b/plugins/browser_auto.py new file mode 100644 index 0000000..6296dd3 --- /dev/null +++ b/plugins/browser_auto.py @@ -0,0 +1,545 @@ +""" +浏览器自动化插件 - 无头浏览器操控 +基于 Playwright，支持页面导航、元素交互、截图、JS 执行 +""" +import os +import json +import base64 +import time +from typing import Optional + + +class Liugin: + """浏览器自动化 - 网页操控、表单填写、数据抓取、截图""" + + def __init__(self): + self.usage = """浏览器自动化工具 + +连接: + start - 启动浏览器实例 + stop - 关闭浏览器 + status - 查看浏览器状态 + +导航: + open - 打开网页 + back - 后退 + forward - 前进 + reload - 刷新页面 + title - 获取页面标题 + url - 获取当前 URL + +交互: + click <选择器> - 点击元素 + fill <选择器> <文本> - 填写输入框 + select <选择器> <值> - 下拉选择 + check <选择器> - 勾选复选框 + uncheck <选择器> - 取消勾选 + hover <选择器> - 鼠标悬停 + press <按键> - 按键 (Enter/Tab/Escape 等) + +提取: + text [选择器] - 获取元素文本 (默认 body) + html [选择器] - 获取元素 HTML + attr <选择器> <属性名> - 获取元素属性 + value <选择器> - 获取输入框值 + eval - 执行 JavaScript + query <选择器> - 查询匹配元素列表 + +截图: + screenshot [路径] - 页面截图 (默认 screenshot.png) + screenshot --selector <选择器> - 元素截图 + +等待: + wait <选择器> [超时秒数] - 等待元素出现 + wait-gone <选择器> [超时秒数] - 等待元素消失 + wait-url [超时秒数] - 等待 URL 变化 + +高级: + pdf [路径] - 保存页面为 PDF + cookies - 获取所有 cookies + set-cookie - 设置 cookie + viewport <宽> <高> - 设置视口大小 + download [保存路径] - 下载文件 +""" + self.cli = None + self._browser = None + self._context = None + self._page = None + self._pw = None + + def set_cli(self, cli): + self.cli = cli + + def get_tool_info(self): + return { + "name": "browser_auto", + "description": "浏览器自动化 - 网页导航、元素交互、表单填写、数据抓取、截图、JS执行", + "keywords": ["浏览器", "browser", "网页", "点击", "截图", "screenshot", "爬虫", + "playwright", "自动化", "表单", "抓取", "导航", "puppeteer"], + "usage": self.usage + } + + def get_mcp_definition(self): + return { + "name": "browser_auto", + "description": "浏览器自动化工具", + "inputSchema": { + "type": "object", + "properties": { + "operation": {"type": "string", "description": "操作类型"}, + "url": {"type": "string", "description": "网页 URL"}, + "selector": {"type": "string", "description": "CSS 选择器"}, + "value": {"type": "string", "description": "输入值"}, + "script": {"type": "string", "description": "JavaScript 代码"}, + "path": {"type": "string", "description": "保存路径"} + }, + "required": ["operation"] + } + } + + def convert_mcp_args(self, arguments): + op = arguments.get("operation", "") + url = arguments.get("url", "") + selector = arguments.get("selector", "") + return f"{op} {url} {selector}".strip() + + # ── 路由 ── + + def handle(self, args: str) -> str: + try: + parts = args.strip().split(maxsplit=1) + if not parts: + return "错误：请提供操作类型" + + op = parts[0].lower() + rest = parts[1] if len(parts) > 1 else "" + + handlers = { + "start": self._start, + "stop": self._stop, + "status": self._status, + "open": self._open, + "back": self._back, + "forward": self._forward, + "reload": self._reload, + "title": self._title, + "url": self._url, + "click": self._click, + "fill": self._fill, + "select": self._select, + "check": self._check, + "uncheck": self._uncheck, + "hover": self._hover, + "press": self._press, + "text": self._text, + "html": self._html, + "attr": self._attr, + "value": self._value, + "eval": self._eval, + "query": self._query, + "screenshot": self._screenshot, + "wait": self._wait, + "wait-gone": self._wait_gone, + "wait-url": self._wait_url, + "pdf": self._pdf, + "cookies": self._cookies, + "set-cookie": self._set_cookie, + "viewport": self._viewport, + "download": self._download, + } + + handler = handlers.get(op) + if not handler: + return f"错误：不支持的操作 '{op}'" + return handler(rest) + + except Exception as e: + return f"浏览器自动化错误: {str(e)}" + + # ── 浏览器生命周期 ── + + def _ensure_playwright(self): + """确保 Playwright 已安装并可用""" + try: + from playwright.sync_api import sync_playwright + return sync_playwright + except ImportError: + return None + + def _start(self, args: str) -> str: + if self._browser and self._page: + return "浏览器已在运行中" + + sync_playwright = self._ensure_playwright() + if not sync_playwright: + return (" 未安装 Playwright。安装步骤:\n" + " pip install playwright\n" + " playwright install chromium") + + try: + self._pw = sync_playwright().start() + self._browser = self._pw.chromium.launch(headless=True) + self._context = self._browser.new_context( + viewport={"width": 1280, "height": 720}, + user_agent="Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36" + ) + self._page = self._context.new_page() + return " 浏览器已启动 (headless Chromium, 1280×720)" + except Exception as e: + return f" 启动失败: {e}" + + def _stop(self, args: str) -> str: + try: + if self._context: + self._context.close() + if self._browser: + self._browser.close() + if self._pw: + self._pw.stop() + except Exception: + pass + self._page = None + self._context = None + self._browser = None + self._pw = None + return " 浏览器已关闭" + + def _status(self, args: str) -> str: + if self._page and not self._page.is_closed(): + url = self._page.url + title = self._page.title() + return f" 运行中\n URL: {url}\n 标题: {title}" + return " 未运行" + + def _require_page(self): + """确保页面可用，否则自动启动""" + if self._page and not self._page.is_closed(): + return self._page + self._start("") + return self._page + + # ── 导航 ── + + def _open(self, args: str) -> str: + url = args.strip() + if not url: + return "错误：请提供 URL" + if not url.startswith(("http://", "https://", "file://")): + url = "https://" + url + + page = self._require_page() + try: + page.goto(url, wait_until="domcontentloaded", timeout=30000) + title = page.title() + return f" 已打开: {url}\n 标题: {title}" + except Exception as e: + return f" 打开失败: {e}" + + def _back(self, args: str) -> str: + page = self._require_page() + page.go_back() + return f" 后退 → {page.url}" + + def _forward(self, args: str) -> str: + page = self._require_page() + page.go_forward() + return f" 前进 → {page.url}" + + def _reload(self, args: str) -> str: + page = self._require_page() + page.reload() + return f" 已刷新: {page.url}" + + def _title(self, args: str) -> str: + page = self._require_page() + return page.title() or "(无标题)" + + def _url(self, args: str) -> str: + page = self._require_page() + return page.url + + # ── 交互 ── + + def _click(self, selector: str) -> str: + selector = selector.strip() + if not selector: + return "错误：请提供 CSS 选择器" + page = self._require_page() + try: + page.click(selector, timeout=10000) + return f" 已点击: {selector}" + except Exception as e: + return f" 点击失败: {e}" + + def _fill(self, args: str) -> str: + parts = args.strip().split(maxsplit=1) + if len(parts) < 2: + return "错误：格式: fill <选择器> <文本>" + selector, text = parts[0], parts[1] + page = self._require_page() + try: + page.fill(selector, text, timeout=10000) + return f" 已填写: {selector}" + except Exception as e: + return f" 填写失败: {e}" + + def _select(self, args: str) -> str: + parts = args.strip().split(maxsplit=1) + if len(parts) < 2: + return "错误：格式: select <选择器> <值>" + selector, value = parts[0], parts[1] + page = self._require_page() + try: + page.select_option(selector, value, timeout=10000) + return f" 已选择: {selector} = {value}" + except Exception as e: + return f" 选择失败: {e}" + + def _check(self, selector: str) -> str: + page = self._require_page() + try: + page.check(selector.strip(), timeout=10000) + return f" 已勾选: {selector}" + except Exception as e: + return f" 勾选失败: {e}" + + def _uncheck(self, selector: str) -> str: + page = self._require_page() + try: + page.uncheck(selector.strip(), timeout=10000) + return f" 已取消勾选: {selector}" + except Exception as e: + return f" 取消勾选失败: {e}" + + def _hover(self, selector: str) -> str: + page = self._require_page() + try: + page.hover(selector.strip(), timeout=10000) + return f" 悬停: {selector}" + except Exception as e: + return f" 悬停失败: {e}" + + def _press(self, key: str) -> str: + page = self._require_page() + page.keyboard.press(key.strip()) + return f" 按键: {key}" + + # ── 提取 ── + + def _text(self, selector: str) -> str: + selector = selector.strip() or "body" + page = self._require_page() + try: + el = page.query_selector(selector) + if el: + text = el.inner_text() + return text + return f"未找到元素: {selector}" + except Exception as e: + return f" 获取文本失败: {e}" + + def _html(self, selector: str) -> str: + selector = selector.strip() or "body" + page = self._require_page() + try: + el = page.query_selector(selector) + if el: + html = el.inner_html() + return html + return f"未找到元素: {selector}" + except Exception as e: + return f" 获取 HTML 失败: {e}" + + def _attr(self, args: str) -> str: + parts = args.strip().split(maxsplit=1) + if len(parts) < 2: + return "错误：格式: attr <选择器> <属性名>" + selector, attr_name = parts[0], parts[1] + page = self._require_page() + try: + el = page.query_selector(selector) + if el: + val = el.get_attribute(attr_name) + return f"{attr_name} = {val}" + return f"未找到元素: {selector}" + except Exception as e: + return f" 获取属性失败: {e}" + + def _value(self, selector: str) -> str: + page = self._require_page() + try: + el = page.query_selector(selector.strip()) + if el: + return el.input_value() + return f"未找到元素: {selector}" + except Exception as e: + return f" 获取值失败: {e}" + + def _eval(self, script: str) -> str: + script = script.strip() + if not script: + return "错误：请提供 JavaScript 代码" + page = self._require_page() + try: + result = page.evaluate(script) + if isinstance(result, (dict, list)): + return json.dumps(result, ensure_ascii=False, indent=2) + return str(result) + except Exception as e: + return f" JS 执行失败: {e}" + + def _query(self, selector: str) -> str: + selector = selector.strip() + if not selector: + return "错误：请提供 CSS 选择器" + page = self._require_page() + try: + elements = page.query_selector_all(selector) + if not elements: + return f"未找到匹配 '{selector}' 的元素" + + result = [f"找到 {len(elements)} 个元素:\n"] + for i, el in enumerate(elements[:20]): + tag = el.evaluate("el => el.tagName.toLowerCase()") + text = el.inner_text()[:80].replace('\n', ' ').strip() + result.append(f" [{i}] <{tag}> {text}") + if len(elements) > 20: + result.append(f" ... 还有 {len(elements) - 20} 个") + return '\n'.join(result) + except Exception as e: + return f" 查询失败: {e}" + + # ── 截图 ── + + def _screenshot(self, args: str) -> str: + page = self._require_page() + + # 解析参数 + path = "screenshot.png" + selector = None + parts = args.strip().split() + i = 0 + while i < len(parts): + if parts[i] == "--selector" and i + 1 < len(parts): + selector = parts[i + 1] + i += 2 + elif not parts[i].startswith("-"): + path = parts[i] + i += 1 + else: + i += 1 + + try: + if selector: + el = page.query_selector(selector) + if not el: + return f"未找到元素: {selector}" + el.screenshot(path=path) + else: + page.screenshot(path=path, full_page=True) + + size = os.path.getsize(path) + return f" 截图已保存: {path} ({size/1024:.1f} KB)" + except Exception as e: + return f" 截图失败: {e}" + + # ── 等待 ── + + def _wait(self, args: str) -> str: + parts = args.strip().split() + if not parts: + return "错误：请提供选择器" + selector = parts[0] + timeout = int(parts[1]) * 1000 if len(parts) > 1 else 30000 + page = self._require_page() + try: + page.wait_for_selector(selector, timeout=timeout) + return f" 元素已出现: {selector}" + except Exception: + return f" 等待超时: {selector}" + + def _wait_gone(self, args: str) -> str: + parts = args.strip().split() + if not parts: + return "错误：请提供选择器" + selector = parts[0] + timeout = int(parts[1]) * 1000 if len(parts) > 1 else 30000 + page = self._require_page() + try: + page.wait_for_selector(selector, state="hidden", timeout=timeout) + return f" 元素已消失: {selector}" + except Exception: + return f" 等待超时: {selector}" + + def _wait_url(self, args: str) -> str: + parts = args.strip().split() + if not parts: + return "错误：请提供 URL 片段" + url_part = parts[0] + timeout = int(parts[1]) * 1000 if len(parts) > 1 else 30000 + page = self._require_page() + try: + page.wait_for_url(f"**{url_part}**", timeout=timeout) + return f" URL 已变化: {page.url}" + except Exception: + return f" 等待超时: URL 未变化" + + # ── 高级 ── + + def _pdf(self, args: str) -> str: + path = args.strip() or "page.pdf" + page = self._require_page() + try: + page.pdf(path=path) + size = os.path.getsize(path) + return f" PDF 已保存: {path} ({size/1024:.1f} KB)" + except Exception as e: + return f" PDF 生成失败: {e}" + + def _cookies(self, args: str) -> str: + page = self._require_page() + cookies = page.context.cookies() + if not cookies: + return "无 cookies" + result = [f"Cookies ({len(cookies)} 个):\n"] + for c in cookies[:20]: + result.append(f" {c['name']}: {c['value'][:50]} (domain: {c.get('domain', '-')})") + return '\n'.join(result) + + def _set_cookie(self, args: str) -> str: + try: + cookie = json.loads(args.strip()) + except json.JSONDecodeError: + return "错误：cookie 必须是 JSON 格式: {\"name\": \"...\", \"value\": \"...\", \"domain\": \"...\"}" + page = self._require_page() + page.context.add_cookies([cookie]) + return f" 已设置 cookie: {cookie.get('name', '?')}" + + def _viewport(self, args: str) -> str: + parts = args.strip().split() + if len(parts) < 2: + return "错误：格式: viewport <宽> <高>" + try: + w, h = int(parts[0]), int(parts[1]) + except ValueError: + return "错误：宽高必须是整数" + page = self._require_page() + page.set_viewport_size({"width": w, "height": h}) + return f" 视口已设置: {w}×{h}" + + def _download(self, args: str) -> str: + parts = args.strip().split() + if not parts: + return "错误：格式: download [保存路径]" + url = parts[0] + save_path = parts[1] if len(parts) > 1 else os.path.basename(url) or "download" + page = self._require_page() + try: + with page.expect_download() as download_info: + page.evaluate(f"window.open('{url}')") + download = download_info.value + download.save_as(save_path) + size = os.path.getsize(save_path) + return f" 已下载: {save_path} ({size/1024:.1f} KB)" + except Exception as e: + return f" 下载失败: {e}" diff --git a/plugins/cmd_executor.py b/plugins/cmd_executor.py new file mode 100644 index 0000000..3813862 --- /dev/null +++ b/plugins/cmd_executor.py @@ -0,0 +1,147 @@ +""" +命令执行器插件 - 跨平台 Shell 命令执行 +""" +import os +import re +import subprocess +import platform +import sys + +# 添加项目根目录到 path +sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) +from xcli_core.tool_result import ToolResult, ErrorCode + + +class Liugin: + """Shell 命令执行器 - 跨平台命令行工具""" + + def __init__(self): + self.usage = """Shell 命令执行器 + +操作: + run <命令> [--timeout 秒] - 执行 Shell 命令 (默认超时 30s) + +示例: + run ls -la - 列出当前目录 + run python3 --version - 查看 Python 版本 + run git status - 查看 Git 状态 + run make build --timeout 60 - 执行构建 (60秒超时) + +注意: + - 跨平台兼容 (Linux/macOS/Windows) + - 输出限制 5000 字符 + - 某些危险命令会被拦截 +""" + self.cli = None + + def set_cli(self, cli): + self.cli = cli + + def get_tool_info(self): + return { + "name": "cmd_executor", + "description": "Shell 命令执行器 - 跨平台执行系统命令，支持超时控制", + "keywords": ["命令", "执行", "shell", "cmd", "终端", "命令行", "subprocess"], + "usage": self.usage + } + + def get_mcp_definition(self): + return { + "name": "cmd_executor", + "description": "Shell 命令执行器", + "inputSchema": { + "type": "object", + "properties": { + "command": {"type": "string", "description": "要执行的命令"}, + "timeout": {"type": "integer", "description": "超时秒数", "default": 30} + }, + "required": ["command"] + } + } + + def convert_mcp_args(self, arguments): + cmd = arguments.get("command", "") + timeout = arguments.get("timeout", "") + result = f"run {cmd}" + if timeout: + result += f" --timeout {timeout}" + return result + + # 危险命令黑名单 + BLOCKED = { + 'rm -rf /', 'rm -rf ~', 'mkfs', 'dd if=', 'wipefs', 'shred', + ':(){ :|:& };:', 'chmod -R 777 /', 'mv / ', 'wget http', + } + + def handle(self, args: str): + try: + parts = args.strip().split(maxsplit=1) + if not parts: + return ToolResult.missing("操作。可用: run <命令>") + + operation = parts[0].lower() + if operation != "run": + return ToolResult.fail(f"不支持的操作 '{operation}'。可用: run", ErrorCode.UNSUPPORTED_OP) + + if len(parts) < 2: + return ToolResult.missing("要执行的命令") + + rest = parts[1] + + # 解析 --timeout + timeout = 30 + timeout_match = re.search(r'--timeout\s+(\d+)', rest) + if timeout_match: + timeout = int(timeout_match.group(1)) + rest = re.sub(r'--timeout\s+\d+', '', rest).strip() + + if not rest: + return ToolResult.missing("要执行的命令") + + # 安全检查 + for blocked in self.BLOCKED: + if blocked in rest: + return ToolResult.fail(f"安全拦截: 检测到危险命令模式 '{blocked}'", ErrorCode.PERMISSION_DENIED) + + return self._execute(rest, timeout) + + except Exception as e: + return ToolResult.fail(str(e), ErrorCode.INTERNAL_ERROR, tool_name="cmd_executor") + + def _execute(self, command: str, timeout: int): + try: + use_shell = platform.system() == 'Windows' + + result = subprocess.run( + command, + shell=True, + capture_output=True, + text=True, + timeout=timeout, + encoding='utf-8', + errors='replace' + ) + + stdout = result.stdout.strip() + stderr = result.stderr.strip() + rc = result.returncode + + output = "" + if stdout: + output += stdout + "\n" + if stderr: + output += f"[stderr]\n{stderr}\n" + if rc != 0: + output += f"[exit code: {rc}]\n" + + if not output: + output = f"命令执行完成，无输出 (超时: {timeout}s)" + + if rc != 0: + return ToolResult.fail(output.strip(), ErrorCode.EXEC_FAILED, tool_name="cmd_executor") + return ToolResult.ok(output.strip(), tool_name="cmd_executor") + + except subprocess.TimeoutExpired: + return ToolResult.timeout(timeout, tool_name="cmd_executor") + except Exception as e: + return ToolResult.fail(str(e), ErrorCode.EXEC_FAILED, tool_name="cmd_executor") diff --git a/plugins/code_editor.py b/plugins/code_editor.py new file mode 100644 index 0000000..c34fbb5 --- /dev/null +++ b/plugins/code_editor.py @@ -0,0 +1,1477 @@ +""" +代码工具 - 统一的代码编辑与搜索能力 +合并原 code_editor + code_search，消除重复 +""" +import os +import re +import ast +import difflib +import py_compile +import json +import subprocess +import sys +import tempfile +import platform +import threading +from typing import Optional, Tuple, List + + +class Liugin: + """代码编辑与搜索 - 精准编辑 + 代码理解""" + + def __init__(self): + self.usage = """代码编辑与搜索工具 + +编辑操作 (修改后自动检查语法): + edit <文件> <<<>>> - 精准替换代码片段 + multi <文件> - 批量修改 + insert <文件> <行号> <内容> - 在指定行插入 + delete_lines <文件> <起始行> <结束行> - 删除指定行 + create <文件路径> [内容] - 创建新文件 + write <文件路径> <内容> - 写入/覆盖文件 + append <文件路径> <内容> - 追加内容到文件 + +语法检查: + syntax_check <文件路径> - 主动检查文件语法 (别名: check) + 支持: Python/JS/TS/JSON/YAML/TOML/HTML/XML/CSS/Shell/SQL + 编辑操作后自动执行，无需手动调用 + +Diff 弹窗: + diff_popup [on|off|popup|inline] - 开关/切换 diff 显示模式 (别名: popup) + popup/弹窗 → 弹窗模式（新终端窗口） + inline/ssh → 主终端内显示（SSH 兼容） + on/开 → 开启 | off/关 → 关闭 | 无参数 → 切换 + +查看操作: + read_range <文件> <起始行> [结束行] - 读取指定行范围 + diff <文件1> <文件2> - 比较两个文件差异 + diff_text <<<>>> - 比较两段文本差异 + ast_info <文件> - Python AST 摘要 (类/函数/导入) + +搜索操作: + find <目录> <关键词> [文件模式] - 关键词搜索 + regex <目录> <正则表达式> [文件模式] - 正则搜索 + symbols <目录> [文件模式] - 提取所有符号 (类/函数) + imports <文件> - 分析导入依赖 + callers <目录> <函数名> - 查找函数调用位置 + todo <目录> [文件模式] - 搜索 TODO/FIXME + structure <目录> [深度] - 项目目录结构 + context <文件> [行号] [范围] - 获取某行上下文 + stats <目录> - 代码统计 +""" + self.cli = None + self.diff_popup_enabled = True # diff 弹窗开关 + self.diff_popup_mode = None # None=启动时询问, True=弹窗, False=主终端内显示 + + def set_cli(self, cli): + self.cli = cli + + def get_tool_info(self): + return { + "name": "code_editor", + "description": "代码编辑与搜索 — 精准替换、批量编辑、代码搜索、符号提取、依赖分析、diff对比、自动语法检查", + "keywords": ["编辑", "修改", "代码", "文件", "edit", "replace", "search", "diff", + "find", "grep", "符号", "structure", "imports", "todo", "callers", + "语法", "syntax", "check", "lint", "检查"], + "usage": self.usage + } + + def get_mcp_definition(self): + return { + "name": "code_editor", + "description": "代码编辑与搜索工具（含自动语法检查）", + "inputSchema": { + "type": "object", + "properties": { + "operation": {"type": "string", "description": "操作类型"}, + "path": {"type": "string", "description": "文件路径"}, + "old_text": {"type": "string"}, + "new_text": {"type": "string"}, + "content": {"type": "string"}, + "line_number": {"type": "integer"}, + "start_line": {"type": "integer"}, + "end_line": {"type": "integer"}, + "pattern": {"type": "string"}, + "file_pattern": {"type": "string"}, + "directory": {"type": "string"}, + "operations": {"type": "array"} + }, + "required": ["operation"] + } + } + + def convert_mcp_args(self, arguments): + op = arguments.get("operation", "") + path = arguments.get("path", "") + return f"{op} {path}" + + # ── 路由 ── + + def handle(self, args: str) -> str: + try: + # 先提取操作名 + first_space = args.strip().find(' ') + if first_space == -1: + operation = args.strip().lower() + arg1, arg2 = "", "" + else: + operation = args.strip()[:first_space].lower() + rest = args.strip()[first_space + 1:] + + # diff_text 特殊处理：用 <<<>>> 分割 + if operation == "diff_text" and " <<<>>> " in rest: + arg1, arg2 = rest.split(" <<<>>> ", 1) + else: + parts = rest.split(maxsplit=1) + arg1 = parts[0] if parts else "" + arg2 = parts[1] if len(parts) > 1 else "" + + if not operation: + return "错误：请提供操作类型" + + handlers = { + # 编辑 + "edit": self._op_edit, + "multi": self._op_multi_edit, + "insert": self._op_insert, + "delete_lines": self._op_delete_lines, + "create": self._op_create, + "write": self._op_write, + "append": self._op_append, + # 查看 + "read_range": self._op_read_range, + "diff": self._op_diff, + "diff_text": self._op_diff_text, + "ast_info": self._op_ast_info, + # 搜索 + "find": self._op_find, + "regex": self._op_regex, + "symbols": self._op_symbols, + "imports": self._op_imports, + "callers": self._op_callers, + "todo": self._op_todo, + "structure": self._op_structure, + "context": self._op_context, + "stats": self._op_stats, + # 语法检查 + "syntax_check": self._op_syntax_check, + "check": self._op_syntax_check, # 简写别名 + # Diff 弹窗 + "diff_popup": self._op_diff_popup, + "popup": self._op_diff_popup, # 简写别名 + } + + handler = handlers.get(operation) + if not handler: + return f"错误：不支持的操作 '{operation}'" + return handler(arg1, arg2) + + except Exception as e: + return f"代码工具错误: {str(e)}" + + # ── 工具方法 ── + + def _norm(self, path: str) -> str: + path = path.strip().strip('"').strip("'") + return os.path.normpath(os.path.expanduser(path)) + + def _walk_files(self, directory: str, pattern: str = "*.py", + max_files: int = 200) -> List[str]: + if pattern.startswith("*."): + ext = pattern[1:] + filt = lambda f: f.endswith(ext) + elif pattern == "*": + filt = lambda f: True + else: + filt = lambda f: pattern in f + + files = [] + skip = {'.git', 'node_modules', '__pycache__', '.venv', 'venv', + 'env', '.tox', '.mypy_cache', '.pytest_cache'} + for root, dirs, fnames in os.walk(directory): + dirs[:] = [d for d in dirs if not d.startswith('.') and d not in skip] + for f in fnames: + if filt(f): + files.append(os.path.join(root, f)) + if len(files) >= max_files: + return files + return files + + def _make_diff(self, old: str, new: str, label: str = "修改") -> str: + diff = difflib.unified_diff( + old.splitlines(keepends=True), new.splitlines(keepends=True), + fromfile="原始", tofile="修改后", lineterm='') + text = '\n'.join(diff) + return f" 变更预览:\n{text}" if text else "内容无变化" + + # ══════════════════════════════════════ + # 语法检查系统 + # ══════════════════════════════════════ + + # 支持语法检查的语言映射 + _CODE_EXTENSIONS = { + '.py': 'python', + '.pyw': 'python', + '.pyi': 'python', + '.js': 'javascript', + '.mjs': 'javascript', + '.cjs': 'javascript', + '.jsx': 'javascript', + '.ts': 'typescript', + '.tsx': 'typescript', + '.mts': 'typescript', + '.json': 'json', + '.jsonl': 'json', + '.jsonc': 'json', + '.yaml': 'yaml', + '.yml': 'yaml', + '.toml': 'toml', + '.html': 'html', + '.htm': 'html', + '.xml': 'xml', + '.css': 'css', + '.sh': 'shell', + '.bash': 'shell', + '.zsh': 'shell', + '.sql': 'sql', + '.md': None, # 不检查 + '.txt': None, + '.csv': None, + '.log': None, + '.gitignore': None, + '.env': None, + } + + def _get_lang(self, filepath: str) -> Optional[str]: + """根据文件扩展名获取语言类型，None 表示跳过检查""" + _, ext = os.path.splitext(filepath.lower()) + return self._CODE_EXTENSIONS.get(ext) + + def _is_code_file(self, filepath: str) -> bool: + """判断是否是需要语法检查的代码文件""" + lang = self._get_lang(filepath) + return lang is not None + + def _check_syntax(self, filepath: str) -> str: + """ + 检查文件语法，返回结果字符串。 + - 通过: 返回空字符串 "" + - 失败: 返回详细的错误信息 + - 跳过: 返回 None + """ + lang = self._get_lang(filepath) + if lang is None: + return None # 非代码文件，跳过 + + if not os.path.exists(filepath): + return None + + try: + with open(filepath, 'r', encoding='utf-8') as f: + source = f.read() + except (UnicodeDecodeError, PermissionError): + return None + + if not source.strip(): + return None # 空文件跳过 + + if lang == 'python': + return self._check_python_syntax(filepath, source) + elif lang == 'javascript': + return self._check_js_syntax(filepath, source) + elif lang == 'typescript': + return self._check_ts_syntax(filepath, source) + elif lang == 'json': + return self._check_json_syntax(filepath, source) + elif lang == 'yaml': + return self._check_yaml_syntax(filepath, source) + elif lang == 'toml': + return self._check_toml_syntax(filepath, source) + elif lang == 'html': + return self._check_html_syntax(filepath, source) + elif lang == 'xml': + return self._check_xml_syntax(filepath, source) + elif lang == 'css': + return self._check_css_syntax(filepath, source) + elif lang == 'shell': + return self._check_shell_syntax(filepath, source) + elif lang == 'sql': + return self._check_sql_syntax(filepath, source) + return None + + def _check_python_syntax(self, filepath: str, source: str) -> str: + """Python 语法检查：ast.parse + py_compile 双重验证""" + errors = [] + + # 方法1: ast.parse（更精确的错误定位） + try: + tree = ast.parse(source, filename=filepath) + except SyntaxError as e: + lineno = e.lineno or 0 + offset = e.offset or 0 + text = (e.text or '').rstrip() + msg = e.msg or 'syntax error' + pointer = ' ' * (offset - 1) + '^' if offset > 0 else '' + errors.append( + f" 第 {lineno} 行, 列 {offset}: {msg}\n" + f" {text}\n" + f" {pointer}" + ) + + # 方法2: py_compile（捕获 ast.parse 可能遗漏的问题） + if not errors: + try: + py_compile.compile(filepath, doraise=True) + except py_compile.PyCompileError as e: + errors.append(f" 编译错误: {e}") + + if errors: + return f" Python 语法检查失败 ({filepath}):\n" + "\n".join(errors) + return "" + + def _check_js_syntax(self, filepath: str, source: str) -> str: + """JavaScript 语法检查：使用 Node.js --check""" + try: + result = subprocess.run( + [sys.executable, '-c', f''' +import json, sys +# 基础 JS 语法检查：括号匹配 +source = {json.dumps(source)} +errors = [] +stack = [] +pairs = {{'(': ')', '[': ']', '{{': '}}'}} +close_to_open = {{v: k for k, v in pairs.items()}} +line = 1 +col = 0 +in_string = None +in_comment = False +in_block_comment = False +prev = '' +for i, ch in enumerate(source): + col += 1 + if ch == '\\n': + line += 1 + col = 0 + in_comment = False + continue + if in_block_comment: + if prev == '*' and ch == '/': + in_block_comment = False + prev = ch + continue + if in_comment: + prev = ch + continue + if prev == '/' and ch == '/': + in_comment = True + prev = ch + continue + if prev == '/' and ch == '*': + in_block_comment = True + prev = ch + continue + if ch in ('"', "'", '`'): + if in_string == ch: + in_string = None + elif not in_string: + in_string = ch + prev = ch + continue + if in_string: + prev = ch + continue + if ch in pairs: + stack.append((ch, line, col)) + elif ch in close_to_open: + if stack and stack[-1][0] == close_to_open[ch]: + stack.pop() + else: + errors.append(f" 第 {{line}} 行, 列 {{col}}: 不匹配的闭合括号 '{{ch}}'") + prev = ch +for open_ch, line, col in stack: + errors.append(f" 第 {{line}} 行, 列 {{col}}: 未闭合的括号 '{{open_ch}}'") +if errors: + print("ERROR:" + "\\n".join(errors)) +else: + print("OK") +'''], + capture_output=True, text=True, timeout=5 + ) + output = result.stdout.strip() + if output.startswith("ERROR:"): + return f" JavaScript 语法检查失败 ({filepath}):\n" + output[6:] + except Exception: + pass + return "" + + def _check_ts_syntax(self, filepath: str, source: str) -> str: + """TypeScript 语法检查：尝试 tsc --noEmit，回退到 JS 检查""" + try: + result = subprocess.run( + ['npx', 'tsc', '--noEmit', '--pretty', 'false', filepath], + capture_output=True, text=True, timeout=10 + ) + if result.returncode != 0 and result.stderr.strip(): + errors = [] + for line in result.stderr.strip().split('\n')[:10]: + if 'error TS' in line: + errors.append(f" {line.strip()}") + if errors: + return f" TypeScript 语法检查失败 ({filepath}):\n" + "\n".join(errors) + except (FileNotFoundError, subprocess.TimeoutExpired): + pass + # 回退到 JS 括号检查 + return self._check_js_syntax(filepath, source) + + def _check_json_syntax(self, filepath: str, source: str) -> str: + """JSON 语法检查""" + try: + json.loads(source) + except json.JSONDecodeError as e: + lineno = e.lineno or 0 + colno = e.colno or 0 + return ( + f" JSON 语法检查失败 ({filepath}):\n" + f" 第 {lineno} 行, 列 {colno}: {e.msg}\n" + f" 文档位置: 字符 {e.pos}" + ) + return "" + + def _check_yaml_syntax(self, filepath: str, source: str) -> str: + """YAML 语法检查""" + try: + import yaml + list(yaml.safe_load_all(source)) + except ImportError: + # 无 PyYAML，用基础检查 + if source.strip().startswith('{') or source.strip().startswith('['): + return self._check_json_syntax(filepath, source) + except yaml.YAMLError as e: + mark = getattr(e, 'problem_mark', None) + if mark: + return ( + f" YAML 语法检查失败 ({filepath}):\n" + f" 第 {mark.line + 1} 行, 列 {mark.column + 1}: {getattr(e, 'problem', str(e))}" + ) + return f" YAML 语法检查失败 ({filepath}):\n {e}" + return "" + + def _check_toml_syntax(self, filepath: str, source: str) -> str: + """TOML 语法检查""" + try: + import tomllib + tomllib.loads(source) + except ImportError: + pass # Python < 3.11 无 tomllib + except Exception as e: + return f" TOML 语法检查失败 ({filepath}):\n {e}" + return "" + + def _check_html_syntax(self, filepath: str, source: str) -> str: + """HTML 基础检查：标签匹配""" + errors = [] + import re as _re + # 匹配开闭标签 + tag_pattern = _re.compile(r'<(/?)(\w+)[^>]*>') + void_tags = {'br', 'hr', 'img', 'input', 'meta', 'link', 'area', + 'base', 'col', 'embed', 'source', 'track', 'wbr'} + stack = [] + for m in tag_pattern.finditer(source): + is_close = m.group(1) == '/' + tag_name = m.group(2).lower() + if tag_name in void_tags: + continue + pos = m.start() + line_num = source[:pos].count('\n') + 1 + if is_close: + if stack and stack[-1][0] == tag_name: + stack.pop() + elif stack: + errors.append( + f" 第 {line_num} 行: 与 <{stack[-1][0]}> 不匹配" + ) + else: + stack.append((tag_name, line_num)) + for tag_name, line_num in stack: + errors.append(f" 第 {line_num} 行: <{tag_name}> 未闭合") + if errors and len(errors) <= 10: + return f" HTML 标签检查 ({filepath}):\n" + "\n".join(errors) + return "" + + def _check_xml_syntax(self, filepath: str, source: str) -> str: + """XML 语法检查：使用 xml.etree""" + import xml.etree.ElementTree as ET + try: + ET.fromstring(source) + except ET.ParseError as e: + return f" XML 语法检查失败 ({filepath}):\n {e}" + return "" + + def _check_css_syntax(self, filepath: str, source: str) -> str: + """CSS 基础检查：花括号匹配""" + errors = [] + depth = 0 + in_string = False + string_char = None + line_num = 1 + for i, ch in enumerate(source): + if ch == '\n': + line_num += 1 + continue + if in_string: + if ch == string_char and (i == 0 or source[i-1] != '\\'): + in_string = False + continue + if ch in ('"', "'"): + in_string = True + string_char = ch + continue + if ch == '{': + depth += 1 + elif ch == '}': + if depth > 0: + depth -= 1 + else: + errors.append(f" 第 {line_num} 行: 多余的闭合花括号 '}}'") + if depth > 0: + errors.append(f" 文件末尾: {depth} 个未闭合的花括号 '{{' ") + if errors: + return f" CSS 括号检查 ({filepath}):\n" + "\n".join(errors) + return "" + + def _check_shell_syntax(self, filepath: str, source: str) -> str: + """Shell 脚本语法检查：使用 bash -n""" + try: + result = subprocess.run( + ['bash', '-n', filepath], + capture_output=True, text=True, timeout=5 + ) + if result.returncode != 0: + stderr = result.stderr.strip() + lines = stderr.split('\n')[:5] + return f" Shell 语法检查失败 ({filepath}):\n" + "\n".join(f" {l}" for l in lines) + except (FileNotFoundError, subprocess.TimeoutExpired): + pass + return "" + + def _check_sql_syntax(self, filepath: str, source: str) -> str: + """SQL 基础检查：关键字匹配""" + # 简单检查未闭合的引号和括号 + errors = [] + single_q = double_q = 0 + paren_depth = 0 + line_num = 1 + for ch in source: + if ch == '\n': + line_num += 1 + continue + if ch == "'": + single_q += 1 + elif ch == '"': + double_q += 1 + elif ch == '(': + paren_depth += 1 + elif ch == ')': + paren_depth -= 1 + if single_q % 2 != 0: + errors.append(" 存在未闭合的单引号") + if double_q % 2 != 0: + errors.append(" 存在未闭合的双引号") + if paren_depth > 0: + errors.append(f" 存在 {paren_depth} 个未闭合的括号") + if errors: + return f" SQL 检查 ({filepath}):\n" + "\n".join(errors) + return "" + + def _auto_syntax_check(self, filepath: str) -> str: + """ + 编辑操作后自动语法检查。 + 返回格式化的结果字符串，供拼接到操作结果末尾。 + - 通过: 返回简短成功提示 + - 失败: 返回详细错误信息 + - 跳过: 返回空字符串 + """ + result = self._check_syntax(filepath) + if result is None: + return "" # 非代码文件，不检查 + if result == "": + return f"\n 语法检查通过 ✓" + else: + return f"\n{result}" + + # ══════════════════════════════════════ + # Diff 弹窗系统 + # ══════════════════════════════════════ + + def _read_file_safe(self, filepath: str) -> str: + """安全读取文件，失败返回空字符串""" + try: + with open(filepath, 'r', encoding='utf-8') as f: + return f.read() + except Exception: + return "" + + def _spawn_diff_popup(self, filepath: str, before: str, after: str): + """ + 显示修改前后的对比。 + 根据 diff_popup_mode 决定弹窗还是主终端内显示。 + """ + if not self.diff_popup_enabled: + return + if before == after: + return # 内容无变化，不弹窗 + + # 启动时未选择模式，默认为主终端内显示（SSH 兼容） + popup = self.diff_popup_mode if self.diff_popup_mode is not None else False + + if popup: + thread = threading.Thread( + target=self._do_spawn_diff_popup, + args=(filepath, before, after), + daemon=True + ) + thread.start() + else: + self._show_inline_diff(filepath, before, after) + + def _do_spawn_diff_popup(self, filepath: str, before: str, after: str): + """实际执行弹窗创建（在子线程中运行）""" + basename = os.path.basename(filepath) + + # 生成带行号的 before/after + before_numbered = self._number_lines(before) + after_numbered = self._number_lines(after) + + # 生成 diff + diff_lines = list(difflib.unified_diff( + before.splitlines(keepends=True), + after.splitlines(keepends=True), + fromfile=f"修改前: {basename}", + tofile=f"修改后: {basename}", + lineterm='' + )) + + # 统计变更 + added = sum(1 for l in diff_lines if l.startswith('+') and not l.startswith('+++')) + removed = sum(1 for l in diff_lines if l.startswith('-') and not l.startswith('---')) + + before_count = len(before.splitlines()) + after_count = len(after.splitlines()) + + # 构建弹窗显示内容 + display = self._build_diff_display( + basename, filepath, + before_numbered, after_numbered, + diff_lines, added, removed, + before_count, after_count + ) + + # 写入临时脚本并弹出 + self._launch_popup_window(display, basename) + + def _number_lines(self, content: str) -> str: + """给内容加上行号""" + lines = content.splitlines() + width = len(str(len(lines))) + return '\n'.join(f"{i+1:>{width}} | {line}" for i, line in enumerate(lines)) + + def _build_diff_display(self, basename, filepath, + before_numbered, after_numbered, + diff_lines, added, removed, + before_count, after_count): + """构建完整的 diff 显示文本（带 ANSI 颜色）""" + sep = '═' * 70 + thin_sep = '─' * 70 + + # ANSI 颜色 + R = '\033[31m' # 红字 + G = '\033[32m' # 绿字 + C = '\033[36m' # 青 + B = '\033[1m' # 粗体 + D = '\033[2m' # 暗 + W = '\033[37m' # 白 + N = '\033[0m' # 重置 + RBG = '\033[41m\033[97m' # 红底白字 + GBG = '\033[42m\033[97m' # 绿底白字 + + # 构建带颜色的 diff + diff_colored_lines = [] + for line in diff_lines: + if line.startswith('@@'): + diff_colored_lines.append(f"{C}{line}{N}") + elif line.startswith('+++') or line.startswith('---'): + diff_colored_lines.append(f"{B}{line}{N}") + elif line.startswith('+'): + diff_colored_lines.append(f"{GBG} {line} {N}") + elif line.startswith('-'): + diff_colored_lines.append(f"{RBG} {line} {N}") + else: + diff_colored_lines.append(line) + diff_colored = '\n'.join(diff_colored_lines) if diff_colored_lines else ' (无差异)' + + display = f""" +{W}{sep}{N} +{B} 文件变更对比: {basename}{N} +{D} 路径: {filepath}{N} +{W}{sep}{N} + + 统计: {before_count} 行 → {after_count} 行 | {G}+{added} 新增{N} {R}-{removed} 删除{N} + +{W}{thin_sep}{N} + 修改前 ({before_count} 行): +{W}{thin_sep}{N} +{before_numbered} + +{W}{thin_sep}{N} + 修改后 ({after_count} 行): +{W}{thin_sep}{N} +{after_numbered} + +{W}{thin_sep}{N} + 差异 (Diff): +{W}{thin_sep}{N} +{diff_colored} + +{W}{sep}{N} + 按任意键关闭此窗口... +{W}{sep}{N} +""" + return display + + def _launch_popup_window(self, display_text: str, title: str): + """根据平台弹出新终端窗口""" + # 写入临时显示脚本 + try: + script_fd, script_path = tempfile.mkstemp(suffix='.py', prefix='xiaoli_diff_') + with os.fdopen(script_fd, 'w', encoding='utf-8') as f: + # 写入显示内容到脚本 + escaped = display_text.replace('\\', '\\\\').replace("'", "\\'") + f.write(f"#!/usr/bin/env python3\n") + f.write(f"# -*- coding: utf-8 -*-\n") + f.write(f"import sys\n") + f.write(f"text = '''{escaped}'''\n") + f.write(f"try:\n") + f.write(f" sys.stdout.reconfigure(encoding='utf-8')\n") + f.write(f"except Exception:\n") + f.write(f" pass\n") + f.write(f"print(text)\n") + f.write(f"try:\n") + f.write(f" input()\n") + f.write(f"except (EOFError, KeyboardInterrupt):\n") + f.write(f" pass\n") + + system = platform.system() + + if system == 'Windows': + # Windows: 新开 cmd 窗口 + subprocess.Popen( + ['cmd', '/c', 'start', 'cmd', '/k', sys.executable, script_path], + creationflags=subprocess.CREATE_NEW_CONSOLE, + shell=False + ) + elif system == 'Darwin': + # macOS: 用 osascript 打开 Terminal.app + apple_script = ( + f'tell application "Terminal"\n' + f' activate\n' + f' do script "{sys.executable} {script_path}"\n' + f'end tell' + ) + subprocess.Popen(['osascript', '-e', apple_script]) + else: + # Linux: 尝试多个终端模拟器 + terminals = [ + ['gnome-terminal', '--', sys.executable, script_path], + ['xterm', '-e', sys.executable, script_path], + ['konsole', '-e', sys.executable, script_path], + ['xfce4-terminal', '-e', f'{sys.executable} {script_path}'], + ['lxterminal', '-e', sys.executable, script_path], + ['mate-terminal', '-e', sys.executable, script_path], + ] + launched = False + for cmd in terminals: + try: + subprocess.Popen(cmd, start_new_session=True) + launched = True + break + except FileNotFoundError: + continue + if not launched: + # 兜底: 用 xdg-open 不太行，直接打印到当前终端 + print(f"\n[Diff 弹窗] 无可用终端模拟器，直接输出:\n") + print(display_text) + try: + os.unlink(script_path) + except Exception: + pass + + except Exception as e: + print(f"[Diff 弹窗] 创建失败: {e}") + + def _show_inline_diff(self, filepath: str, before: str, after: str): + """在主终端内显示 diff（SSH 兼容模式），带颜色""" + basename = os.path.basename(filepath) + is_tui = False + + # 生成 diff + diff_lines = list(difflib.unified_diff( + before.splitlines(keepends=True), + after.splitlines(keepends=True), + fromfile=f"修改前: {basename}", + tofile=f"修改后: {basename}", + lineterm='' + )) + + # 统计 + added = sum(1 for l in diff_lines if l.startswith('+') and not l.startswith('+++')) + removed = sum(1 for l in diff_lines if l.startswith('-') and not l.startswith('---')) + before_count = len(before.splitlines()) + after_count = len(after.splitlines()) + + sep = '═' * 60 + thin = '─' * 60 + + if is_tui: # 永远为 False，保留 else 分支 + pass + output = self.cli._output + output(f"[dim]{sep}[/]") + output(f"[bold cyan] 文件变更: {basename}[/] [dim]{filepath}[/]") + output(f"[dim]{sep}[/]") + output(f"[bold] 统计: {before_count} 行 → {after_count} 行 | " + f"[green]+{added} 新增[/] [red]-{removed} 删除[/]") + output(f"[dim]{thin}[/]") + + for line in diff_lines: + if line.startswith('@@'): + output(f"[cyan]{line}[/]") + elif line.startswith('+++') or line.startswith('---'): + output(f"[bold]{line}[/]") + elif line.startswith('+'): + output(f"[white on green] {line} [/]") + elif line.startswith('-'): + output(f"[white on red] {line} [/]") + else: + output(line) + + output(f"[dim]{sep}[/]") + else: + # CLI 模式：使用 ANSI 颜色 + from colorama import Fore, Style + _out = print + + _out(f"{Fore.WHITE}{sep}{Style.RESET_ALL}") + _out(f"{Fore.CYAN} 文件变更: {basename}{Style.RESET_ALL} {filepath}") + _out(f"{Fore.WHITE}{sep}{Style.RESET_ALL}") + _out(f" 统计: {before_count} 行 → {after_count} 行 | " + f"{Fore.GREEN}+{added} 新增{Style.RESET_ALL} " + f"{Fore.RED}-{removed} 删除{Style.RESET_ALL}") + _out(f"{Fore.WHITE}{thin}{Style.RESET_ALL}") + + for line in diff_lines: + if line.startswith('@@'): + _out(f"{Fore.CYAN}{line}{Style.RESET_ALL}") + elif line.startswith('+++') or line.startswith('---'): + _out(f"{Style.BRIGHT}{line}{Style.RESET_ALL}") + elif line.startswith('+'): + _out(f"\033[42m\033[97m {line} {Style.RESET_ALL}") + elif line.startswith('-'): + _out(f"\033[41m\033[97m {line} {Style.RESET_ALL}") + else: + _out(line) + + _out(f"{Fore.WHITE}{sep}{Style.RESET_ALL}") + + def _op_diff_popup(self, path: str, rest: str) -> str: + """切换 diff 弹窗开关 / 设置显示模式""" + arg = (path + ' ' + rest).strip().lower() + if arg in ('on', '开', '开启', 'enable', '1', 'true'): + self.diff_popup_enabled = True + return " Diff 弹窗已开启" + elif arg in ('off', '关', '关闭', 'disable', '0', 'false'): + self.diff_popup_enabled = False + return " Diff 弹窗已关闭" + elif arg in ('popup', '弹窗', '弹窗模式'): + self.diff_popup_enabled = True + self.diff_popup_mode = True + return " Diff 模式: 弹窗（新终端窗口）" + elif arg in ('inline', '内联', 'ssh', '终端', '主终端'): + self.diff_popup_enabled = True + self.diff_popup_mode = False + return " Diff 模式: 主终端内显示（SSH 兼容）" + else: + # 无参数：切换状态 + self.diff_popup_enabled = not self.diff_popup_enabled + state = "开启" if self.diff_popup_enabled else "关闭" + return f" Diff 弹窗: {state}" + + def _op_syntax_check(self, path: str, rest: str) -> str: + """主动语法检查操作""" + if not path: + return "错误：请提供文件路径。用法: syntax_check <文件路径>" + fp = self._norm(path) + if not os.path.exists(fp): + return f"错误：文件不存在: {fp}" + + lang = self._get_lang(fp) + if lang is None: + return f"⏭ 跳过: {fp} (不支持的文件类型，无需语法检查)" + + result = self._check_syntax(fp) + if result is None: + return f"⏭ 跳过: {fp} (无法读取文件)" + if result == "": + return f" 语法检查通过 ✓ ({fp})\n 语言: {lang}" + else: + return result + + # ══════════════════════════════════════ + # 编辑操作 + # ══════════════════════════════════════ + + def _op_edit(self, path: str, rest: str) -> str: + if not path: + return "错误：请提供文件路径" + fp = self._norm(path) + if not os.path.exists(fp): + return f"错误：文件不存在: {fp}" + + sep = " <<<>>> " + if sep not in rest: + return "错误：格式: edit <文件> <<<>>> " + + old_text, new_text = rest.split(sep, 1) + old_text = old_text.strip() + new_text = new_text.strip() + if not old_text: + return "错误：old_text 不能为空" + + with open(fp, 'r', encoding='utf-8') as f: + content = f.read() + + if old_text not in content: + # 模糊匹配提示 + lines = content.split('\n') + old_lines = old_text.split('\n') + best_ratio, best_pos = 0, None + for i in range(len(lines) - len(old_lines) + 1): + candidate = lines[i:i+len(old_lines)] + ratio = difflib.SequenceMatcher( + None, ''.join(candidate), ''.join(old_lines)).ratio() + if ratio > best_ratio: + best_ratio = ratio + best_pos = i + 1 + if best_ratio > 0.6: + return f"错误：未找到精确匹配。最接近位置在第 {best_pos} 行 (相似度 {best_ratio:.0%})，请检查缩进。" + return "错误：未找到要替换的内容，请确保文本完全匹配（包括缩进）。" + + count = content.count(old_text) + if count > 1: + return f"警告：找到 {count} 处匹配，请提供更多上下文以确保唯一。" + + before_content = content # 保存修改前内容 + new_content = content.replace(old_text, new_text, 1) + with open(fp, 'w', encoding='utf-8') as f: + f.write(new_content) + + self._spawn_diff_popup(fp, before_content, new_content) + result = f" 已编辑: {fp}\n\n{self._make_diff(old_text, new_text)}" + result += self._auto_syntax_check(fp) + return result + + def _op_multi_edit(self, path: str, rest: str) -> str: + import json + if not path: + return "错误：请提供文件路径" + fp = self._norm(path) + if not os.path.exists(fp): + return f"错误：文件不存在: {fp}" + + try: + ops = json.loads(rest) + except json.JSONDecodeError: + return "错误：JSON 格式: [{\"old\": \"...\", \"new\": \"...\"}]" + if not isinstance(ops, list): + return "错误：operations 必须是数组" + + with open(fp, 'r', encoding='utf-8') as f: + content = f.read() + + before_content = content # 保存修改前内容 + results = [] + for i, op in enumerate(ops): + old = op.get("old", "").strip() + new = op.get("new", "").strip() + if not old: + results.append(f" 操作 {i+1}: old 为空") + elif old not in content: + results.append(f" 操作 {i+1}: 未找到匹配") + else: + content = content.replace(old, new, 1) + results.append(f" 操作 {i+1}: 已替换") + + with open(fp, 'w', encoding='utf-8') as f: + f.write(content) + self._spawn_diff_popup(fp, before_content, content) + result = f" 批量编辑: {fp}\n" + "\n".join(results) + result += self._auto_syntax_check(fp) + return result + + def _op_insert(self, path: str, rest: str) -> str: + if not path: + return "错误：请提供文件路径" + fp = self._norm(path) + if not os.path.exists(fp): + return f"错误：文件不存在: {fp}" + + parts = rest.split(maxsplit=1) + if len(parts) < 2: + return "错误：格式: insert <文件> <行号> <内容>" + try: + line_num = int(parts[0]) + except ValueError: + return "错误：行号必须是整数" + + with open(fp, 'r', encoding='utf-8') as f: + lines = f.readlines() + + if line_num < 1 or line_num > len(lines) + 1: + return f"错误：行号超出范围 (1-{len(lines)+1})" + + before_content = ''.join(lines) # 保存修改前内容 + insert_lines = [l + '\n' for l in parts[1].strip().split('\n')] + lines[line_num-1:line_num-1] = insert_lines + + with open(fp, 'w', encoding='utf-8') as f: + f.writelines(lines) + after_content = ''.join(lines) + self._spawn_diff_popup(fp, before_content, after_content) + result = f" 已在第 {line_num} 行插入 {len(insert_lines)} 行" + result += self._auto_syntax_check(fp) + return result + + def _op_delete_lines(self, path: str, rest: str) -> str: + if not path: + return "错误：请提供文件路径" + fp = self._norm(path) + if not os.path.exists(fp): + return f"错误：文件不存在: {fp}" + + parts = rest.split() + if len(parts) < 2: + return "错误：格式: delete_lines <文件> <起始行> <结束行>" + try: + start, end = int(parts[0]), int(parts[1]) + except ValueError: + return "错误：行号必须是整数" + + with open(fp, 'r', encoding='utf-8') as f: + lines = f.readlines() + + if start < 1 or end > len(lines) or start > end: + return f"错误：行号范围无效 (1-{len(lines)})" + + before_content = ''.join(lines) # 保存修改前内容 + deleted = lines[start-1:end] + lines[start-1:end] = [] + + with open(fp, 'w', encoding='utf-8') as f: + f.writelines(lines) + after_content = ''.join(lines) + self._spawn_diff_popup(fp, before_content, after_content) + result = f" 已删除第 {start}-{end} 行 ({len(deleted)} 行)" + result += self._auto_syntax_check(fp) + return result + + def _op_create(self, path: str, rest: str) -> str: + if not path: + return "错误：请提供文件路径" + fp = self._norm(path) + if os.path.exists(fp): + return f"错误：文件已存在: {fp}" + dir_path = os.path.dirname(fp) + if dir_path: + os.makedirs(dir_path, exist_ok=True) + with open(fp, 'w', encoding='utf-8') as f: + f.write(rest or "") + self._spawn_diff_popup(fp, "", rest or "") + result = f" 已创建: {fp} ({len(rest or '')} 字符)" + result += self._auto_syntax_check(fp) + return result + + def _op_write(self, path: str, rest: str) -> str: + if not path: + return "错误：请提供文件路径" + fp = self._norm(path) + dir_path = os.path.dirname(fp) + if dir_path: + os.makedirs(dir_path, exist_ok=True) + before_content = self._read_file_safe(fp) # 保存修改前内容 + with open(fp, 'w', encoding='utf-8') as f: + f.write(rest) + self._spawn_diff_popup(fp, before_content, rest) + result = f" 已写入: {fp} ({len(rest)} 字符)" + result += self._auto_syntax_check(fp) + return result + + def _op_append(self, path: str, rest: str) -> str: + if not path: + return "错误：请提供文件路径" + fp = self._norm(path) + if not os.path.exists(fp): + return f"错误：文件不存在: {fp}" + before_content = self._read_file_safe(fp) # 保存修改前内容 + with open(fp, 'a', encoding='utf-8') as f: + f.write(rest) + after_content = self._read_file_safe(fp) + self._spawn_diff_popup(fp, before_content, after_content) + result = f" 已追加: {fp} ({len(rest)} 字符)" + result += self._auto_syntax_check(fp) + return result + + # ══════════════════════════════════════ + # 查看操作 + # ══════════════════════════════════════ + + def _op_read_range(self, path: str, rest: str) -> str: + if not path: + return "错误：请提供文件路径" + fp = self._norm(path) + if not os.path.exists(fp): + return f"错误：文件不存在: {fp}" + + parts = rest.split() + start = int(parts[0]) if parts else 1 + end = int(parts[1]) if len(parts) > 1 else None + + with open(fp, 'r', encoding='utf-8') as f: + lines = f.readlines() + + total = len(lines) + end = end or total + start = max(1, min(start, total)) + end = max(start, min(end, total)) + + selected = lines[start-1:end] + numbered = [f"{start+i:4d} | {line.rstrip()}" for i, line in enumerate(selected)] + return f" {fp} (第 {start}-{end} 行，共 {total} 行)\n{'─'*60}\n" + '\n'.join(numbered) + + def _op_diff(self, path: str, rest: str) -> str: + if not path: + return "错误：请提供第一个文件路径" + if not rest.strip(): + return "错误：请提供第二个文件路径" + f1 = self._norm(path) + f2 = self._norm(rest.split()[0]) + if not os.path.exists(f1): + return f"错误：文件不存在: {f1}" + if not os.path.exists(f2): + return f"错误：文件不存在: {f2}" + + with open(f1, 'r', encoding='utf-8') as f: + l1 = f.readlines() + with open(f2, 'r', encoding='utf-8') as f: + l2 = f.readlines() + + diff = '\n'.join(difflib.unified_diff(l1, l2, fromfile=f1, tofile=f2, lineterm='')) + return diff or "两个文件完全相同" + + def _op_diff_text(self, old: str, new: str) -> str: + if not old and not new: + return "错误：格式: diff_text <<<>>> " + return self._make_diff(old.strip(), new.strip()) + + def _op_ast_info(self, path: str, rest: str) -> str: + if not path: + return "错误：请提供文件路径" + fp = self._norm(path) + if not os.path.exists(fp): + return f"错误：文件不存在: {fp}" + + with open(fp, 'r', encoding='utf-8') as f: + source = f.read() + try: + tree = ast.parse(source) + except SyntaxError as e: + return f"错误：语法错误 - {e}" + + info = [f" {fp} AST 摘要:"] + for node in ast.iter_child_nodes(tree): + if isinstance(node, ast.ClassDef): + methods = [n.name for n in ast.iter_child_nodes(node) + if isinstance(n, (ast.FunctionDef, ast.AsyncFunctionDef))] + info.append(f" class {node.name} (行 {node.lineno})") + for m in methods: + info.append(f" └─ {m}()") + elif isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)): + info.append(f" def {node.name}() (行 {node.lineno})") + elif isinstance(node, ast.Import): + info.append(f" import {', '.join(a.name for a in node.names)}") + elif isinstance(node, ast.ImportFrom): + info.append(f" from {node.module} import {', '.join(a.name for a in node.names)}") + + return '\n'.join(info) if len(info) > 1 else f" {fp}: 文件为空" + + # ══════════════════════════════════════ + # 搜索操作 + # ══════════════════════════════════════ + + def _op_find(self, directory: str, rest: str) -> str: + if not directory: + return "错误：请提供搜索目录" + search_dir = self._norm(directory) + parts = rest.split(maxsplit=1) + keyword = parts[0] if parts else "" + file_pattern = parts[1] if len(parts) > 1 else "*.py" + if not keyword: + return "错误：请提供搜索关键词" + if not os.path.isdir(search_dir): + return f"错误：目录不存在: {search_dir}" + + files = self._walk_files(search_dir, file_pattern) + results = [] + for fp in files: + try: + with open(fp, 'r', encoding='utf-8') as f: + for line_num, line in enumerate(f, 1): + if keyword.lower() in line.lower(): + rel = os.path.relpath(fp, search_dir) + results.append(f" {rel}:{line_num}: {line.rstrip()}") + if len(results) >= 80: + break + except (UnicodeDecodeError, PermissionError): + continue + if len(results) >= 80: + break + + if not results: + return f"未找到 '{keyword}' 的匹配" + return f" 搜索 '{keyword}' ({len(results)}{'+' if len(results) >= 80 else ''} 匹配):\n" + '\n'.join(results) + + def _op_regex(self, directory: str, rest: str) -> str: + if not directory: + return "错误：请提供搜索目录" + search_dir = self._norm(directory) + parts = rest.split(maxsplit=1) + pattern = parts[0] if parts else "" + file_pattern = parts[1] if len(parts) > 1 else "*.py" + if not pattern: + return "错误：请提供正则表达式" + try: + regex = re.compile(pattern) + except re.error as e: + return f"错误：无效的正则: {e}" + + files = self._walk_files(search_dir, file_pattern) + results = [] + for fp in files: + try: + with open(fp, 'r', encoding='utf-8') as f: + for line_num, line in enumerate(f, 1): + if regex.search(line): + rel = os.path.relpath(fp, search_dir) + results.append(f" {rel}:{line_num}: {line.rstrip()}") + if len(results) >= 50: + break + except (UnicodeDecodeError, PermissionError): + continue + if len(results) >= 50: + break + + if not results: + return f"未找到匹配 '{pattern}'" + return f" 正则搜索 ({len(results)}{'+' if len(results) >= 50 else ''} 匹配):\n" + '\n'.join(results) + + def _op_symbols(self, directory: str, rest: str) -> str: + if not directory: + return "错误：请提供目录路径" + search_dir = self._norm(directory) + file_pattern = rest.strip() or "*.py" + files = self._walk_files(search_dir, file_pattern) + all_symbols = [] + + for fp in files: + if not fp.endswith('.py'): + continue + try: + with open(fp, 'r', encoding='utf-8') as f: + tree = ast.parse(f.read()) + rel = os.path.relpath(fp, search_dir) + symbols = [] + for node in ast.iter_child_nodes(tree): + if isinstance(node, ast.ClassDef): + methods = [n.name for n in ast.iter_child_nodes(node) + if isinstance(n, (ast.FunctionDef, ast.AsyncFunctionDef))] + symbols.append(f" class {node.name} (行 {node.lineno})") + for m in methods[:10]: + symbols.append(f" └─ {m}()") + elif isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)): + symbols.append(f" def {node.name}() (行 {node.lineno})") + if symbols: + all_symbols.append(f"\n {rel}:") + all_symbols.extend(symbols) + except (SyntaxError, UnicodeDecodeError): + continue + + return " 代码符号:\n" + '\n'.join(all_symbols) if all_symbols else "未找到 Python 符号" + + def _op_imports(self, file_path: str, rest: str) -> str: + if not file_path: + return "错误：请提供文件路径" + path = self._norm(file_path) + if not os.path.exists(path): + return f"错误：文件不存在: {path}" + + with open(path, 'r', encoding='utf-8') as f: + tree = ast.parse(f.read()) + + imports = [] + for node in ast.iter_child_nodes(tree): + if isinstance(node, ast.Import): + imports.append(f" import {', '.join(a.name for a in node.names)} (行 {node.lineno})") + elif isinstance(node, ast.ImportFrom): + names = ', '.join(a.name for a in node.names) + imports.append(f" from {node.module} import {names} (行 {node.lineno})") + + return f" {file_path} 导入:\n" + '\n'.join(imports) if imports else f" {file_path}: 没有导入" + + def _op_callers(self, directory: str, rest: str) -> str: + if not directory: + return "错误：请提供搜索目录" + search_dir = self._norm(directory) + parts = rest.split(maxsplit=1) + func_name = parts[0] if parts else "" + file_pattern = parts[1] if len(parts) > 1 else "*.py" + if not func_name: + return "错误：请提供函数名" + + patterns = [ + re.compile(rf'\b{re.escape(func_name)}\s*\('), + re.compile(rf'\.{re.escape(func_name)}\s*\('), + ] + files = self._walk_files(search_dir, file_pattern) + results = [] + for fp in files: + try: + with open(fp, 'r', encoding='utf-8') as f: + for line_num, line in enumerate(f, 1): + if any(p.search(line) for p in patterns): + rel = os.path.relpath(fp, search_dir) + results.append(f" {rel}:{line_num}: {line.rstrip()}") + except (UnicodeDecodeError, PermissionError): + continue + + return f" '{func_name}' 的调用 ({len(results)}):\n" + '\n'.join(results) if results else f"未找到调用 '{func_name}'" + + def _op_todo(self, directory: str, rest: str) -> str: + if not directory: + return "错误：请提供目录路径" + search_dir = self._norm(directory) + file_pattern = rest.strip() or "*.py" + pattern = re.compile(r'#\s*(TODO|FIXME|HACK|XXX|BUG|NOTE)\b[:\s]*(.*)', re.IGNORECASE) + files = self._walk_files(search_dir, file_pattern) + results = [] + for fp in files: + try: + with open(fp, 'r', encoding='utf-8') as f: + for line_num, line in enumerate(f, 1): + m = pattern.search(line) + if m: + rel = os.path.relpath(fp, search_dir) + results.append(f" {rel}:{line_num} [{m.group(1).upper()}] {m.group(2).strip()}") + except (UnicodeDecodeError, PermissionError): + continue + + return f" TODO/FIXME ({len(results)}):\n" + '\n'.join(results) if results else "没有 TODO/FIXME" + + def _op_structure(self, directory: str, rest: str) -> str: + if not directory: + return "错误：请提供目录路径" + search_dir = self._norm(directory) + if not os.path.isdir(search_dir): + return f"错误：目录不存在: {search_dir}" + + max_depth = int(rest) if rest.strip().isdigit() else 3 + lines = [f" {os.path.basename(search_dir)}/"] + skip = {'.git', 'node_modules', '__pycache__', '.venv', 'venv', 'env', '.tox'} + + def _tree(path, prefix="", depth=0): + if depth >= max_depth: + return + try: + entries = sorted(os.listdir(path)) + except PermissionError: + return + dirs = [e for e in entries if os.path.isdir(os.path.join(path, e)) + and e not in skip and not e.startswith('.')] + files = [e for e in entries if os.path.isfile(os.path.join(path, e))] + if len(files) > 20: + files = files[:20] + [f"... ({len(files)-20} more)"] + + for i, d in enumerate(dirs): + is_last = (i == len(dirs) - 1) and not files + lines.append(f"{prefix}{'└── ' if is_last else '├── '}{d}/") + _tree(os.path.join(path, d), prefix + (" " if is_last else "│ "), depth + 1) + + for i, f in enumerate(files): + is_last = i == len(files) - 1 + size = os.path.getsize(os.path.join(path, f)) + size_str = f" ({size//1024}KB)" if size > 1024 else f" ({size}B)" + lines.append(f"{prefix}{'└── ' if is_last else '├── '}{f}{size_str}") + + _tree(search_dir) + return '\n'.join(lines) + + def _op_context(self, file_path: str, rest: str) -> str: + if not file_path: + return "错误：请提供文件路径" + path = self._norm(file_path) + if not os.path.exists(path): + return f"错误：文件不存在: {path}" + + parts = rest.split() + line_num = int(parts[0]) if parts else 1 + ctx = int(parts[1]) if len(parts) > 1 else 5 + + with open(path, 'r', encoding='utf-8') as f: + lines = f.readlines() + + total = len(lines) + start = max(1, line_num - ctx) + end = min(total, line_num + ctx) + + result = [f" {path} 第 {start}-{end} 行 (目标: 第 {line_num} 行):", "─" * 60] + for i in range(start - 1, end): + marker = ">>>" if i + 1 == line_num else " " + result.append(f"{marker} {i+1:4d} | {lines[i].rstrip()}") + + return '\n'.join(result) + + def _op_stats(self, directory: str, rest: str) -> str: + if not directory: + return "错误：请提供目录路径" + search_dir = self._norm(directory) + files = self._walk_files(search_dir, "*.py") + + total = blank = comment = code = 0 + for fp in files: + try: + with open(fp, 'r', encoding='utf-8') as f: + for line in f: + total += 1 + s = line.strip() + if not s: + blank += 1 + elif s.startswith('#'): + comment += 1 + else: + code += 1 + except (UnicodeDecodeError, PermissionError): + continue + + return (f" 代码统计 ({search_dir}):\n" + f" 文件: {len(files)}\n" + f" 总行: {total}\n" + f" 代码: {code}\n" + f" 注释: {comment}\n" + f" 空行: {blank}\n" + f" 注释率: {comment/max(code,1)*100:.1f}%") diff --git a/plugins/compile_check.py b/plugins/compile_check.py new file mode 100644 index 0000000..9e93590 --- /dev/null +++ b/plugins/compile_check.py @@ -0,0 +1,564 @@ +""" +编译验证插件 - 批量语法/编译检查 +对项目内 Python 文件做 ast.parse + py_compile 双重验证， +支持按目录、单文件或全项目扫描，并发执行加速。 +""" +import os +import sys +import ast +import time +import shutil +import py_compile +import concurrent.futures +from pathlib import Path +from typing import List, Tuple, Optional + +sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) +from xcli_core.tool_result import ToolResult, ErrorCode + +try: + from colorama import Fore, Style, init as _colorama_init + _colorama_init(autoreset=False) + _HAS_COLOR = True +except Exception: + _HAS_COLOR = False + + class _Stub: + def __getattr__(self, _): return "" + Fore = Style = _Stub() + +PROJECT_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) + +SKIP_DIRS = { + "__pycache__", ".git", ".venv", "venv", "env", ".env", + "node_modules", ".idea", ".vscode", "dist", "build", + ".mypy_cache", ".pytest_cache", ".ruff_cache", "site-packages", +} + +SKIP_FILES = { + "setup.py", +} + + +class Liugin: + """编译验证 - 批量语法检查 / 编译验证 / 清理 __pycache__""" + + def __init__(self): + self.usage = """编译验证工具 + +操作: + all - 验证项目内全部 Python 文件 + core - 仅验证 xcli_core/ 目录 + engines - 仅验证 ai_engines/ 目录 + plugins - 仅验证 plugins/ 目录 + dir <目录> - 验证指定目录 + check <文件> - 验证单个文件 (可多次指定) + clean [目录] - 清理 __pycache__ (默认项目根) + stats - 统计各目录 Python 文件数量 + +选项: + -v / --verbose - 显示每个文件的结果 + -j / --jobs - 并发线程数 (默认 8) + -q / --quiet - 仅在结束时打印汇总 + +输出: + ✅ 绿色 = 通过 + ❌ 红色 = 失败 + 汇总: 总数/通过/失败 + 失败文件详情 + +示例: + check all -v + check core + check plugins/compile_check.py + check dir ai_engines -j 16 + check clean +""" + self.cli = None + + def set_cli(self, cli): + self.cli = cli + + def get_tool_info(self): + return { + "name": "compile_check", + "description": "编译验证工具 — 批量语法/编译检查(ast.parse + py_compile)，支持目录、单文件、全项目扫描，并发加速，清理 __pycache__", + "keywords": ["编译", "验证", "语法", "检查", "compile", "syntax", + "check", "lint", "py_compile", "ast", "批量", + "validate", "verify", "clean", "pycache"], + "usage": self.usage, + } + + def get_mcp_definition(self): + return { + "name": "compile_check", + "description": "编译验证工具", + "inputSchema": { + "type": "object", + "properties": { + "operation": { + "type": "string", + "enum": ["all", "core", "engines", "plugins", + "dir", "check", "clean", "stats"], + "description": "操作类型" + }, + "path": {"type": "string", + "description": "目录或文件路径"}, + "paths": {"type": "array", + "items": {"type": "string"}, + "description": "多文件路径列表"}, + "verbose": {"type": "boolean", "default": False}, + "jobs": {"type": "integer", "default": 8}, + "quiet": {"type": "boolean", "default": False}, + }, + "required": ["operation"] + } + } + + def convert_mcp_args(self, arguments): + op = arguments.get("operation", "") + path = arguments.get("path", "") + return f"{op} {path}".strip() + + def handle(self, args: str): + try: + parts = self._parse_args(args) + if not parts: + return self._print_usage() + + operation = parts[0].lower() + opts = self._extract_options(parts[1:]) + + if operation in ("help", "-h", "--help"): + return self._print_usage() + + routes = { + "all": self._op_all, + "core": self._op_core, + "engines": self._op_engines, + "plugins": self._op_plugins, + "dir": self._op_dir, + "check": self._op_check, + "clean": self._op_clean, + "stats": self._op_stats, + } + handler = routes.get(operation) + if not handler: + return ToolResult.fail( + f"不支持的操作 '{operation}'", + ErrorCode.UNSUPPORTED_OP, + tool_name="compile_check", + ) + return handler(opts) + + except Exception as e: + return ToolResult.fail( + f"编译验证错误: {e}", + ErrorCode.EXEC_FAILED, + tool_name="compile_check", + ) + + def _print_usage(self): + self._emit(self.usage) + return ToolResult.ok("usage_printed", tool_name="compile_check") + + def _out(self, msg: str): + """统一输出""" + if self.cli is not None and hasattr(self.cli, "_output"): + self.cli._output(msg) + else: + print(msg) + + def _emit(self, msg: str, end: str = "\n"): + """统一输出，适配 CLI + + - CLI 模式: 直接输出，尊重 end，支持 end="" 的进度条刷新 + """ + if self.cli is not None and hasattr(self.cli, "_output"): + self.cli._output(msg) + else: + print(msg, end=end) + + def _ok(self, msg: str) -> str: + return f"{Fore.GREEN}{msg}{Style.RESET_ALL}" + + def _err(self, msg: str) -> str: + return f"{Fore.RED}{msg}{Style.RESET_ALL}" + + def _warn(self, msg: str) -> str: + return f"{Fore.YELLOW}{msg}{Style.RESET_ALL}" + + def _dim(self, msg: str) -> str: + return f"{Fore.CYAN}{msg}{Style.RESET_ALL}" + + def _banner(self, title: str) -> str: + bar = "═" * max(20, len(title) + 4) + return f"{Fore.CYAN}{bar}\n {title}\n{bar}{Style.RESET_ALL}" + + def _parse_args(self, args: str) -> List[str]: + parts, current, in_quotes, qc = [], "", False, None + for ch in args: + if ch in ('"', "'") and not in_quotes: + in_quotes, qc = True, ch + elif ch == qc and in_quotes: + in_quotes, qc = False, None + elif ch == " " and not in_quotes: + if current: + parts.append(current) + current = "" + else: + current += ch + if current: + parts.append(current) + return parts + + def _extract_options(self, args: List[str]) -> dict: + opts = { + "positional": [], + "verbose": False, + "quiet": False, + "jobs": 8, + } + i = 0 + while i < len(args): + a = args[i] + if a in ("-v", "--verbose"): + opts["verbose"] = True + elif a in ("-q", "--quiet"): + opts["quiet"] = True + elif a in ("-j", "--jobs") and i + 1 < len(args): + try: + opts["jobs"] = max(1, int(args[i + 1])) + except ValueError: + pass + i += 1 + elif not a.startswith("-"): + opts["positional"].append(a) + i += 1 + return opts + + def _collect_py_files(self, root: str) -> List[str]: + root = os.path.abspath(root) + if not os.path.isdir(root): + return [] + result: List[str] = [] + for dirpath, dirnames, filenames in os.walk(root): + dirnames[:] = [d for d in dirnames if d not in SKIP_DIRS] + for fn in filenames: + if not fn.endswith(".py"): + continue + if fn in SKIP_FILES: + continue + result.append(os.path.join(dirpath, fn)) + result.sort() + return result + + def _verify_one(self, filepath: str) -> Tuple[str, bool, str]: + try: + with open(filepath, "r", encoding="utf-8") as f: + src = f.read() + except UnicodeDecodeError: + try: + with open(filepath, "r", encoding="gbk") as f: + src = f.read() + except Exception as e: + return filepath, False, f"读取失败: {e}" + except Exception as e: + return filepath, False, f"读取失败: {e}" + + try: + ast.parse(src, filename=filepath) + except SyntaxError as e: + line = getattr(e, "lineno", "?") + col = getattr(e, "offset", "?") + msg = getattr(e, "msg", str(e)) + return filepath, False, f"SyntaxError 第{line}行第{col}列: {msg}" + + try: + py_compile.compile(filepath, doraise=True, quiet=2) + except py_compile.PyCompileError as e: + return filepath, False, f"PyCompileError: {e.msg if hasattr(e, 'msg') else e}" + except Exception as e: + return filepath, False, f"编译失败: {e}" + + return filepath, True, "" + + def _run_batch( + self, + files: List[str], + title: str, + verbose: bool = False, + quiet: bool = False, + jobs: int = 8, + ) -> Tuple[int, int, List[Tuple[str, str]]]: + total = len(files) + if total == 0: + self._emit(self._warn(f"{title}: 没有可验证的 Python 文件")) + return 0, 0, [] + + if not quiet: + self._emit(self._banner(f"{title} ({total} 个文件, {jobs} 线程)")) + self._emit("") + + passed = 0 + failed: List[Tuple[str, str]] = [] + start = time.time() + + results: List[Tuple[str, bool, str]] = [] + if jobs == 1: + for f in files: + results.append(self._verify_one(f)) + else: + with concurrent.futures.ThreadPoolExecutor(max_workers=jobs) as ex: + futures = {ex.submit(self._verify_one, f): f for f in files} + done = 0 + for fut in concurrent.futures.as_completed(futures): + results.append(fut.result()) + done += 1 + if not quiet and not verbose and total > 0: + pct = done * 100 // total + rel = os.path.relpath(futures[fut], PROJECT_ROOT) + self._emit(f"\r 进度: [{done}/{total}] {pct:3d}% {rel[:40]:<40}", end="") + if not quiet and not verbose: + self._emit("") + + results.sort(key=lambda x: x[0]) + + if verbose and not quiet: + self._emit("") + + for filepath, ok, err in results: + rel = os.path.relpath(filepath, PROJECT_ROOT) + if ok: + passed += 1 + if verbose and not quiet: + self._emit(f" {self._ok('✓')} {rel}") + else: + failed.append((rel, err)) + if not quiet: + self._emit(f" {self._err('✗')} {rel}") + self._emit(f" {self._err(err)}") + + elapsed = time.time() - start + + self._emit("") + self._emit("─" * 60) + if failed: + self._emit(f" {self._err('✗ 失败:')} {len(failed)}/{total}") + self._emit(f" {self._ok('✓ 通过:')} {passed}/{total}") + self._emit(f" {self._dim(f'耗时: {elapsed:.2f}s')}") + self._emit("") + self._emit(self._err("失败列表:")) + for rel, err in failed: + self._emit(f" • {self._err(rel)}") + first_line = err.split("\n")[0][:120] + self._emit(f" {first_line}") + else: + self._emit(f" {self._ok(f'✓ 全部通过:')} {passed}/{total} 个文件") + self._emit(f" {self._dim(f'耗时: {elapsed:.2f}s')}") + self._emit("─" * 60) + + return passed, len(failed), failed + + def _op_all(self, opts: dict): + files = self._collect_py_files(PROJECT_ROOT) + passed, failed, _ = self._run_batch( + files, + "全项目编译验证", + verbose=opts["verbose"], + quiet=opts["quiet"], + jobs=opts["jobs"], + ) + if failed == 0: + return ToolResult.ok( + f"全部通过 ({passed}/{passed})", + tool_name="compile_check", + ) + return ToolResult.fail( + f"有 {failed} 个文件编译失败", + ErrorCode.EXEC_FAILED, + tool_name="compile_check", + ) + + def _op_core(self, opts: dict): + return self._scan_subdir("xcli_core", "xcli_core 编译验证", opts) + + def _op_engines(self, opts: dict): + return self._scan_subdir("ai_engines", "ai_engines 编译验证", opts) + + def _op_plugins(self, opts: dict): + return self._scan_subdir("plugins", "plugins 编译验证", opts) + + def _scan_subdir(self, sub: str, title: str, opts: dict): + target = os.path.join(PROJECT_ROOT, sub) + if not os.path.isdir(target): + return ToolResult.not_found(f"目录: {sub}", tool_name="compile_check") + files = self._collect_py_files(target) + passed, failed, _ = self._run_batch( + files, title, + verbose=opts["verbose"], + quiet=opts["quiet"], + jobs=opts["jobs"], + ) + if failed == 0: + return ToolResult.ok( + f"{sub} 全部通过 ({passed})", + tool_name="compile_check", + ) + return ToolResult.fail( + f"{sub} 有 {failed} 个文件编译失败", + ErrorCode.EXEC_FAILED, + tool_name="compile_check", + ) + + def _op_dir(self, opts: dict): + if not opts["positional"]: + return ToolResult.missing("目录路径", tool_name="compile_check") + target = os.path.abspath(opts["positional"][0]) + if not os.path.isdir(target): + return ToolResult.not_found(f"目录: {target}", tool_name="compile_check") + files = self._collect_py_files(target) + passed, failed, _ = self._run_batch( + files, + f"目录验证: {os.path.relpath(target, PROJECT_ROOT)}", + verbose=opts["verbose"], + quiet=opts["quiet"], + jobs=opts["jobs"], + ) + if failed == 0: + return ToolResult.ok( + f"目录全部通过 ({passed})", + tool_name="compile_check", + ) + return ToolResult.fail( + f"目录有 {failed} 个文件编译失败", + ErrorCode.EXEC_FAILED, + tool_name="compile_check", + ) + + def _op_check(self, opts: dict): + if not opts["positional"]: + return ToolResult.missing("文件路径", tool_name="compile_check") + + targets = [] + for p in opts["positional"]: + fp = os.path.abspath(p) + if not os.path.isfile(fp): + return ToolResult.not_found( + f"文件: {p}", tool_name="compile_check", + ) + targets.append(fp) + + if len(targets) == 1: + self._emit(self._banner( + f"单文件验证: {os.path.relpath(targets[0], PROJECT_ROOT)}" + )) + filepath, ok, err = self._verify_one(targets[0]) + rel = os.path.relpath(filepath, PROJECT_ROOT) + self._emit("") + if ok: + self._emit(f" {self._ok('✓ 通过')} {rel}") + self._emit("─" * 60) + return ToolResult.ok(f"通过: {rel}", tool_name="compile_check") + else: + self._emit(f" {self._err('✗ 失败')} {rel}") + self._emit(f" {self._err(err)}") + self._emit("─" * 60) + return ToolResult.fail( + f"编译失败: {rel}", + ErrorCode.EXEC_FAILED, + tool_name="compile_check", + ) + + passed, failed, _ = self._run_batch( + targets, + f"批量验证 ({len(targets)} 个文件)", + verbose=opts["verbose"], + quiet=opts["quiet"], + jobs=opts["jobs"], + ) + if failed == 0: + return ToolResult.ok( + f"全部通过 ({passed})", + tool_name="compile_check", + ) + return ToolResult.fail( + f"有 {failed} 个文件编译失败", + ErrorCode.EXEC_FAILED, + tool_name="compile_check", + ) + + def _op_clean(self, opts: dict): + target = PROJECT_ROOT + if opts["positional"]: + target = os.path.abspath(opts["positional"][0]) + if not os.path.isdir(target): + return ToolResult.not_found( + f"目录: {target}", tool_name="compile_check", + ) + + self._emit(self._banner(f"清理 __pycache__: {os.path.relpath(target, PROJECT_ROOT)}")) + removed = 0 + for dirpath, dirnames, _ in os.walk(target): + for d in list(dirnames): + if d == "__pycache__": + full = os.path.join(dirpath, d) + try: + shutil.rmtree(full) + removed += 1 + rel = os.path.relpath(full, PROJECT_ROOT) + if not opts["quiet"]: + self._emit(f" {self._ok('✓ 已删除')} {rel}") + except Exception as e: + rel = os.path.relpath(full, PROJECT_ROOT) + self._emit(f" {self._err('✗ 失败')} {rel}: {e}") + self._emit("") + self._emit("─" * 60) + if removed: + self._emit(f" {self._ok(f'✓ 已清理')} {removed} 个 __pycache__") + else: + self._emit(f" {self._dim('没有可清理的 __pycache__')}") + self._emit("─" * 60) + + return ToolResult.ok( + f"清理完成 ({removed} 个目录)", + tool_name="compile_check", + ) + + def _op_stats(self, opts: dict): + self._emit(self._banner("项目 Python 文件统计")) + + subdirs = [ + ("xcli_core", "xcli_core"), + ("ai_engines", "ai_engines"), + ("plugins", "plugins"), + ] + + total = 0 + rows: List[Tuple[str, int]] = [] + for sub, label in subdirs: + target = os.path.join(PROJECT_ROOT, sub) + if os.path.isdir(target): + count = len(self._collect_py_files(target)) + rows.append((label, count)) + total += count + + other = len(self._collect_py_files(PROJECT_ROOT)) - total + rows.append(("其他(根目录等)", other)) + total += other + + self._emit("") + self._emit(f" {'目录':<20} {'文件数':>8}") + self._emit(" " + "─" * 30) + for label, count in rows: + bar = "█" * min(count, 40) if count else "" + color = Fore.GREEN if count else Fore.CYAN + self._emit(f" {label:<20} {count:>8} {color}{bar}{Style.RESET_ALL}") + self._emit(" " + "─" * 30) + self._emit(f" {'合计':<20} {total:>8}") + self._emit("") + self._emit("─" * 60) + + return ToolResult.ok( + f"统计完成 (共 {total} 个文件)", + tool_name="compile_check", + ) \ No newline at end of file diff --git a/plugins/file_manager.py b/plugins/file_manager.py new file mode 100644 index 0000000..e45e1b1 --- /dev/null +++ b/plugins/file_manager.py @@ -0,0 +1,354 @@ +""" +文件管理器插件 - 文件系统操作 +聚焦文件系统操作，代码编辑交给 code_editor +""" +import os +import json +import shutil +import sys +from datetime import datetime +from pathlib import Path +from typing import List + +# 添加项目根目录到 path +sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) +from xcli_core.tool_result import ToolResult, ErrorCode + + +class Liugin: + """文件管理器 - 文件和目录的增删改查""" + + def __init__(self): + self.usage = """文件管理器 + +操作: + list <路径> [-p "模式"] - 列出目录内容 + read <文件> [-n 行数] - 读取文件内容 + write <文件> -c "内容" - 写入文件 + append <文件> -c "内容" - 追加内容 + copy <源> <目标> - 复制文件/目录 + move <源> <目标> - 移动/重命名 + delete <路径> [-r] - 删除文件/目录 + search <目录> [-p 模式] [-c 内容] - 搜索文件 + info <路径> - 文件详细信息 + mkdir <路径> - 创建目录 +""" + self.cli = None + + def set_cli(self, cli): + self.cli = cli + + def get_tool_info(self): + return { + "name": "file_manager", + "description": "文件管理器 - 文件和目录的创建、读写、复制、移动、删除、搜索", + "keywords": ["文件", "目录", "管理", "file", "复制", "删除", "搜索", "mkdir", + "读取", "写入", "移动", "重命名"], + "usage": self.usage + } + + def get_mcp_definition(self): + return { + "name": "file_manager", + "description": "文件管理器", + "inputSchema": { + "type": "object", + "properties": { + "operation": { + "type": "string", + "enum": ["list", "read", "write", "append", "copy", + "move", "delete", "search", "info", "mkdir"], + "description": "操作类型" + }, + "path": {"type": "string"}, + "content": {"type": "string"}, + "destination": {"type": "string"}, + "pattern": {"type": "string"}, + "recursive": {"type": "boolean", "default": False} + }, + "required": ["operation"] + } + } + + def convert_mcp_args(self, arguments): + op = arguments.get("operation", "") + path = arguments.get("path", "") + return f"{op} {path}".strip() + + def handle(self, args: str): + try: + parts = self._parse_args(args) + if not parts: + return ToolResult.missing("操作类型") + + operation = parts[0].lower() + handlers = { + "list": self._op_list, + "read": self._op_read, + "write": self._op_write, + "append": self._op_append, + "copy": self._op_copy, + "move": self._op_move, + "delete": self._op_delete, + "search": self._op_search, + "info": self._op_info, + "mkdir": self._op_mkdir, + } + + handler = handlers.get(operation) + if not handler: + return ToolResult.fail(f"不支持的操作 '{operation}'", ErrorCode.UNSUPPORTED_OP) + return handler(parts[1:]) + + except Exception as e: + return f"文件操作错误: {str(e)}" + + def _parse_args(self, args: str) -> List[str]: + parts, current, in_quotes, qc = [], "", False, None + for ch in args: + if ch in ('"', "'") and not in_quotes: + in_quotes, qc = True, ch + elif ch == qc and in_quotes: + in_quotes, qc = False, None + elif ch == ' ' and not in_quotes: + if current: + parts.append(current) + current = "" + else: + current += ch + if current: + parts.append(current) + return parts + + def _op_list(self, args: List[str]): + path, pattern = ".", None + i = 0 + while i < len(args): + if args[i] == "-p" and i + 1 < len(args): + pattern = args[i + 1]; i += 1 + elif not args[i].startswith("-"): + path = args[i] + i += 1 + + path = os.path.abspath(path) + if not os.path.isdir(path): + return ToolResult.not_found(f"目录: {path}") + + items = [] + try: + for item in os.listdir(path): + full = os.path.join(path, item) + if pattern and not Path(item).match(pattern): + continue + if os.path.isdir(full): + items.append(('dir', item, '')) + else: + size = os.path.getsize(full) + size_str = f"{size/1024:.1f}KB" if size > 1024 else f"{size}B" + items.append(('file', item, size_str)) + + items.sort(key=lambda x: (0 if x[0] == 'dir' else 1, x[1].lower())) + dirs = sum(1 for x in items if x[0] == 'dir') + files = len(items) - dirs + + result = [f" {path}", "─" * 50] + for t, name, size in items[:100]: + result.append(f" {'' if t == 'dir' else ''} {name}{'/' if t == 'dir' else f' ({size})'}") + if len(items) > 100: + result.append(f" ... 还有 {len(items) - 100} 项") + result.append("─" * 50) + result.append(f"共 {dirs} 个文件夹, {files} 个文件") + return ToolResult.ok('\n'.join(result), tool_name="file_manager") + except Exception as e: + return ToolResult.fail(str(e), ErrorCode.EXEC_FAILED, tool_name="file_manager") + + def _op_read(self, args: List[str]): + if not args: + return ToolResult.missing("文件路径") + file_path = os.path.abspath(args[0]) + max_lines = None + i = 1 + while i < len(args): + if args[i] == "-n" and i + 1 < len(args): + try: + max_lines = int(args[i + 1]) + except ValueError: + return ToolResult.fail("行数必须是整数", ErrorCode.INVALID_ARGS) + i += 1 + i += 1 + + if not os.path.isfile(file_path): + return ToolResult.not_found(f"文件: {file_path}") + + size = os.path.getsize(file_path) + if size > 10 * 1024 * 1024: + return ToolResult.fail(f"文件过大 ({size/1024/1024:.1f}MB)，请用 -n 限制行数", ErrorCode.INVALID_ARGS) + + try: + with open(file_path, 'r', encoding='utf-8') as f: + if max_lines: + lines = [] + total = 0 + for i, line in enumerate(f): + total = i + 1 + if i < max_lines: + lines.append(f"{i+1:4d} | {line.rstrip()}") + content = '\n'.join(lines) + header = f" {file_path} ({size}B, 前 {min(max_lines, total)}/{total} 行)" + else: + all_lines = f.readlines() + content = '\n'.join(f"{i+1:4d} | {l.rstrip()}" for i, l in enumerate(all_lines)) + header = f" {file_path} ({size}B, {len(all_lines)} 行)" + + return ToolResult.ok(f"{header}\n{'─' * 50}\n{content}", tool_name="file_manager") + except UnicodeDecodeError: + return ToolResult.fail("无法解码（可能是二进制文件）", ErrorCode.DECODE_ERROR) + + def _op_write(self, args: List[str]): + if len(args) < 2: + return ToolResult.fail("格式: write <文件> -c <内容>", ErrorCode.MISSING_ARGS) + fp = os.path.abspath(args[0]) + content = None + i = 1 + while i < len(args): + if args[i] == "-c" and i + 1 < len(args): + content = args[i + 1]; i += 1 + i += 1 + if content is None: + return ToolResult.missing("内容 (-c 参数)") + os.makedirs(os.path.dirname(fp) or ".", exist_ok=True) + with open(fp, 'w', encoding='utf-8') as f: + f.write(content) + return ToolResult.ok(f"已写入: {fp} ({len(content)} 字符)", tool_name="file_manager") + + def _op_append(self, args: List[str]): + if len(args) < 2: + return ToolResult.fail("格式: append <文件> -c <内容>", ErrorCode.MISSING_ARGS) + fp = os.path.abspath(args[0]) + content = None + i = 1 + while i < len(args): + if args[i] == "-c" and i + 1 < len(args): + content = args[i + 1]; i += 1 + i += 1 + if content is None: + return ToolResult.missing("内容 (-c 参数)") + if not os.path.isfile(fp): + return ToolResult.not_found(f"文件: {fp}") + with open(fp, 'a', encoding='utf-8') as f: + f.write(content) + return ToolResult.ok(f"已追加: {fp}", tool_name="file_manager") + + def _op_copy(self, args: List[str]): + if len(args) < 2: + return ToolResult.missing("源和目标路径") + src, dst = os.path.abspath(args[0]), os.path.abspath(args[1]) + if not os.path.exists(src): + return ToolResult.not_found(f"源: {src}") + os.makedirs(os.path.dirname(dst) or ".", exist_ok=True) + if os.path.isfile(src): + shutil.copy2(src, dst) + else: + shutil.copytree(src, dst, dirs_exist_ok=True) + return ToolResult.ok(f"已复制:\n {src}\n → {dst}", tool_name="file_manager") + + def _op_move(self, args: List[str]): + if len(args) < 2: + return ToolResult.missing("源和目标路径") + src, dst = os.path.abspath(args[0]), os.path.abspath(args[1]) + if not os.path.exists(src): + return ToolResult.not_found(f"源: {src}") + os.makedirs(os.path.dirname(dst) or ".", exist_ok=True) + shutil.move(src, dst) + return ToolResult.ok(f"已移动:\n {src}\n → {dst}", tool_name="file_manager") + + def _op_delete(self, args: List[str]): + if not args: + return ToolResult.missing("路径") + path = os.path.abspath(args[0]) + recursive = "-r" in args + if not os.path.exists(path): + return ToolResult.not_found(f"路径: {path}") + if os.path.isfile(path): + os.remove(path) + return ToolResult.ok(f"已删除文件: {path}", tool_name="file_manager") + elif os.path.isdir(path): + if recursive: + shutil.rmtree(path) + return ToolResult.ok(f"已删除目录: {path}", tool_name="file_manager") + elif not os.listdir(path): + os.rmdir(path) + return ToolResult.ok(f"已删除空目录: {path}", tool_name="file_manager") + else: + return ToolResult.fail("目录不为空，用 -r 递归删除", ErrorCode.INVALID_ARGS) + + def _op_search(self, args: List[str]): + if not args: + return ToolResult.missing("搜索目录") + directory = os.path.abspath(args[0]) + pattern, content_search = None, None + i = 1 + while i < len(args): + if args[i] == "-p" and i + 1 < len(args): + pattern = args[i + 1]; i += 1 + elif args[i] == "-c" and i + 1 < len(args): + content_search = args[i + 1]; i += 1 + i += 1 + + if not os.path.isdir(directory): + return ToolResult.not_found(f"目录: {directory}") + + results = [] + for root, dirs, files in os.walk(directory): + for fn in files: + if pattern and not Path(fn).match(pattern): + continue + fp = os.path.join(root, fn) + rel = os.path.relpath(fp, directory) + if content_search: + try: + with open(fp, 'r', encoding='utf-8') as f: + for i, line in enumerate(f, 1): + if content_search in line: + results.append(f"{rel}:{i}: {line.strip()[:80]}") + if len(results) >= 50: + break + except (UnicodeDecodeError, IOError): + continue + else: + results.append(rel) + if len(results) >= 50: + break + if len(results) >= 50: + break + + return ToolResult.ok(f"搜索结果 ({len(results)}):\n" + '\n'.join(results), tool_name="file_manager") if results else ToolResult.ok("未找到匹配", tool_name="file_manager") + + def _op_info(self, args: List[str]): + if not args: + return ToolResult.missing("路径") + path = os.path.abspath(args[0]) + if not os.path.exists(path): + return ToolResult.not_found(f"路径: {path}") + + stat = os.stat(path) + result = [ + f"路径: {path}", + f"类型: {'目录' if os.path.isdir(path) else '文件'}", + f"大小: {stat.st_size:,} 字节 ({stat.st_size/1024:.1f} KB)", + f"修改: {datetime.fromtimestamp(stat.st_mtime):%Y-%m-%d %H:%M:%S}", + f"访问: {datetime.fromtimestamp(stat.st_atime):%Y-%m-%d %H:%M:%S}", + ] + if os.path.isfile(path): + ext = os.path.splitext(path)[1] + result.append(f"扩展名: {ext or '无'}") + return ToolResult.ok('\n'.join(result), tool_name="file_manager") + + def _op_mkdir(self, args: List[str]): + if not args: + return ToolResult.missing("目录路径") + path = os.path.abspath(args[0]) + if os.path.exists(path): + return ToolResult.fail(f"已存在: {path}", ErrorCode.INVALID_ARGS) + os.makedirs(path, exist_ok=True) + return ToolResult.ok(f"已创建: {path}", tool_name="file_manager") diff --git a/plugins/frontend_tester.py b/plugins/frontend_tester.py new file mode 100644 index 0000000..ec106fc --- /dev/null +++ b/plugins/frontend_tester.py @@ -0,0 +1,479 @@ +""" +前端测试验证插件 - 类似 iFlow CLI 的 frontend-tester +支持HTML/CSS/JS自动化测试和UI验证 +""" + +import os +import re +import subprocess +from colorama import Fore, Style + + +class Liugin: + """前端测试验证插件 - 自动化测试Web界面""" + + def __init__(self): + self.usage = """前端测试工具使用方法： + +JSON格式示例： +{"action": "use_tool", "tool": "frontend_tester", "args": "validate index.html"} - 验证HTML文件 +{"action": "use_tool", "tool": "frontend_tester", "args": "test style.css"} - 测试CSS文件 +{"action": "use_tool", "tool": "frontend_tester", "args": "check app.js"} - 检查JS文件 +{"action": "use_tool", "tool": "frontend_tester", "args": "preview index.html"} - 在浏览器中预览 +{"action": "use_tool", "tool": "frontend_tester", "args": "analyze project"} - 分析整个项目 + +功能说明： +- validate - 验证HTML文件的语法和结构 +- test - 测试CSS文件的样式和兼容性 +- check - 检查JS文件的语法和潜在问题 +- preview - 在默认浏览器中打开预览 +- analyze <项目路径> - 分析整个前端项目的结构和问题 + +支持的检查项： + HTML语法验证 + CSS语法和兼容性检查 + JavaScript语法检查 + 响应式设计检查 + 可访问性检查 + 性能优化建议""" + self.cli = None + + def set_cli(self, cli): + """设置CLI实例引用""" + self.cli = cli + # 注册插件命令 + self.cli.register_liugin_command('ftest', self.command_handler) + self.cli.register_liugin_command('frontend', self.command_handler) + + def command_handler(self, args): + """处理 /ftest 或 /frontend 命令""" + return self.handle(args) + + def get_tool_info(self): + return { + "name": "frontend_tester", + "description": "前端测试验证工具，支持HTML/CSS/JS自动化测试和UI验证，包括语法检查、响应式设计、可访问性检查等", + "keywords": ["前端", "测试", "HTML", "CSS", "JavaScript", "UI", "验证", "preview", "validate", "frontend", "test"], + "usage": self.usage + } + + def get_mcp_definition(self): + return { + "name": "frontend_tester", + "description": "前端测试验证工具，支持HTML/CSS/JS自动化测试", + "inputSchema": { + "type": "object", + "properties": { + "operation": { + "type": "string", + "enum": ["validate", "lint", "test"], + "description": "操作类型" + }, + "target": { + "type": "string", + "description": "目标文件路径" + } + }, + "required": ["operation", "target"] + } + } + + def convert_mcp_args(self, arguments): + op = arguments.get("operation", "") + target = arguments.get("target", "") + return f"{op} {target}" + + def handle(self, args): + """处理前端测试请求""" + try: + parts = args.strip().split(maxsplit=1) + if not parts: + return "错误：请提供操作类型和参数。使用 'frontend_tester help' 查看帮助" + + operation = parts[0].lower() + + if operation == "help": + return self.usage + + elif operation == "validate": + # 验证HTML文件 + if len(parts) < 2: + return "错误：请提供HTML文件路径。格式: validate " + file_path = parts[1] + return self._validate_html(file_path) + + elif operation == "test": + # 测试CSS文件 + if len(parts) < 2: + return "错误：请提供CSS文件路径。格式: test " + file_path = parts[1] + return self._test_css(file_path) + + elif operation == "check": + # 检查JS文件 + if len(parts) < 2: + return "错误：请提供JS文件路径。格式: check " + file_path = parts[1] + return self._check_js(file_path) + + elif operation == "preview": + # 在浏览器中预览 + if len(parts) < 2: + return "错误：请提供HTML文件路径。格式: preview " + file_path = parts[1] + return self._preview_in_browser(file_path) + + elif operation == "analyze": + # 分析整个项目 + if len(parts) < 2: + return "错误：请提供项目路径。格式: analyze <项目路径>" + project_path = parts[1] + return self._analyze_project(project_path) + + else: + return f"错误：不支持的操作 '{operation}'。支持的操作有: validate, test, check, preview, analyze, help" + + except Exception as e: + return f"前端测试操作错误: {str(e)}" + + def _validate_html(self, file_path): + """验证HTML文件""" + if not os.path.exists(file_path): + return f" 文件不存在: {file_path}" + + try: + with open(file_path, 'r', encoding='utf-8') as f: + content = f.read() + + result = f"\n HTML验证结果: {file_path}\n" + result += "=" * 60 + "\n\n" + + # 基本检查 + issues = [] + + # 检查DOCTYPE + if not content.strip().startswith('" + }) + + # 检查lang属性 + if '' not in content: + issues.append({ + "level": "error", + "message": "缺少标签" + }) + + # 统计元素 + div_count = content.count('<div') + img_count = content.count('<img') + img_alt_count = content.count('alt=') + link_count = content.count('<link') + script_count = content.count('<script') + + result += f" 文件统计:\n" + result += f" - div元素: {div_count}\n" + result += f" - img元素: {img_count}\n" + result += f" - img alt属性: {img_alt_count}\n" + result += f" - link标签: {link_count}\n" + result += f" - script标签: {script_count}\n\n" + + # 检查img alt属性 + if img_count > 0 and img_alt_count < img_count: + issues.append({ + "level": "warning", + "message": f"有 {img_count - img_alt_count} 个img元素缺少alt属性" + }) + + # 显示问题 + if issues: + result += f" 发现 {len(issues)} 个问题:\n\n" + for i, issue in enumerate(issues, 1): + level = issue['level'] + if level == 'error': + icon = f"{Fore.RED}{Style.RESET_ALL}" + elif level == 'warning': + icon = f"{Fore.YELLOW}{Style.RESET_ALL}" + else: + icon = f"{Fore.GREEN}ℹ{Style.RESET_ALL}" + result += f"{icon} {i}. {issue['message']}\n" + else: + result += f"{Fore.GREEN} 未发现问题{Style.RESET_ALL}\n" + + result += "\n" + "=" * 60 + "\n" + + return result + + except UnicodeDecodeError: + return " 文件编码问题，无法读取" + except Exception as e: + return f" 验证失败: {str(e)}" + + def _test_css(self, file_path): + """测试CSS文件""" + if not os.path.exists(file_path): + return f" 文件不存在: {file_path}" + + try: + with open(file_path, 'r', encoding='utf-8') as f: + content = f.read() + + result = f"\n CSS测试结果: {file_path}\n" + result += "=" * 60 + "\n\n" + + issues = [] + + # 检查常见的CSS问题 + if content.count('{') != content.count('}'): + issues.append({ + "level": "error", + "message": "大括号不匹配" + }) + + # 检查颜色使用 + if '#000000' in content or '#ffffff' in content: + issues.append({ + "level": "info", + "message": "使用了纯黑或纯白，建议使用更柔和的颜色" + }) + + # 检查单位使用 + if content.count('px') > 10 and 'rem' not in content and 'em' not in content: + issues.append({ + "level": "warning", + "message": "大量使用px单位，建议考虑使用rem或em以支持更好的缩放" + }) + + # 统计 + rule_count = content.count('{') + selector_count = len([line for line in content.split('\n') if '{' in line]) + + result += f" 文件统计:\n" + result += f" - CSS规则: {rule_count}\n" + result += f" - 选择器: {selector_count}\n\n" + + # 显示问题 + if issues: + result += f" 发现 {len(issues)} 个问题:\n\n" + for i, issue in enumerate(issues, 1): + level = issue['level'] + if level == 'error': + icon = f"{Fore.RED}{Style.RESET_ALL}" + elif level == 'warning': + icon = f"{Fore.YELLOW}{Style.RESET_ALL}" + else: + icon = f"{Fore.GREEN}ℹ{Style.RESET_ALL}" + result += f"{icon} {i}. {issue['message']}\n" + else: + result += f"{Fore.GREEN} 未发现问题{Style.RESET_ALL}\n" + + result += "\n" + "=" * 60 + "\n" + + return result + + except UnicodeDecodeError: + return " 文件编码问题，无法读取" + except Exception as e: + return f" 测试失败: {str(e)}" + + def _check_js(self, file_path): + """检查JS文件""" + if not os.path.exists(file_path): + return f" 文件不存在: {file_path}" + + try: + with open(file_path, 'r', encoding='utf-8') as f: + content = f.read() + + result = f"\n JavaScript检查结果: {file_path}\n" + result += "=" * 60 + "\n\n" + + issues = [] + + # 检查常见问题 + if 'var ' in content: + issues.append({ + "level": "warning", + "message": "使用了var声明，建议使用let或const" + }) + + if re.search(r'(?<![=!])==(?!=)', content): + issues.append({ + "level": "warning", + "message": "使用了==比较，建议使用===严格相等" + }) + + if content.count('console.log') > 5: + issues.append({ + "level": "info", + "message": f"有{content.count('console.log')}个console.log，生产环境建议移除" + }) + + if 'eval(' in content: + issues.append({ + "level": "error", + "message": "使用了eval()，存在安全风险" + }) + + # 统计 + line_count = len(content.split('\n')) + function_count = content.count('function ') + + result += f" 文件统计:\n" + result += f" - 代码行数: {line_count}\n" + result += f" - 函数数量: {function_count}\n\n" + + # 显示问题 + if issues: + result += f" 发现 {len(issues)} 个问题:\n\n" + for i, issue in enumerate(issues, 1): + level = issue['level'] + if level == 'error': + icon = f"{Fore.RED}{Style.RESET_ALL}" + elif level == 'warning': + icon = f"{Fore.YELLOW}{Style.RESET_ALL}" + else: + icon = f"{Fore.GREEN}ℹ{Style.RESET_ALL}" + result += f"{icon} {i}. {issue['message']}\n" + else: + result += f"{Fore.GREEN} 未发现问题{Style.RESET_ALL}\n" + + result += "\n" + "=" * 60 + "\n" + + return result + + except UnicodeDecodeError: + return " 文件编码问题，无法读取" + except Exception as e: + return f" 检查失败: {str(e)}" + + def _preview_in_browser(self, file_path): + """在浏览器中预览""" + if not os.path.exists(file_path): + return f" 文件不存在: {file_path}" + + try: + # Windows系统 + os.startfile(file_path) + return f" 已在默认浏览器中打开: {file_path}" + except Exception as e: + return f" 无法打开浏览器: {str(e)}" + + def _analyze_project(self, project_path): + """分析整个前端项目""" + if not os.path.exists(project_path): + return f" 项目路径不存在: {project_path}" + + result = f"\n 前端项目分析: {project_path}\n" + result += "=" * 60 + "\n\n" + + try: + # 统计文件 + html_files = [] + css_files = [] + js_files = [] + + for root, dirs, files in os.walk(project_path): + for file in files: + if file.endswith('.html'): + html_files.append(os.path.join(root, file)) + elif file.endswith('.css'): + css_files.append(os.path.join(root, file)) + elif file.endswith('.js'): + js_files.append(os.path.join(root, file)) + + result += f" 项目文件统计:\n" + result += f" - HTML文件: {len(html_files)}\n" + result += f" - CSS文件: {len(css_files)}\n" + result += f" - JavaScript文件: {len(js_files)}\n\n" + + # 建议检查 + result += f" 建议检查:\n" + + if html_files: + result += f" - HTML文件:\n" + for html_file in html_files[:3]: # 只显示前3个 + result += f" • {os.path.basename(html_file)}\n" + if len(html_files) > 3: + result += f" • ... 还有 {len(html_files) - 3} 个文件\n" + + if css_files: + result += f" - CSS文件:\n" + for css_file in css_files[:3]: + result += f" • {os.path.basename(css_file)}\n" + if len(css_files) > 3: + result += f" • ... 还有 {len(css_files) - 3} 个文件\n" + + if js_files: + result += f" - JavaScript文件:\n" + for js_file in js_files[:3]: + result += f" • {os.path.basename(js_file)}\n" + if len(js_files) > 3: + result += f" • ... 还有 {len(js_files) - 3} 个文件\n" + + result += f"\n{Fore.GREEN} 分析完成{Style.RESET_ALL}\n" + result += "\n" + "=" * 60 + "\n" + + return result + + except Exception as e: + return f" 分析失败: {str(e)}" + + +# 测试函数 +def test_plugin(): + """测试插件功能""" + plugin = Liugin() + print("前端测试验证插件测试:") + + print("\n1. 创建测试HTML文件:") + test_html = """<!DOCTYPE html> +<html> +<head> + <meta charset="UTF-8"> + <title>测试页面 + + +

测试

+ +""" + with open('test.html', 'w', encoding='utf-8') as f: + f.write(test_html) + + print("\n2. 验证HTML:") + print(plugin.handle("validate test.html")) + + print("\n3. 在浏览器中预览:") + print(plugin.handle("preview test.html")) + + print("\n4. 分析项目:") + print(plugin.handle("analyze .")) + + # 清理测试文件 + if os.path.exists('test.html'): + os.remove('test.html') + + +if __name__ == "__main__": + test_plugin() \ No newline at end of file diff --git a/plugins/git_tools.py b/plugins/git_tools.py new file mode 100644 index 0000000..ed0bc20 --- /dev/null +++ b/plugins/git_tools.py @@ -0,0 +1,426 @@ +""" +Git 工具插件 - 统一的版本控制能力 +合并原 git_tools + git_workflow，消除重复 +""" +import os +import re +import subprocess +from typing import Tuple, Optional + + +class Liugin: + """Git 版本控制 - 基础操作 + 工作流自动化""" + + def __init__(self): + self.usage = """Git 版本控制工具 + +基础操作: + status - 查看仓库状态 + diff [文件路径] - 查看未暂存变更 + diff --cached - 查看已暂存变更 + log [数量] - 提交历史 (默认10条) + log --oneline [数量] - 简洁提交历史 + add <文件路径> - 暂存文件 + add . - 暂存所有变更 + commit <提交信息> - 提交变更 + branch - 查看分支列表 + branch <名称> - 创建新分支 + checkout <分支名> - 切换分支 + checkout -b <分支名> - 创建并切换分支 + stash - 暂存当前变更 + stash pop - 恢复暂存的变更 + show - 查看指定提交 + blame <文件路径> - 逐行修改记录 + remote - 查看远程仓库 + init - 初始化仓库 + clone [目录] - 克隆仓库 + +工作流: + smart-commit [消息] - 智能提交 (自动 add + 规范化消息) + changelog [版本] - 生成 CHANGELOG + summary - 变更摘要 (未提交改动) + contributors - 贡献者统计 + stale [天数] - 查找长期未更新文件 +""" + self.cli = None + + def set_cli(self, cli): + self.cli = cli + + def get_tool_info(self): + return { + "name": "git_tools", + "description": "Git 版本控制 - 状态查看、提交、分支管理、diff、历史、blame、工作流自动化", + "keywords": ["git", "版本控制", "提交", "分支", "commit", "branch", "status", "diff", + "changelog", "log", "blame", "stash", "checkout", "merge"], + "usage": self.usage + } + + def get_mcp_definition(self): + return { + "name": "git_tools", + "description": "Git 版本控制工具", + "inputSchema": { + "type": "object", + "properties": { + "operation": {"type": "string", "description": "Git 操作"}, + "args": {"type": "string", "description": "操作参数"} + }, + "required": ["operation"] + } + } + + def convert_mcp_args(self, arguments): + op = arguments.get("operation", "") + args = arguments.get("args", "") + return f"{op} {args}".strip() + + # ── 执行 Git 命令 ── + + def _run_git(self, args: list, cwd: Optional[str] = None) -> Tuple[bool, str]: + try: + result = subprocess.run( + ["git"] + args, + capture_output=True, text=True, + cwd=cwd, timeout=30 + ) + output = (result.stdout + result.stderr).strip() + return result.returncode == 0, output + except FileNotFoundError: + return False, "git 未安装，请先安装 Git" + except subprocess.TimeoutExpired: + return False, "Git 命令执行超时" + except Exception as e: + return False, str(e) + + def _run_shell(self, cmd: str, cwd: Optional[str] = None) -> Tuple[bool, str]: + try: + result = subprocess.run( + cmd, shell=True, capture_output=True, text=True, + cwd=cwd or os.getcwd(), timeout=30 + ) + return result.returncode == 0, (result.stdout + result.stderr).strip() + except Exception as e: + return False, str(e) + + def _get_cwd(self): + if self.cli and hasattr(self.cli, 'current_dir'): + return self.cli.current_dir + return None + + # ── 路由 ── + + def handle(self, args: str) -> str: + try: + parts = args.strip().split(maxsplit=1) + if not parts: + return self._status() + + op = parts[0].lower() + rest = parts[1] if len(parts) > 1 else "" + cwd = self._get_cwd() + + handlers = { + # 基础 + "status": lambda r: self._status(cwd), + "diff": lambda r: self._diff(r, cwd), + "log": lambda r: self._log(r, cwd), + "add": lambda r: self._add(r, cwd), + "commit": lambda r: self._commit(r, cwd), + "branch": lambda r: self._branch(r, cwd), + "checkout": lambda r: self._checkout(r, cwd), + "stash": lambda r: self._stash(r, cwd), + "show": lambda r: self._show(r, cwd), + "blame": lambda r: self._blame(r, cwd), + "remote": lambda r: self._remote(cwd), + "init": lambda r: self._init(r, cwd), + "clone": lambda r: self._clone(r, cwd), + # 工作流 + "smart-commit": lambda r: self._smart_commit(r, cwd), + "changelog": lambda r: self._changelog(r, cwd), + "summary": lambda r: self._summary(cwd), + "contributors": lambda r: self._contributors(cwd), + "stale": lambda r: self._stale(r, cwd), + } + + handler = handlers.get(op) + if handler: + return handler(rest) + + # 回退：直接执行 git 命令 + ok, output = self._run_git(args.split(), cwd) + return output if ok else f"Git 错误: {output}" + + except Exception as e: + return f"Git 工具错误: {str(e)}" + + # ── 基础操作 ── + + def _status(self, cwd=None) -> str: + ok, output = self._run_git(["status", "--porcelain"], cwd) + if not ok: + return f"Git 错误: {output}" + + if not output: + # 获取分支 + _, branch = self._run_git(["branch", "--show-current"], cwd) + return f" 工作区干净 (分支: {branch})" + + lines = output.split('\n') + staged, unstaged, untracked = [], [], [] + + for line in lines: + if len(line) < 4: + continue + s, filename = line[:2], line[3:] + if s[0] in 'MADRC': + staged.append(f" {s[0]} {filename}") + if s[1] in 'MD': + unstaged.append(f" ! {s[1]} {filename}") + if s == '??': + untracked.append(f" ? {filename}") + + _, branch = self._run_git(["branch", "--show-current"], cwd) + result = [f" Git 状态 (分支: {branch})"] + + if staged: + result.append(f"\n已暂存 ({len(staged)}):") + result.extend(staged) + if unstaged: + result.append(f"\n未暂存 ({len(unstaged)}):") + result.extend(unstaged) + if untracked: + result.append(f"\n未跟踪 ({len(untracked)}):") + result.extend(untracked) + + return '\n'.join(result) + + def _diff(self, args: str, cwd=None) -> str: + args = args.strip() + if args == "--cached": + git_args = ["diff", "--cached"] + elif args: + git_args = ["diff", args] + else: + git_args = ["diff"] + + ok, output = self._run_git(git_args, cwd) + if not ok: + return f"Git 错误: {output}" + if not output: + return "没有变更" + return output + + def _log(self, args: str, cwd=None) -> str: + parts = args.split() + oneline = "--oneline" in parts + count = 10 + for p in parts: + if p.isdigit(): + count = int(p) + + if oneline: + ok, output = self._run_git( + ["log", "--oneline", f"-{count}", "--graph", "--decorate"], cwd) + else: + ok, output = self._run_git( + ["log", f"-{count}", "--format=%h %an %ad %s", "--date=short"], cwd) + + if not ok: + return f"Git 错误: {output}" + return output or "暂无提交历史" + + def _add(self, args: str, cwd=None) -> str: + target = args.strip() + if not target: + return "错误：请提供文件路径（使用 . 暂存所有）" + ok, output = self._run_git(["add", target], cwd) + return f" 已暂存: {target}" if ok else f"Git add 失败: {output}" + + def _commit(self, args: str, cwd=None) -> str: + message = args.strip() + if not message: + return "错误：请提供提交信息" + ok, output = self._run_git(["commit", "-m", message], cwd) + return f" 提交成功:\n{output}" if ok else f"Git commit 失败: {output}" + + def _branch(self, args: str, cwd=None) -> str: + if not args.strip(): + ok, output = self._run_git(["branch", "-a"], cwd) + return f" 分支列表:\n{output}" if ok else f"Git 错误: {output}" + else: + ok, output = self._run_git(["branch", args.strip()], cwd) + return f" 已创建分支: {args.strip()}" if ok else f"创建分支失败: {output}" + + def _checkout(self, args: str, cwd=None) -> str: + args = args.strip() + if args.startswith("-b "): + branch = args[3:].strip() + ok, output = self._run_git(["checkout", "-b", branch], cwd) + else: + branch = args + ok, output = self._run_git(["checkout", branch], cwd) + return f" 已切换到: {branch}" if ok else f"切换失败: {output}" + + def _stash(self, args: str, cwd=None) -> str: + if args.strip() == "pop": + ok, output = self._run_git(["stash", "pop"], cwd) + else: + ok, output = self._run_git(["stash"], cwd) + return f" {output}" if ok else f"Git stash 失败: {output}" + + def _show(self, args: str, cwd=None) -> str: + commit = args.strip() or "HEAD" + ok, output = self._run_git(["show", "--stat", commit], cwd) + if not ok: + return f"Git show 失败: {output}" + return output + + def _blame(self, args: str, cwd=None) -> str: + path = args.strip() + if not path: + return "错误：请提供文件路径" + ok, output = self._run_git(["blame", "--line-porcelain", path], cwd) + if not ok: + return f"Git blame 失败: {output}" + + lines = output.split('\n') + result = [] + author = "" + for line in lines: + if line.startswith('author '): + author = line[7:] + elif line.startswith('\t'): + result.append(f" {author}: {line[1:]}") + + if len(result) > 100: + result = result[:100] + result.append(f" ... (共 {len(result)} 行)") + + return f" {path} 修改记录:\n" + '\n'.join(result) + + def _remote(self, cwd=None) -> str: + ok, output = self._run_git(["remote", "-v"], cwd) + if not ok: + return f"Git 错误: {output}" + return output or "没有配置远程仓库" + + def _init(self, args: str, cwd=None) -> str: + path = args.strip() or "." + ok, output = self._run_git(["init", path], cwd) + return f" {output}" if ok else f"Git init 失败: {output}" + + def _clone(self, args: str, cwd=None) -> str: + parts = args.split() + if not parts: + return "错误：请提供仓库 URL" + cmd = ["clone", parts[0]] + if len(parts) > 1: + cmd.append(parts[1]) + ok, output = self._run_git(cmd, cwd) + return f" 克隆成功:\n{output}" if ok else f"Git clone 失败: {output}" + + # ── 工作流 ── + + def _smart_commit(self, message: str, cwd=None) -> str: + """智能提交：自动 add + 规范化消息""" + ok, status = self._run_git(["status", "--porcelain"], cwd) + if not status: + return " 工作区干净，没有需要提交的变更" + + self._run_git(["add", "-A"], cwd) + + if not message: + message = self._auto_commit_message(status) + + # conventional commits 检查 + if not re.match(r'^(feat|fix|docs|style|refactor|perf|test|build|ci|chore|revert)(\(.+\))?: .+', message): + if 'test' in message.lower(): + message = f"test: {message}" + elif 'doc' in message.lower() or 'readme' in message.lower(): + message = f"docs: {message}" + else: + message = f"feat: {message}" + + ok, output = self._run_git(["commit", "-m", message], cwd) + if ok: + _, hash_out = self._run_git(["log", "--oneline", "-1"], cwd) + return f" 已提交: {message}\n {hash_out}" + return f" 提交失败: {output}" + + def _auto_commit_message(self, status: str) -> str: + lines = status.strip().split('\n') + added = len([l for l in lines if l.startswith('A ') or (len(l) > 1 and l.startswith('A') and l[1] == ' ')]) + modified = len([l for l in lines if l.startswith('M ') or (len(l) > 1 and l[1] == 'M')]) + deleted = len([l for l in lines if l.startswith('D ') or (len(l) > 1 and l[1] == 'D')]) + + parts = [] + if added: + parts.append(f"添加 {added} 个文件") + if modified: + parts.append(f"修改 {modified} 个文件") + if deleted: + parts.append(f"删除 {deleted} 个文件") + return ", ".join(parts) if parts else "更新代码" + + def _changelog(self, version: str, cwd=None) -> str: + ok, output = self._run_shell( + 'git log --oneline --format="%s" | head -50', cwd) + if not ok: + return f" {output}" + + commits = output.strip().split('\n') + categories = { + 'feat': [], 'fix': [], 'docs': [], 'refactor': [], + 'test': [], 'chore': [], 'other': [] + } + + for commit in commits: + matched = False + for prefix in categories: + if commit.startswith(prefix + ':') or commit.startswith(prefix + '('): + categories[prefix].append(commit) + matched = True + break + if not matched: + categories['other'].append(commit) + + labels = { + 'feat': ' 新增', 'fix': ' 修复', 'docs': ' 文档', + 'refactor': ' 重构', 'test': ' 测试', 'chore': ' 杂项', + 'other': ' 其他' + } + + ver = version or "未发布" + result = [f"## {ver}\n"] + for prefix, label in labels.items(): + items = categories[prefix] + if items: + result.append(f"\n### {label}") + for item in items[:10]: + result.append(f"- {item}") + + return '\n'.join(result) + + def _summary(self, cwd=None) -> str: + ok, output = self._run_git(["diff", "--stat"], cwd) + if not output: + return " 没有未提交的变更" + _, short = self._run_git(["diff", "--shortstat"], cwd) + return f" 变更摘要:\n\n{short}\n\n{output[:2000]}" + + def _contributors(self, cwd=None) -> str: + ok, output = self._run_git(["shortlog", "-sn", "--all", "--no-merges"], cwd) + if not ok: + return f" {output}" + lines = output.strip().split('\n') + result = [f" 贡献者 ({len(lines)} 人):\n"] + for line in lines[:20]: + result.append(f" {line.strip()}") + return '\n'.join(result) + + def _stale(self, args: str, cwd=None) -> str: + days = int(args) if args.strip().isdigit() else 90 + ok, output = self._run_shell( + f"git log --diff-filter=A --format='%aI %n' --since='{days} days ago' | head -20", cwd) + return f" 最近 {days} 天新增的文件:\n{output[:2000]}" if ok else f" {output}" diff --git a/plugins/gui_auto.py b/plugins/gui_auto.py new file mode 100644 index 0000000..9d53937 --- /dev/null +++ b/plugins/gui_auto.py @@ -0,0 +1,1036 @@ +""" +Windows GUI 自动化插件 - 屏幕元素识别与控制 +基于 Windows UI Automation (UIA)，获取屏幕 UI 元素树并自动操控桌面应用 +支持：元素发现、点击、输入、截图、元素树遍历、窗口管理 +""" + +import os +import sys +import json +import time +from typing import Optional, List, Dict, Any + +# ── 平台检测 ── +IS_WINDOWS = sys.platform == "win32" + + +class Liugin: + """Windows GUI 自动化 - 屏幕元素识别、点击、输入、截图、元素树遍历""" + + def __init__(self): + self.usage = """Windows GUI 自动化工具 + +屏幕信息: + snapshot [深度] - 获取屏幕 UI 元素树 (默认深度 5) + snapshot --window <标题> - 获取指定窗口的元素树 + screenshot [路径] - 全屏截图 (默认 gui_screenshot.png) + windows - 列出所有顶层窗口 + focus <窗口标题> - 聚焦指定窗口 + +元素操作: + click <名称> - 点击元素 (支持模糊匹配) + click --xy - 点击屏幕坐标 + rightclick <名称> - 右键点击元素 + doubleclick <名称> - 双击元素 + type <名称> <文本> - 在元素中输入文本 + clear <名称> - 清空输入框 + keys <按键序列> - 发送按键 (如: keys ctrl+a, keys enter) + scroll <方向> [数量] - 滚动 (up/down/left/right) + +元素查询: + find <名称> - 查找元素 (返回位置和属性) + findall <名称> - 查找所有匹配元素 + info <名称> - 获取元素详细信息 + value <名称> - 获取元素的值 + tree <名称> [深度] - 以某元素为根的子树 + +高级: + wait <名称> [超时秒数] - 等待元素出现 + exists <名称> - 检查元素是否存在 + highlight <名称> - 高亮闪烁元素 (视觉定位) + state <名称> - 获取元素状态 (enabled/visible/focused等) +""" + self.cli = None + self._uia = None + self._root = None + self._comtypes = None + self._pyautogui = None + + def set_cli(self, cli): + self.cli = cli + + def get_tool_info(self): + return { + "name": "gui_auto", + "description": "Windows GUI 自动化 - 屏幕UI元素识别、点击、输入、截图、元素树遍历、桌面应用操控", + "keywords": ["GUI", "屏幕", "桌面", "窗口", "控件", "点击", "输入", + "自动化", "UIA", "Windows", "截图", "元素", "按钮", + "菜单", "桌面应用", "桌面自动化", "computer use", "UI"], + "usage": self.usage + } + + def get_mcp_definition(self): + return { + "name": "gui_auto", + "description": "Windows GUI 自动化工具，可识别和操控屏幕上的 UI 元素，获取元素树，执行点击/输入/按键等操作", + "inputSchema": { + "type": "object", + "properties": { + "operation": { + "type": "string", + "description": "操作类型", + "enum": ["snapshot", "screenshot", "windows", "focus", + "click", "rightclick", "doubleclick", "type", + "clear", "keys", "scroll", "find", "findall", + "info", "value", "tree", "wait", "exists", + "highlight", "state"] + }, + "target": {"type": "string", "description": "目标元素名称"}, + "value": {"type": "string", "description": "输入的文本"}, + "x": {"type": "integer", "description": "X 坐标"}, + "y": {"type": "integer", "description": "Y 坐标"}, + "path": {"type": "string", "description": "保存路径"}, + "depth": {"type": "integer", "description": "遍历深度"} + }, + "required": ["operation"] + } + } + + def convert_mcp_args(self, arguments): + op = arguments.get("operation", "") + target = arguments.get("target", "") + value = arguments.get("value", "") + x = arguments.get("x") + y = arguments.get("y") + depth = arguments.get("depth") + + parts = [op] + if x is not None and y is not None: + parts.append(f"--xy {x} {y}") + elif target: + parts.append(target) + if value: + parts.append(value) + if depth is not None and op == "snapshot": + parts = [op, str(depth)] + if target: + parts.extend(["--window", target]) + return " ".join(str(p) for p in parts) + + # ══════════════════════════════════════════════ + # 路由分发 + # ══════════════════════════════════════════════ + + def handle(self, args: str) -> str: + try: + parts = args.strip().split(maxsplit=1) + if not parts: + return "错误：请提供操作类型" + + op = parts[0].lower() + rest = parts[1] if len(parts) > 1 else "" + + handlers = { + "snapshot": self._snapshot, + "screenshot": self._screenshot, + "windows": self._list_windows, + "focus": self._focus_window, + "click": self._click, + "rightclick": self._rightclick, + "doubleclick": self._doubleclick, + "type": self._type, + "clear": self._clear, + "keys": self._keys, + "scroll": self._scroll, + "find": self._find, + "findall": self._findall, + "info": self._info, + "value": self._value, + "tree": self._tree, + "wait": self._wait, + "exists": self._exists, + "highlight": self._highlight, + "state": self._state, + } + + handler = handlers.get(op) + if not handler: + return f"错误：不支持的操作 '{op}'\n可用: {', '.join(handlers.keys())}" + return handler(rest) + + except Exception as e: + return f"GUI 自动化错误: {str(e)}" + + # ══════════════════════════════════════════════ + # 平台检查 + # ══════════════════════════════════════════════ + + def _check_platform(self) -> Optional[str]: + """检查是否在 Windows 平台，返回错误信息或 None""" + if not IS_WINDOWS: + return ("❌ 此插件仅支持 Windows 系统\n" + " Windows UI Automation 是 Windows 专有 API\n" + " 其他平台请使用 browser_auto 插件进行网页自动化") + return None + + # ══════════════════════════════════════════════ + # UIA 初始化 + # ══════════════════════════════════════════════ + + def _ensure_uia(self) -> bool: + """确保 UIA COM 接口已初始化""" + if self._uia is not None: + return True + + err = self._check_platform() + if err: + return False + + try: + import comtypes + import comtypes.client + self._comtypes = comtypes + + # IUIAutomation CLSID + self._uia = comtypes.client.CreateObject( + "{ff48dba4-60ef-4201-aa87-54103eef594e}", + interface=comtypes.gen.UIAutomationClient.IUIAutomation + ) + self._root = self._uia.GetRootElement() + return True + except ImportError: + return False + except Exception: + return False + + def _ensure_pyautogui(self): + """确保 pyautogui 可用，返回模块或 None""" + if self._pyautogui is not None: + return self._pyautogui + + try: + import pyautogui + pyautogui.FAILSAFE = True + pyautogui.PAUSE = 0.05 + self._pyautogui = pyautogui + return pyautogui + except ImportError: + return None + + def _uia_error(self) -> str: + """返回 UIA 初始化失败的错误信息""" + err = self._check_platform() + if err: + return err + + missing = [] + try: + import comtypes + except ImportError: + missing.append("comtypes") + try: + import pyautogui + except ImportError: + missing.append("pyautogui") + + if missing: + return (f"缺少依赖: {', '.join(missing)}\n" + f"安装: pip install {' '.join(missing)}") + return "UI Automation 初始化失败，请确认在 Windows 环境下运行" + + # ══════════════════════════════════════════════ + # 元素遍历核心 + # ══════════════════════════════════════════════ + + def _element_to_dict(self, element, include_ref=False) -> Optional[Dict[str, Any]]: + """将 UIA 元素转换为字典""" + try: + name = element.CurrentName or "" + ctrl_type = element.CurrentLocalizedControlType or "" + automation_id = element.CurrentAutomationId or "" + class_name = element.CurrentClassName or "" + is_enabled = element.CurrentIsEnabled + has_focus = element.CurrentHasKeyboardFocus + + try: + rect = element.CurrentBoundingRectangle + bounds = { + "left": int(rect.left), "top": int(rect.top), + "right": int(rect.right), "bottom": int(rect.bottom), + "width": int(rect.right - rect.left), + "height": int(rect.bottom - rect.top) + } + except Exception: + bounds = None + + # 尝试读取 ValuePattern + value = "" + try: + vp = element.GetCurrentPattern(0xA) # ValuePattern + if vp: + value = vp.CurrentValue or "" + except Exception: + pass + + result = { + "name": name, "type": ctrl_type, + "automation_id": automation_id, "class": class_name, + "enabled": is_enabled, "focused": has_focus, + "bounds": bounds, + } + if value: + result["value"] = value + if include_ref: + result["_element"] = element + return result + except Exception: + return None + + def _walk_tree(self, element, depth=0, max_depth=5, prefix="") -> str: + """遍历元素树，返回格式化字符串""" + if element is None or depth > max_depth: + return "" + + lines = [] + self._walk_recursive(element, depth, max_depth, prefix, lines) + return "\n".join(lines) + + def _walk_recursive(self, element, depth, max_depth, prefix, lines): + """递归遍历元素树""" + if depth > max_depth: + return + try: + info = self._element_to_dict(element) + if not info: + return + + indent = " " * depth + name_part = f'"{info["name"]}"' if info["name"] else "(无名)" + type_part = f'[{info["type"]}]' if info["type"] else "" + id_part = f' id={info["automation_id"]}' if info["automation_id"] else "" + + bounds_part = "" + if info.get("bounds"): + b = info["bounds"] + bounds_part = f' @({b["left"]},{b["top"]},{b["width"]}x{b["height"]})' + + state_parts = [] + if info.get("focused"): + state_parts.append("FOCUSED") + if not info.get("enabled", True): + state_parts.append("DISABLED") + state_str = f' {" ".join(state_parts)}' if state_parts else "" + + lines.append(f"{indent}{prefix}{type_part} {name_part}{id_part}{bounds_part}{state_str}") + + children = element.FindAll( + 2, # TreeScope_Children + self._uia.CreateTrueCondition() + ) + if children: + count = min(children.Length, 50) # 限制单层最多 50 个子元素 + for i in range(count): + child = children.GetElement(i) + self._walk_recursive(child, depth + 1, max_depth, f"[{i}] ", lines) + except Exception: + pass + + def _find_elements_by_name(self, name: str, root=None, max_results=20) -> List[Dict]: + """通过名称查找元素（支持模糊匹配）""" + if not self._ensure_uia(): + return [] + if root is None: + root = self._root + + results = [] + name_lower = name.lower() + self._search_recursive(root, name_lower, results, max_results, 0, 8) + return results + + def _search_recursive(self, element, name_lower, results, max_results, depth, max_depth): + """递归搜索元素""" + if depth > max_depth or len(results) >= max_results: + return + try: + el_name = (element.CurrentName or "").lower() + el_aid = (element.CurrentAutomationId or "").lower() + + if name_lower in el_name or name_lower in el_aid: + info = self._element_to_dict(element, include_ref=True) + if info: + results.append(info) + + children = element.FindAll( + self._uia.CreatePropertyCondition(30000, 0), + self._uia.CreateTrueCondition() + ) + if children: + for i in range(min(children.Length, 100)): + child = children.GetElement(i) + self._search_recursive(child, name_lower, results, max_results, depth + 1, max_depth) + except Exception: + pass + + def _find_element_by_name(self, name: str) -> Optional[Dict]: + """查找单个元素，精确匹配优先""" + results = self._find_elements_by_name(name) + if not results: + return None + # 精确匹配优先 + for r in results: + if r.get("name", "").lower() == name.lower(): + return r + return results[0] + + def _click_at(self, x: int, y: int, button="left", clicks=1, label="") -> str: + """通过坐标点击""" + pg = self._ensure_pyautogui() + if not pg: + return "错误：未安装 pyautogui。运行: pip install pyautogui" + + try: + if button == "left": + pg.click(x, y, clicks=clicks) + elif button == "right": + pg.rightClick(x, y) + else: + pg.click(x, y, clicks=clicks, button=button) + + btn = "左键" if button == "left" else "右键" + act = "双击" if clicks == 2 else "点击" + label_str = f' "{label}"' if label else "" + return f"✅ {act}{label_str} @ ({x}, {y})" + except Exception as e: + return f"❌ 点击失败: {e}" + + def _click_element(self, el_info: Dict, button="left", clicks=1) -> str: + """点击元素（自动计算中心坐标）""" + bounds = el_info.get("bounds") + if not bounds: + return f"❌ 元素 '{el_info.get('name')}' 没有位置信息" + + cx = (bounds["left"] + bounds["right"]) // 2 + cy = (bounds["top"] + bounds["bottom"]) // 2 + return self._click_at(cx, cy, button, clicks, el_info.get("name", "")) + + def _format_element_info(self, el: Dict, detailed=False) -> str: + """格式化元素信息""" + lines = [] + lines.append(f' 名称: "{el.get("name", "(无名)")}"') + lines.append(f' 类型: {el.get("type", "未知")}') + lines.append(f' 类名: {el.get("class", "未知")}') + if el.get("automation_id"): + lines.append(f' 自动化ID: {el["automation_id"]}') + bounds = el.get("bounds") + if bounds: + lines.append(f' 位置: ({bounds["left"]}, {bounds["top"]})') + lines.append(f' 大小: {bounds["width"]} x {bounds["height"]}') + if el.get("value"): + lines.append(f' 值: {el["value"]}') + lines.append(f' 启用: {"是" if el.get("enabled", True) else "否"}') + lines.append(f' 聚焦: {"是" if el.get("focused") else "否"}') + + if detailed and el.get("_element"): + element = el["_element"] + for attr, label in [ + ("CurrentHelpText", "帮助文本"), + ("CurrentAccessKey", "访问键"), + ("CurrentAcceleratorKey", "快捷键"), + ]: + try: + val = getattr(element, attr, None) + if val: + lines.append(f' {label}: {val}') + except Exception: + pass + + # 支持的 Pattern + patterns = [] + pattern_ids = { + 0: "Invoke", 1: "Selection", 2: "Value", 3: "RangeValue", + 5: "Scroll", 6: "ExpandCollapse", 7: "Grid", 8: "GridItem", + 9: "MultipleView", 10: "Window", 11: "SelectionItem", + 12: "Dock", 13: "Table", 14: "TableItem", 15: "Text", + 16: "Toggle", 17: "Transform", 18: "ScrollItem" + } + for pid, pname in pattern_ids.items(): + try: + element.GetCurrentPattern(pid) + patterns.append(pname) + except Exception: + pass + if patterns: + lines.append(f' 支持模式: {", ".join(patterns)}') + + return "\n".join(lines) + + def _type_unicode(self, text: str): + """输入 Unicode 文本（中文等）""" + import ctypes + import ctypes.wintypes + + INPUT_KEYBOARD = 1 + KEYEVENTF_UNICODE = 0x0004 + KEYEVENTF_KEYUP = 0x0002 + + class KEYBDINPUT(ctypes.Structure): + _fields_ = [ + ("wVk", ctypes.wintypes.WORD), + ("wScan", ctypes.wintypes.WORD), + ("dwFlags", ctypes.wintypes.DWORD), + ("time", ctypes.wintypes.DWORD), + ("dwExtraInfo", ctypes.POINTER(ctypes.c_ulong)), + ] + + class INPUT(ctypes.Structure): + _fields_ = [("type", ctypes.wintypes.DWORD), ("ki", KEYBDINPUT)] + + for char in text: + for flags in [KEYEVENTF_UNICODE, KEYEVENTF_UNICODE | KEYEVENTF_KEYUP]: + inp = INPUT(type=INPUT_KEYBOARD) + inp.ki.wScan = ord(char) + inp.ki.dwFlags = flags + ctypes.windll.user32.SendInput( + 1, ctypes.byref(inp), ctypes.sizeof(INPUT) + ) + time.sleep(0.02) + + # ══════════════════════════════════════════════ + # 操作实现 + # ══════════════════════════════════════════════ + + def _snapshot(self, args: str) -> str: + """获取屏幕元素树""" + if not self._ensure_uia(): + return self._uia_error() + + parts = args.strip().split() if args.strip() else [] + max_depth = 5 + window_title = None + + i = 0 + while i < len(parts): + if parts[i] == "--window" and i + 1 < len(parts): + window_title = parts[i + 1] + i += 2 + elif parts[i].isdigit(): + max_depth = int(parts[i]) + i += 1 + else: + i += 1 + + try: + if window_title: + condition = self._uia.CreatePropertyCondition(30005, window_title) + windows = self._root.FindAll( + self._uia.CreatePropertyCondition(30000, 2), condition + ) + if windows.Length == 0: + return f"❌ 未找到窗口: {window_title}" + element = windows.GetElement(0) + else: + element = self._root + + tree_str = self._walk_tree(element, max_depth=max_depth) + header = f"📍 屏幕 UI 元素树 (深度={max_depth})" + if window_title: + header += f" - 窗口: {window_title}" + + line_count = len([l for l in tree_str.strip().split("\n") if l.strip()]) if tree_str.strip() else 0 + return f"{header}\n{'=' * 60}\n{tree_str}\n{'=' * 60}\n共 {line_count} 个元素" + + except Exception as e: + return f"❌ 获取元素树失败: {e}" + + def _screenshot(self, args: str) -> str: + """全屏截图""" + err = self._check_platform() + if err: + return err + + try: + from PIL import ImageGrab + except ImportError: + return "❌ 需要 Pillow。运行: pip install Pillow" + + path = args.strip() if args.strip() else "gui_screenshot.png" + try: + screenshot = ImageGrab.grab() + screenshot.save(path) + w, h = screenshot.size + size_kb = os.path.getsize(path) / 1024 + return f"✅ 截图已保存: {path} ({w}x{h}, {size_kb:.1f} KB)" + except Exception as e: + return f"❌ 截图失败: {e}" + + def _list_windows(self, args: str) -> str: + """列出所有顶层窗口""" + if not self._ensure_uia(): + return self._uia_error() + + try: + children = self._root.FindAll( + 2, # TreeScope_Children + self._uia.CreateTrueCondition() + ) + + windows = [] + for i in range(children.Length): + el = children.GetElement(i) + try: + name = el.CurrentName or "(无标题)" + ctrl_type = el.CurrentLocalizedControlType or "" + class_name = el.CurrentClassName or "" + rect = el.CurrentBoundingRectangle + bounds = f"({rect.left},{rect.top},{rect.right - rect.left}x{rect.bottom - rect.top})" + windows.append(f" [{i}] [{ctrl_type}] \"{name}\" class={class_name} {bounds}") + except Exception: + continue + + if not windows: + return "📍 未找到任何窗口" + return f"📍 顶层窗口 (共 {len(windows)} 个)\n{'=' * 60}\n" + "\n".join(windows) + + except Exception as e: + return f"❌ 列出窗口失败: {e}" + + def _focus_window(self, args: str) -> str: + """聚焦窗口""" + title = args.strip() + if not title: + return "❌ 请提供窗口标题" + + if not self._ensure_uia(): + return self._uia_error() + + try: + condition = self._uia.CreatePropertyCondition(30005, title) + windows = self._root.FindAll( + self._uia.CreatePropertyCondition(30000, 2), condition + ) + if windows.Length == 0: + return f"❌ 未找到窗口: {title}" + + window = windows.GetElement(0) + rect = window.CurrentBoundingRectangle + + # 使用 Win32 API 设置焦点 + try: + import ctypes + import ctypes.wintypes + hwnd = ctypes.windll.user32.WindowFromPoint( + ctypes.wintypes.POINT(rect.left + 10, rect.top + 10) + ) + if hwnd: + ctypes.windll.user32.SetForegroundWindow(hwnd) + ctypes.windll.user32.ShowWindow(hwnd, 9) # SW_RESTORE + except Exception: + # 备用方案：点击标题栏 + pg = self._ensure_pyautogui() + if pg: + pg.click(rect.left + (rect.right - rect.left) // 2, rect.top + 10) + + return f"✅ 已聚焦窗口: \"{title}\"" + + except Exception as e: + return f"❌ 聚焦失败: {e}" + + def _click(self, args: str) -> str: + """点击元素""" + args = args.strip() + + # --xy 模式 + if args.startswith("--xy"): + parts = args.split() + if len(parts) >= 3: + try: + x, y = int(parts[1]), int(parts[2]) + return self._click_at(x, y, "left", 1) + except ValueError: + return "❌ 坐标格式: click --xy " + return "❌ 格式: click --xy " + + if not args: + return "❌ 请提供元素名称或 --xy " + + if not self._ensure_uia(): + return self._uia_error() + + el = self._find_element_by_name(args) + if not el: + return f"❌ 未找到元素: {args}" + return self._click_element(el, "left", 1) + + def _rightclick(self, args: str) -> str: + """右键点击""" + name = args.strip() + if not name: + return "❌ 请提供元素名称" + if not self._ensure_uia(): + return self._uia_error() + + el = self._find_element_by_name(name) + if not el: + return f"❌ 未找到元素: {name}" + return self._click_element(el, "right", 1) + + def _doubleclick(self, args: str) -> str: + """双击""" + name = args.strip() + if not name: + return "❌ 请提供元素名称" + if not self._ensure_uia(): + return self._uia_error() + + el = self._find_element_by_name(name) + if not el: + return f"❌ 未找到元素: {name}" + return self._click_element(el, "left", 2) + + def _type(self, args: str) -> str: + """在元素中输入文本""" + parts = args.strip().split(maxsplit=1) + if len(parts) < 2: + return "❌ 格式: type <元素名称> <文本>" + + name, text = parts[0], parts[1] + if not self._ensure_uia(): + return self._uia_error() + + el = self._find_element_by_name(name) + if not el: + return f"❌ 未找到元素: {name}" + + # 尝试 ValuePattern 直接设置值 + element = el.get("_element") + if element: + try: + vp = element.GetCurrentPattern(0xA) # ValuePattern + if vp: + vp.SetValue(text) + return f'✅ 已输入 "{text}" → "{name}" (ValuePattern)' + except Exception: + pass + + # 备用方案：聚焦 + pyautogui 输入 + self._click_element(el, "left", 1) + time.sleep(0.15) + + pg = self._ensure_pyautogui() + if not pg: + return "❌ 需要 pyautogui。运行: pip install pyautogui" + + try: + if text.isascii(): + pg.typewrite(text, interval=0.02) + else: + self._type_unicode(text) + return f'✅ 已输入 "{text}" → "{name}"' + except Exception as e: + return f"❌ 输入失败: {e}" + + def _clear(self, args: str) -> str: + """清空输入框""" + name = args.strip() + if not name: + return "❌ 请提供元素名称" + if not self._ensure_uia(): + return self._uia_error() + + el = self._find_element_by_name(name) + if not el: + return f"❌ 未找到元素: {name}" + + # 尝试 ValuePattern 清空 + element = el.get("_element") + if element: + try: + vp = element.GetCurrentPattern(0xA) + if vp: + vp.SetValue("") + return f'✅ 已清空: "{name}" (ValuePattern)' + except Exception: + pass + + # 备用方案：Ctrl+A + Delete + self._click_element(el, "left", 1) + time.sleep(0.1) + + pg = self._ensure_pyautogui() + if not pg: + return "❌ 需要 pyautogui" + + try: + pg.hotkey('ctrl', 'a') + time.sleep(0.05) + pg.press('delete') + return f'✅ 已清空: "{name}"' + except Exception as e: + return f"❌ 清空失败: {e}" + + def _keys(self, args: str) -> str: + """发送按键""" + keys_str = args.strip() + if not keys_str: + return "❌ 请提供按键。格式: keys ctrl+a, keys enter, keys alt+f4" + + pg = self._ensure_pyautogui() + if not pg: + return "❌ 需要 pyautogui。运行: pip install pyautogui" + + try: + for combo in keys_str.split(","): + combo = combo.strip() + if not combo: + continue + parts = combo.lower().split("+") + if len(parts) > 1: + pg.hotkey(*parts) + else: + pg.press(parts[0]) + return f"✅ 已发送按键: {keys_str}" + except Exception as e: + return f"❌ 按键发送失败: {e}" + + def _scroll(self, args: str) -> str: + """滚动""" + parts = args.strip().split() + direction = parts[0] if parts else "down" + amount = int(parts[1]) if len(parts) > 1 and parts[1].isdigit() else 3 + + pg = self._ensure_pyautogui() + if not pg: + return "❌ 需要 pyautogui。运行: pip install pyautogui" + + try: + if direction == "down": + pg.scroll(-amount * 3) + elif direction == "up": + pg.scroll(amount * 3) + elif direction == "left": + pg.hscroll(-amount * 3) + elif direction == "right": + pg.hscroll(amount * 3) + else: + return f"❌ 不支持的方向 '{direction}'。可用: up/down/left/right" + return f"✅ 已滚动 {direction} x{amount}" + except Exception as e: + return f"❌ 滚动失败: {e}" + + def _find(self, args: str) -> str: + """查找元素""" + name = args.strip() + if not name: + return "❌ 请提供元素名称" + if not self._ensure_uia(): + return self._uia_error() + + el = self._find_element_by_name(name) + if not el: + return f"❌ 未找到元素: {name}" + return f"✅ 找到元素:\n{self._format_element_info(el)}" + + def _findall(self, args: str) -> str: + """查找所有匹配元素""" + name = args.strip() + if not name: + return "❌ 请提供元素名称" + if not self._ensure_uia(): + return self._uia_error() + + elements = self._find_elements_by_name(name) + if not elements: + return f"❌ 未找到匹配 \"{name}\" 的元素" + + result = f"✅ 找到 {len(elements)} 个匹配元素:\n{'=' * 50}\n" + for i, el in enumerate(elements): + result += f"\n[{i}] {self._format_element_info(el)}\n" + return result + + def _info(self, args: str) -> str: + """获取元素详细信息""" + name = args.strip() + if not name: + return "❌ 请提供元素名称" + if not self._ensure_uia(): + return self._uia_error() + + el = self._find_element_by_name(name) + if not el: + return f"❌ 未找到元素: {name}" + return f"✅ 元素信息:\n{self._format_element_info(el, detailed=True)}" + + def _value(self, args: str) -> str: + """获取元素的值""" + name = args.strip() + if not name: + return "❌ 请提供元素名称" + if not self._ensure_uia(): + return self._uia_error() + + el = self._find_element_by_name(name) + if not el: + return f"❌ 未找到元素: {name}" + + element = el.get("_element") + if not element: + return "❌ 无法获取元素引用" + + # ValuePattern + try: + vp = element.GetCurrentPattern(0xA) + if vp: + return f"值: {vp.CurrentValue}" + except Exception: + pass + + # TextPattern + try: + tp = element.GetCurrentPattern(0x1E) + if tp: + return f"文本: {tp.DocumentRange.GetText(-1)}" + except Exception: + pass + + val = el.get("value", "") + if val: + return f"值: {val}" + return f"元素 \"{name}\" 没有可读取的值" + + def _tree(self, args: str) -> str: + """以某元素为根的子树""" + parts = args.strip().split() if args.strip() else [] + name = parts[0] if parts else "" + depth = int(parts[1]) if len(parts) > 1 and parts[1].isdigit() else 3 + + if not name: + return "❌ 请提供元素名称" + if not self._ensure_uia(): + return self._uia_error() + + el = self._find_element_by_name(name) + if not el: + return f"❌ 未找到元素: {name}" + + element = el.get("_element") + if not element: + return "❌ 无法获取元素引用" + + tree_str = self._walk_tree(element, max_depth=depth) + return f"📍 元素 \"{name}\" 的子树 (深度={depth}):\n{'=' * 50}\n{tree_str}" + + def _wait(self, args: str) -> str: + """等待元素出现""" + parts = args.strip().split() + if not parts: + return "❌ 请提供元素名称" + name = parts[0] + timeout = int(parts[1]) if len(parts) > 1 and parts[1].isdigit() else 10 + + if not self._ensure_uia(): + return self._uia_error() + + start_time = time.time() + while time.time() - start_time < timeout: + el = self._find_element_by_name(name) + if el: + elapsed = time.time() - start_time + return f"✅ 元素 \"{name}\" 已出现 ({elapsed:.1f}s)" + time.sleep(0.5) + + return f"⏰ 超时：等待 {timeout}s 后仍未找到 \"{name}\"" + + def _exists(self, args: str) -> str: + """检查元素是否存在""" + name = args.strip() + if not name: + return "❌ 请提供元素名称" + if not self._ensure_uia(): + return self._uia_error() + + el = self._find_element_by_name(name) + if el: + bounds = el.get("bounds", {}) + return f'✅ 存在: "{name}" [{el.get("type", "")}] @({bounds.get("left",0)},{bounds.get("top",0)})' + return f'❌ 不存在: "{name}"' + + def _highlight(self, args: str) -> str: + """高亮闪烁元素""" + name = args.strip() + if not name: + return "❌ 请提供元素名称" + + err = self._check_platform() + if err: + return err + + if not self._ensure_uia(): + return self._uia_error() + + el = self._find_element_by_name(name) + if not el: + return f"❌ 未找到元素: {name}" + + bounds = el.get("bounds") + if not bounds: + return f"❌ 元素 \"{name}\" 没有位置信息" + + try: + import ctypes + user32 = ctypes.windll.user32 + gdi32 = ctypes.windll.gdi32 + hdc = user32.GetDC(0) + + pen = gdi32.CreatePen(0, 3, 0x0000FF) # 红色实线 + old_pen = gdi32.SelectObject(hdc, pen) + old_brush = gdi32.SelectObject(hdc, gdi32.GetStockObject(5)) # NULL_BRUSH + + x1, y1 = bounds["left"], bounds["top"] + x2, y2 = bounds["right"], bounds["bottom"] + + for _ in range(3): + gdi32.Rectangle(hdc, x1, y1, x2, y2) + time.sleep(0.3) + import ctypes.wintypes + user32.InvalidateRect( + 0, ctypes.byref(ctypes.wintypes.RECT(x1 - 2, y1 - 2, x2 + 2, y2 + 2)), True + ) + user32.UpdateWindow(0) + time.sleep(0.2) + + gdi32.SelectObject(hdc, old_pen) + gdi32.SelectObject(hdc, old_brush) + gdi32.DeleteObject(pen) + user32.ReleaseDC(0, hdc) + + return f'✅ 高亮: "{name}" @({x1},{y1})-({x2},{y2})' + except Exception as e: + return f"❌ 高亮失败: {e}" + + def _state(self, args: str) -> str: + """获取元素状态""" + name = args.strip() + if not name: + return "❌ 请提供元素名称" + if not self._ensure_uia(): + return self._uia_error() + + el = self._find_element_by_name(name) + if not el: + return f"❌ 未找到元素: {name}" + + element = el.get("_element") + if not element: + return "❌ 无法获取元素引用" + + states = [] + try: + states.append("✅ enabled" if element.CurrentIsEnabled else "❌ disabled") + if element.CurrentHasKeyboardFocus: + states.append("🎯 focused") + if element.CurrentIsKeyboardFocusable: + states.append("⌨️ focusable") + except Exception as e: + return f"❌ 获取状态失败: {e}" + + return f' "{name}" 状态:\n' + "\n".join(f" {s}" for s in states) diff --git a/plugins/id_generator.py b/plugins/id_generator.py new file mode 100644 index 0000000..e44b8fe --- /dev/null +++ b/plugins/id_generator.py @@ -0,0 +1,383 @@ +""" +UUID / ID 生成器插件 - 生成各种格式的唯一标识符 +支持 UUID v1/v4/v5、NanoID、短ID、雪花ID、自定义格式 +""" + +import uuid +import hashlib +import time +import random +import string +import json +import os +import struct +from datetime import datetime +from typing import List + + +class Liugin: + """UUID / ID 生成器 - 多格式唯一标识符生成""" + + def __init__(self): + self.usage = """UUID / ID 生成器 + +操作: + uuid [-v 版本] [-n 数量] - 生成 UUID（默认 v4） + v1=时间戳 v4=随机 v5=命名 + nanoid [-s 长度] [-n 数量] - 生成 NanoID（默认21位） + short [-s 长度] [-n 数量] - 生成短ID（默认8位） + snowflake [-n 数量] - 生成雪花ID（时间排序） + custom <模板> [-n 数量] - 自定义格式生成 + 模板: {U}=大写字母 {L}=小写 {D}=数字 {X}=十六进制 + ulid [-n 数量] - 生成 ULID（时间排序+随机） + timestamp - 当前时间戳（秒/毫秒/微秒） + from_name <命名空间> <名称> - 基于名称生成确定性 UUID (v5) + batch <类型> [-n 数量] [-o 文件] - 批量生成并保存到文件 + +示例: + id_generator uuid + id_generator uuid -v 1 -n 5 + id_generator nanoid -s 16 + id_generator short -s 6 -n 10 + id_generator custom "USER-{D}{D}{D}{D}{U}{U}" -n 5 + id_generator snowflake -n 3 + id_generator batch uuid -n 100 -o ids.txt +""" + self.cli = None + self._machine_id = random.randint(0, 1023) + self._sequence = 0 + self._last_ts = 0 + + def set_cli(self, cli): + self.cli = cli + + def get_tool_info(self): + return { + "name": "id_generator", + "description": "UUID/ID 生成器 - 支持 UUID、NanoID、短ID、雪花ID、ULID、自定义格式", + "keywords": ["uuid", "id", "生成", "唯一", "标识", "nanoid", "snowflake", "ulid", "短id"], + "usage": self.usage + } + + def get_mcp_definition(self): + return { + "name": "id_generator", + "description": "UUID/ID 生成器，支持多种格式", + "inputSchema": { + "type": "object", + "properties": { + "operation": { + "type": "string", + "enum": ["uuid", "nanoid", "short", "snowflake", "custom", + "ulid", "timestamp", "from_name", "batch"], + "description": "操作类型" + }, + "version": {"type": "integer", "description": "UUID 版本 (1/4/5)"}, + "length": {"type": "integer", "description": "ID 长度"}, + "count": {"type": "integer", "description": "生成数量"}, + "template": {"type": "string", "description": "自定义模板"}, + "namespace": {"type": "string", "description": "命名空间"}, + "name": {"type": "string", "description": "名称"}, + "output": {"type": "string", "description": "输出文件"} + }, + "required": ["operation"] + } + } + + def convert_mcp_args(self, arguments): + op = arguments.get("operation", "") + count = arguments.get("count", "") + parts = [op] + if count: + parts.extend(["-n", str(count)]) + return " ".join(parts) + + def handle(self, args: str) -> str: + try: + parts = self._parse_args(args) + if not parts: + return self._op_uuid([]) + + operation = parts[0].lower() + handlers = { + "uuid": self._op_uuid, + "nanoid": self._op_nanoid, + "short": self._op_short, + "snowflake": self._op_snowflake, + "custom": self._op_custom, + "ulid": self._op_ulid, + "timestamp": self._op_timestamp, + "from_name": self._op_from_name, + "batch": self._op_batch, + } + + handler = handlers.get(operation) + if not handler: + return f"错误：不支持的操作 '{operation}'" + return handler(parts[1:]) + + except Exception as e: + return f"ID 生成错误: {str(e)}" + + def _parse_args(self, args: str) -> List[str]: + parts, current, in_quotes, qc = [], "", False, None + for ch in args: + if ch in ('"', "'") and not in_quotes: + in_quotes, qc = True, ch + elif ch == qc and in_quotes: + in_quotes, qc = False, None + elif ch == ' ' and not in_quotes: + if current: + parts.append(current) + current = "" + else: + current += ch + if current: + parts.append(current) + return parts + + def _parse_opts(self, args: List[str]) -> dict: + opts = {} + i = 0 + while i < len(args): + if args[i].startswith("-") and i + 1 < len(args): + key = args[i].lstrip("-") + opts[key] = args[i + 1] + i += 1 + i += 1 + return opts + + def _op_uuid(self, args: List[str]) -> str: + opts = self._parse_opts(args) + version = int(opts.get("v", 4)) + count = int(opts.get("n", 1)) + count = min(count, 1000) + + ids = [] + for _ in range(count): + if version == 1: + ids.append(str(uuid.uuid1())) + elif version == 4: + ids.append(str(uuid.uuid4())) + elif version == 5: + ids.append(str(uuid.uuid5(uuid.NAMESPACE_DNS, "example.com"))) + else: + return f"错误：不支持的 UUID 版本: {version}" + + header = f" UUID v{version} ({count} 个):\n" + if count <= 20: + return header + "\n".join(f" {u}" for u in ids) + else: + return header + "\n".join(f" {u}" for u in ids[:10]) + f"\n ... (共 {count} 个)" + + def _op_nanoid(self, args: List[str]) -> str: + opts = self._parse_opts(args) + size = int(opts.get("s", 21)) + count = int(opts.get("n", 1)) + count = min(count, 1000) + + alphabet = string.ascii_letters + string.digits + "_-" + ids = [] + for _ in range(count): + ids.append(''.join(random.choices(alphabet, k=size))) + + header = f" NanoID (长度 {size}, {count} 个):\n" + if count <= 20: + return header + "\n".join(f" {i}" for i in ids) + else: + return header + "\n".join(f" {i}" for i in ids[:10]) + f"\n ... (共 {count} 个)" + + def _op_short(self, args: List[str]) -> str: + opts = self._parse_opts(args) + size = int(opts.get("s", 8)) + count = int(opts.get("n", 1)) + count = min(count, 1000) + + chars = string.ascii_letters + string.digits + ids = [] + for _ in range(count): + ids.append(''.join(random.choices(chars, k=size))) + + header = f" 短ID (长度 {size}, {count} 个):\n" + if count <= 20: + return header + "\n".join(f" {i}" for i in ids) + else: + return header + "\n".join(f" {i}" for i in ids[:10]) + f"\n ... (共 {count} 个)" + + def _op_snowflake(self, args: List[str]) -> str: + opts = self._parse_opts(args) + count = int(opts.get("n", 1)) + count = min(count, 1000) + + # Twitter Snowflake: 41位时间戳 + 10位机器ID + 12位序列号 + epoch = 1288834974657 # Twitter epoch (2010-11-04) + + ids = [] + for _ in range(count): + ts = int(time.time() * 1000) - epoch + if ts == self._last_ts: + self._sequence = (self._sequence + 1) & 0xFFF + if self._sequence == 0: + while ts <= self._last_ts: + ts = int(time.time() * 1000) - epoch + else: + self._sequence = 0 + self._last_ts = ts + + snowflake_id = (ts << 22) | (self._machine_id << 12) | self._sequence + ids.append(str(snowflake_id)) + + header = f"❄️ 雪花ID ({count} 个):\n" + if count <= 20: + return header + "\n".join(f" {i}" for i in ids) + else: + return header + "\n".join(f" {i}" for i in ids[:10]) + f"\n ... (共 {count} 个)" + + def _op_custom(self, args: List[str]) -> str: + if not args: + return "错误：请提供模板\n示例: custom \"ORDER-{D}{D}{D}{D}-{U}{U}{U}\"" + template = args[0] + opts = self._parse_opts(args[1:]) + count = int(opts.get("n", 1)) + count = min(count, 1000) + + ids = [] + for _ in range(count): + result = [] + for ch in template: + if ch == '{': + continue # handled below + result.append(ch) + # Actually use proper template parsing + ids.append(self._expand_template(template)) + + header = f" ️ 自定义ID (模板: {template}, {count} 个):\n" + if count <= 20: + return header + "\n".join(f" {i}" for i in ids) + else: + return header + "\n".join(f" {i}" for i in ids[:10]) + f"\n ... (共 {count} 个)" + + def _expand_template(self, template: str) -> str: + result = [] + i = 0 + while i < len(template): + if template[i] == '{' and i + 2 < len(template) and template[i + 2] == '}': + token = template[i + 1] + if token == 'U': + result.append(random.choice(string.ascii_uppercase)) + elif token == 'L': + result.append(random.choice(string.ascii_lowercase)) + elif token == 'D': + result.append(random.choice(string.digits)) + elif token == 'X': + result.append(random.choice('0123456789ABCDEF')) + elif token == 'x': + result.append(random.choice('0123456789abcdef')) + elif token == 'A': + result.append(random.choice(string.ascii_letters)) + else: + result.append(template[i:i + 3]) + i += 3 + else: + result.append(template[i]) + i += 1 + return ''.join(result) + + def _op_ulid(self, args: List[str]) -> str: + opts = self._parse_opts(args) + count = int(opts.get("n", 1)) + count = min(count, 1000) + + # ULID: 48位时间戳 + 80位随机数, Crockford Base32 + alphabet = "0123456789ABCDEFGHJKMNPQRSTVWXYZ" + + ids = [] + for _ in range(count): + ts = int(time.time() * 1000) + # 时间部分 (10 chars) + t_chars = [] + t = ts + for _ in range(10): + t_chars.append(alphabet[t & 0x1F]) + t >>= 5 + t_chars.reverse() + # 随机部分 (16 chars) + r_chars = [random.choice(alphabet) for _ in range(16)] + ids.append(''.join(t_chars) + ''.join(r_chars)) + + header = f" ULID ({count} 个):\n" + if count <= 20: + return header + "\n".join(f" {i}" for i in ids) + else: + return header + "\n".join(f" {i}" for i in ids[:10]) + f"\n ... (共 {count} 个)" + + def _op_timestamp(self, args: List[str]) -> str: + now = time.time() + return (f"⏱ 当前时间戳:\n" + f" 秒: {int(now)}\n" + f" 毫秒: {int(now * 1000)}\n" + f" 微秒: {int(now * 1000000)}\n" + f" ISO: {datetime.now().isoformat()}") + + def _op_from_name(self, args: List[str]) -> str: + if len(args) < 2: + return "错误：格式: from_name <命名空间> <名称>\n命名空间: dns, url, oid, x500" + ns_map = {"dns": uuid.NAMESPACE_DNS, "url": uuid.NAMESPACE_URL, + "oid": uuid.NAMESPACE_OID, "x500": uuid.NAMESPACE_X500} + ns = ns_map.get(args[0].lower(), uuid.NAMESPACE_DNS) + name = args[1] + result = uuid.uuid5(ns, name) + return f" 确定性 UUID v5:\n 命名空间: {args[0]}\n 名称: {name}\n UUID: {result}" + + def _op_batch(self, args: List[str]) -> str: + if not args: + return "错误：请提供类型 (uuid/nanoid/short/snowflake/ulid)" + id_type = args[0] + opts = self._parse_opts(args[1:]) + count = int(opts.get("n", 10)) + output = opts.get("o", "") + + # 生成对应类型的ID + gen_args = [f"-n", str(count)] + handlers = { + "uuid": self._op_uuid, + "nanoid": self._op_nanoid, + "short": self._op_short, + "snowflake": self._op_snowflake, + "ulid": self._op_ulid, + } + handler = handlers.get(id_type) + if not handler: + return f"错误：不支持的类型 '{id_type}'" + + result = handler(gen_args) + + if output: + # 提取纯ID保存到文件 + ids = [line.strip().lstrip(' ') for line in result.split('\n') + if line.strip() and not any(c in line for c in [' ', '️', '❄️'])] + try: + with open(output, 'w', encoding='utf-8') as f: + f.write('\n'.join(ids)) + return f"{result}\n\n 已保存到: {output}" + except Exception as e: + return f"{result}\n\n 保存失败: {e}" + + return result + + +def test_plugin(): + plugin = Liugin() + print("ID 生成器测试:") + print(plugin.handle('uuid')) + print(plugin.handle('uuid -v 1 -n 3')) + print(plugin.handle('nanoid -s 16')) + print(plugin.handle('short -s 6 -n 5')) + print(plugin.handle('snowflake -n 3')) + print(plugin.handle('ulid')) + print(plugin.handle('timestamp')) + print(plugin.handle('custom "ORD-{D}{D}{D}{D}-{U}{U}{U}" -n 5')) + + +if __name__ == "__main__": + test_plugin() diff --git a/plugins/image_reader.py b/plugins/image_reader.py new file mode 100644 index 0000000..20dbd22 --- /dev/null +++ b/plugins/image_reader.py @@ -0,0 +1,293 @@ +""" +图片读取插件 — 从图片中提取文字，发送给 AI +============================================= +功能：读取图片 → OCR 提取文字 → 返回给 AI +支持：Tesseract OCR / Windows PowerShell OCR / 纯 Python 元数据 +""" +import os +import sys +import json +import base64 +import hashlib +import subprocess +import platform +import tempfile +from pathlib import Path + +_IS_WIN = platform.system() == "Windows" + + +class Liugin: + """图片读取 — 从图片中提取文字""" + + def __init__(self): + self.cli = None + + def set_cli(self, cli): + self.cli = cli + + def get_tool_info(self): + return { + "name": "image_reader", + "description": "图片读取工具 — 从图片中提取文字（OCR），获取图片信息，" + "将图片内容转为文本发送给 AI", + "keywords": [ + "图片", "image", "OCR", "文字识别", "读图", "截图", + "提取文字", "图片转文字", "识别", "tesseract", + ], + "usage": ( + "image_reader <操作> <路径>\n\n" + "操作:\n" + " ocr <图片路径> - 从图片中提取文字\n" + " info <图片路径> - 获取图片信息（尺寸/格式/大小）\n" + " read <图片路径> - 综合读取（信息 + OCR）\n" + " ascii <图片路径> [宽] - 转 ASCII 字符画（终端显示）\n" + " base64 <图片路径> - 转 Base64 编码\n" + " hash <图片路径> - 计算图片哈希值\n\n" + "示例:\n" + " image_reader ocr screenshot.png - 识别截图中的文字\n" + " image_reader read photo.jpg - 综合读取图片\n" + " image_reader ascii logo.png 40 - 转40列宽ASCII画\n" + ), + } + + def get_mcp_definition(self): + return { + "name": "image_reader", + "description": "图片读取工具 — 从图片中提取文字（OCR）", + "inputSchema": { + "type": "object", + "properties": { + "action": { + "type": "string", + "enum": ["ocr", "info", "read", "ascii", "base64", "hash"], + "description": "操作类型", + }, + "path": {"type": "string", "description": "图片文件路径"}, + "width": {"type": "integer", "description": "ASCII 画宽度"}, + }, + "required": ["action", "path"], + }, + } + + def convert_mcp_args(self, arguments): + action = arguments.get("action", "") + path = arguments.get("path", "") + width = arguments.get("width", "") + parts = [action, path] + if width: + parts.append(str(width)) + return " ".join(parts) + + def handle(self, args: str) -> str: + parts = args.strip().split(maxsplit=2) + if not parts: + return "请提供操作和图片路径" + action = parts[0].lower() + path = parts[1] if len(parts) > 1 else "" + extra = parts[2] if len(parts) > 2 else "" + + if not path: + return "请提供图片路径" + + # 展开 ~ 和环境变量 + path = os.path.expanduser(os.path.expandvars(path)) + if not os.path.isfile(path): + return f"文件不存在: {path}" + + handlers = { + "ocr": self._ocr, + "info": self._info, + "read": self._read, + "ascii": self._ascii, + "base64": self._b64, + "hash": self._hash, + } + h = handlers.get(action) + if not h: + return f"不支持的操作 '{action}'" + try: + return h(path, extra) + except Exception as e: + return f"错误: {e}" + + # ── 图片信息 ── + + def _info(self, path: str, _: str) -> str: + size = os.path.getsize(path) + ext = os.path.splitext(path)[1].lower() + lines = [ + f"图片: {os.path.basename(path)}", + f"格式: {ext}", + f"大小: {self._human_size(size)}", + ] + # 尝试用 PIL 获取尺寸 + try: + from PIL import Image + with Image.open(path) as img: + lines.append(f"尺寸: {img.width} x {img.height}") + lines.append(f"模式: {img.mode}") + if hasattr(img, 'info'): + dpi = img.info.get('dpi') + if dpi: + lines.append(f"DPI: {dpi}") + except ImportError: + pass + except Exception as e: + lines.append(f"读取详情失败: {e}") + return "\n".join(lines) + + # ── OCR 文字识别 ── + + def _ocr(self, path: str, _: str) -> str: + # 方案1: Tesseract + result = self._ocr_tesseract(path) + if result: + return result + + # 方案2: Windows PowerShell OCR + if _IS_WIN: + result = self._ocr_windows(path) + if result: + return result + + # 方案3: 用 PIL 读取图片元数据，至少告诉用户图片是什么 + return ( + "未找到 OCR 引擎。请安装以下任一工具:\n" + " - Tesseract: https://github.com/tesseract-ocr/tesseract\n" + " - Ubuntu: sudo apt install tesseract-ocr tesseract-ocr-chi-sim\n" + " - macOS: brew install tesseract\n" + " - Windows: 下载 UB-Mannheim installer\n\n" + f"图片信息:\n{self._info(path, '')}" + ) + + def _ocr_tesseract(self, path: str) -> str: + """用 Tesseract OCR 提取文字""" + # 检查 tesseract 是否可用 + try: + subprocess.run(["tesseract", "--version"], + capture_output=True, timeout=5) + except (FileNotFoundError, subprocess.TimeoutExpired): + return "" + + # 执行 OCR + with tempfile.NamedTemporaryFile(suffix=".txt", delete=False) as tmp: + tmp_path = tmp.name + + try: + # 检测语言：中文+英文 + cmd = ["tesseract", path, tmp_path[:-4], "-l", "chi_sim+eng"] + subprocess.run(cmd, capture_output=True, timeout=30) + + if os.path.exists(tmp_path): + with open(tmp_path, "r", encoding="utf-8") as f: + text = f.read().strip() + if text: + return f"OCR 识别结果:\n{text}" + return "OCR 未识别到文字" + except subprocess.TimeoutExpired: + return "OCR 超时" + except Exception as e: + return f"OCR 失败: {e}" + finally: + try: + os.unlink(tmp_path) + except OSError: + pass + return "" + + def _ocr_windows(self, path: str) -> str: + """用 Windows 内置 OCR (PowerShell + Windows.Media.Ocr)""" + try: + ps_script = f''' +Add-Type -AssemblyName System.Runtime.WindowsRuntime +$bitmap = [Windows.Graphics.Imaging.SoftwareBitmap, Windows.Graphics.Imaging, ContentType=WindowsRuntime] +$ocrEngine = [Windows.Media.Ocr.OcrEngine, Windows.Media.Ocr, ContentType=WindowsRuntime] +$ocr = $ocrEngine.TryCreateFromUserProfileLanguages() +$file = Get-Item "{path}" +$stream = [System.IO.File]::OpenRead($file.FullName) +$decoder = [Windows.Graphics.Imaging.BitmapDecoder]::CreateAsync($stream).GetAwaiter().GetResult() +$bitmap = $decoder.GetSoftwareBitmapAsync().GetAwaiter().GetResult() +$result = $ocr.RecognizeAsync($bitmap).GetAwaiter().GetResult() +$result.Text +''' + result = subprocess.run( + ["powershell", "-Command", ps_script], + capture_output=True, text=True, timeout=30 + ) + if result.returncode == 0 and result.stdout.strip(): + return f"OCR 识别结果:\n{result.stdout.strip()}" + except Exception: + pass + return "" + + # ── 综合读取 ── + + def _read(self, path: str, _: str) -> str: + """信息 + OCR""" + info = self._info(path, "") + ocr = self._ocr(path, "") + return f"{info}\n\n{ocr}" + + # ── ASCII 字符画 ── + + def _ascii(self, path: str, extra: str) -> str: + """将图片转为 ASCII 字符画""" + width = int(extra) if extra.strip().isdigit() else 60 + + try: + from PIL import Image + except ImportError: + return "需要 Pillow 库: pip install Pillow" + + chars = " .:-=+*#%@" + + with Image.open(path) as img: + # 转灰度 + img = img.convert("L") + # 缩放 + ratio = img.height / img.width + new_height = int(width * ratio * 0.5) # 字符高宽比约 2:1 + img = img.resize((width, new_height)) + + lines = [] + for y in range(new_height): + row = "" + for x in range(width): + pixel = img.getpixel((x, y)) + idx = pixel * (len(chars) - 1) // 255 + row += chars[idx] + lines.append(row) + + return "\n".join(lines) + + # ── Base64 编码 ── + + def _b64(self, path: str, _: str) -> str: + with open(path, "rb") as f: + data = f.read() + ext = os.path.splitext(path)[1].lower().lstrip(".") + mime = {"png": "image/png", "jpg": "image/jpeg", "jpeg": "image/jpeg", + "gif": "image/gif", "webp": "image/webp", "bmp": "image/bmp" + }.get(ext, "image/png") + b64 = base64.b64encode(data).decode("ascii") + return f"data:{mime};base64,{b64[:100]}... ({len(b64)} 字符)" + + # ── 哈希 ── + + def _hash(self, path: str, _: str) -> str: + with open(path, "rb") as f: + data = f.read() + md5 = hashlib.md5(data).hexdigest() + sha = hashlib.sha256(data).hexdigest() + return f"MD5: {md5}\nSHA256: {sha}" + + # ── 工具 ── + + @staticmethod + def _human_size(size: int) -> str: + for unit in ["B", "KB", "MB", "GB"]: + if size < 1024: + return f"{size:.1f} {unit}" + size /= 1024 + return f"{size:.1f} TB" diff --git a/plugins/json_toolkit.py b/plugins/json_toolkit.py new file mode 100644 index 0000000..c8995e9 --- /dev/null +++ b/plugins/json_toolkit.py @@ -0,0 +1,386 @@ +""" +JSON 工具箱插件 - JSON 格式化、校验、查询、转换 +提供 JSON 美化、压缩、验证、路径查询、类型转换等功能 +""" + +import json +import os +import re +from typing import List + + +class Liugin: + """JSON 工具箱 - 格式化/校验/查询/转换""" + + def __init__(self): + self.usage = """JSON 工具箱 + +操作: + format <文件或JSON> - 美化 JSON（自动缩进） + minify <文件或JSON> - 压缩 JSON（去除空白） + validate <文件或JSON> - 校验 JSON 是否合法 + query <文件或JSON> <路径> - 按路径查询值（如 users[0].name） + keys <文件或JSON> - 列出所有键（扁平化） + diff <文件1> <文件2> - 比较两个 JSON 的差异 + to_csv <文件或JSON> - 将 JSON 数组转为 CSV + merge <文件1> <文件2> - 合并两个 JSON 对象 + sample <文件或JSON> [-n 数量] - 从数组中随机采样 + schema <文件或JSON> - 推断 JSON Schema + +示例: + json_toolkit format data.json + json_toolkit validate '{"name": "test"}' + json_toolkit query config.json "database.host" + json_toolkit keys data.json + json_toolkit diff a.json b.json +""" + self.cli = None + + def set_cli(self, cli): + self.cli = cli + + def get_tool_info(self): + return { + "name": "json_toolkit", + "description": "JSON 工具箱 - 格式化、压缩、校验、路径查询、键提取、差异比较、转换", + "keywords": ["json", "格式化", "校验", "查询", "格式", "转换", "美化", "压缩", "validate", "format"], + "usage": self.usage + } + + def get_mcp_definition(self): + return { + "name": "json_toolkit", + "description": "JSON 工具箱，支持格式化、压缩、校验、路径查询、键提取、差异比较", + "inputSchema": { + "type": "object", + "properties": { + "operation": { + "type": "string", + "enum": ["format", "minify", "validate", "query", "keys", + "diff", "to_csv", "merge", "sample", "schema"], + "description": "操作类型" + }, + "input": {"type": "string", "description": "JSON 字符串或文件路径"}, + "path": {"type": "string", "description": "查询路径（query 操作用）"}, + "input2": {"type": "string", "description": "第二个 JSON 输入（diff/merge 用）"}, + "count": {"type": "integer", "description": "采样数量（sample 操作用）"} + }, + "required": ["operation", "input"] + } + } + + def convert_mcp_args(self, arguments): + op = arguments.get("operation", "") + inp = arguments.get("input", "") + path = arguments.get("path", "") + parts = [op, inp] + if path: + parts.append(path) + return " ".join(parts) + + def handle(self, args: str) -> str: + try: + parts = self._parse_args(args) + if not parts: + return "错误：请提供操作类型" + + operation = parts[0].lower() + handlers = { + "format": self._op_format, + "minify": self._op_minify, + "validate": self._op_validate, + "query": self._op_query, + "keys": self._op_keys, + "diff": self._op_diff, + "to_csv": self._op_to_csv, + "merge": self._op_merge, + "sample": self._op_sample, + "schema": self._op_schema, + } + + handler = handlers.get(operation) + if not handler: + return f"错误：不支持的操作 '{operation}'\n支持: {', '.join(handlers.keys())}" + return handler(parts[1:]) + + except Exception as e: + return f"JSON 工具错误: {str(e)}" + + def _parse_args(self, args: str) -> List[str]: + parts, current, in_quotes, qc = [], "", False, None + for ch in args: + if ch in ('"', "'") and not in_quotes: + in_quotes, qc = True, ch + elif ch == qc and in_quotes: + in_quotes, qc = False, None + elif ch == ' ' and not in_quotes: + if current: + parts.append(current) + current = "" + else: + current += ch + if current: + parts.append(current) + return parts + + def _load_json(self, text: str): + """加载 JSON（支持文件路径或 JSON 字符串）""" + if os.path.isfile(text): + with open(text, 'r', encoding='utf-8') as f: + return json.load(f), f"文件: {text}" + try: + return json.loads(text), "JSON 字符串" + except json.JSONDecodeError as e: + raise ValueError(f"无效的 JSON: {e}") + + def _op_format(self, args: List[str]) -> str: + if not args: + return "错误：请提供 JSON 文件或字符串" + data, source = self._load_json(args[0]) + formatted = json.dumps(data, indent=2, ensure_ascii=False) + return f"✅ 格式化结果 ({source}):\n{formatted}" + + def _op_minify(self, args: List[str]) -> str: + if not args: + return "错误：请提供 JSON 文件或字符串" + data, source = self._load_json(args[0]) + minified = json.dumps(data, separators=(',', ':'), ensure_ascii=False) + original_len = len(json.dumps(data, indent=2, ensure_ascii=False)) + saved = original_len - len(minified) + return f"✅ 压缩结果 ({source}):\n{minified}\n\n📊 大小: {len(minified)} 字符 (节省 {saved} 字符, {saved/original_len*100:.1f}%)" + + def _op_validate(self, args: List[str]) -> str: + if not args: + return "错误：请提供 JSON 文件或字符串" + text = args[0] + try: + if os.path.isfile(text): + with open(text, 'r', encoding='utf-8') as f: + data = json.load(f) + source = f"文件: {text}" + else: + data = json.loads(text) + source = "JSON 字符串" + + depth = self._get_depth(data) + keys_count = self._count_keys(data) + + result = f"✅ JSON 合法 ({source})\n" + result += f" 类型: {type(data).__name__}\n" + result += f" 嵌套深度: {depth}\n" + result += f" 键总数: {keys_count}" + return result + except json.JSONDecodeError as e: + return f"❌ JSON 无效:\n 行 {e.lineno}, 列 {e.colno}: {e.msg}" + except Exception as e: + return f"❌ 验证失败: {e}" + + def _op_query(self, args: List[str]) -> str: + if len(args) < 2: + return "错误：格式: query <路径>\n示例: query data.json users[0].name" + data, _ = self._load_json(args[0]) + path = args[1] + + result = data + parts = re.findall(r'\w+|\[\d+\]', path) + current_path = "" + + for part in parts: + if part.startswith('['): + idx = int(part[1:-1]) + current_path += part + if isinstance(result, list) and 0 <= idx < len(result): + result = result[idx] + else: + return f"❌ 路径 '{current_path}' 无效: 索引越界或非数组" + else: + current_path += f".{part}" if current_path else part + if isinstance(result, dict) and part in result: + result = result[part] + else: + return f"❌ 路径 '{current_path}' 无效: 键不存在" + + output = json.dumps(result, indent=2, ensure_ascii=False) if isinstance(result, (dict, list)) else str(result) + return f"🔍 查询结果 ({path}):\n{output}" + + def _op_keys(self, args: List[str]) -> str: + if not args: + return "错误：请提供 JSON 文件或字符串" + data, _ = self._load_json(args[0]) + + keys = [] + self._flatten_keys(data, "", keys) + + result = f"🔑 键列表 (共 {len(keys)} 个):\n" + for k in keys: + result += f" {k}\n" + return result.rstrip() + + def _flatten_keys(self, obj, prefix, keys): + if isinstance(obj, dict): + for k, v in obj.items(): + full_key = f"{prefix}.{k}" if prefix else k + keys.append(full_key) + self._flatten_keys(v, full_key, keys) + elif isinstance(obj, list) and obj: + self._flatten_keys(obj[0], f"{prefix}[0]", keys) + + def _op_diff(self, args: List[str]) -> str: + if len(args) < 2: + return "错误：请提供两个 JSON 文件或字符串" + data1, src1 = self._load_json(args[0]) + data2, src2 = self._load_json(args[1]) + + diffs = [] + self._compare(data1, data2, "", diffs) + + if not diffs: + return "✅ 两个 JSON 完全相同" + + result = f"🔀 差异比较 ({len(diffs)} 处不同):\n" + for d in diffs[:50]: + result += f" {d}\n" + if len(diffs) > 50: + result += f" ... 还有 {len(diffs) - 50} 处差异" + return result.rstrip() + + def _compare(self, a, b, path, diffs): + if type(a) != type(b): + diffs.append(f" 类型不同 @ {path or '根'}: {type(a).__name__} vs {type(b).__name__}") + return + if isinstance(a, dict): + all_keys = set(a.keys()) | set(b.keys()) + for k in sorted(all_keys): + p = f"{path}.{k}" if path else k + if k not in a: + diffs.append(f"➕ 新增 @ {p}: {b[k]}") + elif k not in b: + diffs.append(f"➖ 删除 @ {p}: {a[k]}") + else: + self._compare(a[k], b[k], p, diffs) + elif isinstance(a, list): + if len(a) != len(b): + diffs.append(f" 数组长度不同 @ {path}: {len(a)} vs {len(b)}") + for i in range(min(len(a), len(b))): + self._compare(a[i], b[i], f"{path}[{i}]", diffs) + else: + if a != b: + diffs.append(f" 值不同 @ {path}: {a!r} → {b!r}") + + def _op_to_csv(self, args: List[str]) -> str: + if not args: + return "错误：请提供 JSON 文件或字符串" + data, _ = self._load_json(args[0]) + + if not isinstance(data, list) or not data: + return "错误：需要非空 JSON 数组" + if not isinstance(data[0], dict): + return "错误：数组元素必须是对象" + + headers = list(data[0].keys()) + lines = [",".join(headers)] + for item in data: + row = [] + for h in headers: + val = str(item.get(h, "")) + if "," in val or '"' in val or "\n" in val: + val = '"' + val.replace('"', '""') + '"' + row.append(val) + lines.append(",".join(row)) + + csv_content = "\n".join(lines) + return f"📊 CSV 转换结果 ({len(data)} 行):\n{csv_content}" + + def _op_merge(self, args: List[str]) -> str: + if len(args) < 2: + return "错误：请提供两个 JSON 文件或字符串" + data1, _ = self._load_json(args[0]) + data2, _ = self._load_json(args[1]) + + if not isinstance(data1, dict) or not isinstance(data2, dict): + return "错误：合并仅支持 JSON 对象" + + merged = self._deep_merge(data1, data2) + return f"✅ 合并结果:\n{json.dumps(merged, indent=2, ensure_ascii=False)}" + + def _deep_merge(self, a, b): + result = a.copy() + for k, v in b.items(): + if k in result and isinstance(result[k], dict) and isinstance(v, dict): + result[k] = self._deep_merge(result[k], v) + else: + result[k] = v + return result + + def _op_sample(self, args: List[str]) -> str: + if not args: + return "错误：请提供 JSON 文件或字符串" + data, _ = self._load_json(args[0]) + count = 3 + for i, a in enumerate(args): + if a == "-n" and i + 1 < len(args): + count = int(args[i + 1]) + + if not isinstance(data, list): + return "错误：需要 JSON 数组" + + import random + sampled = random.sample(data, min(count, len(data))) + return f"🎲 随机采样 ({len(sampled)}/{len(data)}):\n{json.dumps(sampled, indent=2, ensure_ascii=False)}" + + def _op_schema(self, args: List[str]) -> str: + if not args: + return "错误：请提供 JSON 文件或字符串" + data, _ = self._load_json(args[0]) + schema = self._infer_schema(data) + return f"📋 推断 Schema:\n{json.dumps(schema, indent=2, ensure_ascii=False)}" + + def _infer_schema(self, obj, depth=0): + if depth > 10: + return {"type": "any"} + if isinstance(obj, dict): + props = {} + for k, v in obj.items(): + props[k] = self._infer_schema(v, depth + 1) + return {"type": "object", "properties": props} + elif isinstance(obj, list): + if obj: + return {"type": "array", "items": self._infer_schema(obj[0], depth + 1)} + return {"type": "array", "items": {}} + elif isinstance(obj, bool): + return {"type": "boolean"} + elif isinstance(obj, int): + return {"type": "integer"} + elif isinstance(obj, float): + return {"type": "number"} + else: + return {"type": "string"} + + def _get_depth(self, obj, depth=0): + if depth > 50: + return depth + if isinstance(obj, dict): + return max((self._get_depth(v, depth + 1) for v in obj.values()), default=depth) + elif isinstance(obj, list): + return max((self._get_depth(v, depth + 1) for v in obj), default=depth) + return depth + + def _count_keys(self, obj): + if isinstance(obj, dict): + return len(obj) + sum(self._count_keys(v) for v in obj.values()) + elif isinstance(obj, list): + return sum(self._count_keys(v) for v in obj) + return 0 + + +def test_plugin(): + plugin = Liugin() + print("JSON 工具箱测试:") + print(plugin.handle('validate \'{"name": "test", "age": 25}\'')) + print(plugin.handle('format \'{"name":"test","items":[1,2,3]}\'')) + print(plugin.handle('keys \'{"database": {"host": "localhost", "port": 3306}}\'')) + print(plugin.handle('query \'{"users": [{"name": "Alice"}]}\' users[0].name')) + + +if __name__ == "__main__": + test_plugin() diff --git a/plugins/markdown_tool.py b/plugins/markdown_tool.py new file mode 100644 index 0000000..95bd885 --- /dev/null +++ b/plugins/markdown_tool.py @@ -0,0 +1,540 @@ +""" +Markdown 工具插件 - Markdown 渲染、目录生成、格式转换 +支持 TOC 生成、标题提取、表格生成、格式化、统计 +""" + +import re +import json +import os +from typing import List, Tuple + + +class Liugin: + """Markdown 工具 - TOC/渲染/格式转换/统计""" + + def __init__(self): + self.usage = """Markdown 工具 + +操作: + toc <文件或Markdown> - 生成目录 (Table of Contents) + headings <文件或Markdown> - 提取所有标题 + stats <文件或Markdown> - 统计信息（字数/行数/段落数等） + table <数据> - 从 JSON 数组生成 Markdown 表格 + checklist <文件> - 提取所有待办事项 + links <文件或Markdown> - 提取所有链接 + images <文件或Markdown> - 提取所有图片 + frontmatter <文件> - 提取 YAML frontmatter + format <文件或Markdown> - 格式化（标题层级、列表缩进等） + wordcount <文件或Markdown> - 详细字数统计 + outline <文件或Markdown> - 生成大纲视图 + lint <文件> - Markdown 语法检查 + +示例: + markdown_tool toc README.md + markdown_tool stats article.md + markdown_tool table '[{"name":"Alice","age":25},{"name":"Bob","age":30}]' + markdown_tool checklist TODO.md + markdown_tool links README.md + markdown_tool lint README.md +""" + self.cli = None + + def set_cli(self, cli): + self.cli = cli + + def get_tool_info(self): + return { + "name": "markdown_tool", + "description": "Markdown 工具 - TOC 生成、标题提取、统计、表格生成、语法检查", + "keywords": ["markdown", "md", "目录", "toc", "标题", "表格", "统计", "链接", "检查"], + "usage": self.usage + } + + def get_mcp_definition(self): + return { + "name": "markdown_tool", + "description": "Markdown 工具，支持 TOC、统计、表格生成、链接提取、语法检查", + "inputSchema": { + "type": "object", + "properties": { + "operation": { + "type": "string", + "enum": ["toc", "headings", "stats", "table", "checklist", + "links", "images", "frontmatter", "format", + "wordcount", "outline", "lint"], + "description": "操作类型" + }, + "input": {"type": "string", "description": "Markdown 文件路径或内容"}, + "data": {"type": "string", "description": "JSON 数据（table 操作用）"} + }, + "required": ["operation", "input"] + } + } + + def convert_mcp_args(self, arguments): + op = arguments.get("operation", "") + inp = arguments.get("input", "") + return f"{op} {inp}".strip() + + def _load_content(self, text: str) -> Tuple[str, str]: + """加载内容（文件路径或文本）""" + if os.path.isfile(text): + with open(text, 'r', encoding='utf-8') as f: + return f.read(), f"文件: {text}" + return text, "文本输入" + + def handle(self, args: str) -> str: + try: + parts = self._parse_args(args) + if not parts: + return "错误：请提供操作类型" + + operation = parts[0].lower() + handlers = { + "toc": self._op_toc, + "headings": self._op_headings, + "stats": self._op_stats, + "table": self._op_table, + "checklist": self._op_checklist, + "links": self._op_links, + "images": self._op_images, + "frontmatter": self._op_frontmatter, + "format": self._op_format, + "wordcount": self._op_wordcount, + "outline": self._op_outline, + "lint": self._op_lint, + } + + handler = handlers.get(operation) + if not handler: + return f"错误：不支持的操作 '{operation}'" + return handler(parts[1:]) + + except Exception as e: + return f"Markdown 工具错误: {str(e)}" + + def _parse_args(self, args: str) -> List[str]: + parts, current, in_quotes, qc = [], "", False, None + for ch in args: + if ch in ('"', "'") and not in_quotes: + in_quotes, qc = True, ch + elif ch == qc and in_quotes: + in_quotes, qc = False, None + elif ch == ' ' and not in_quotes: + if current: + parts.append(current) + current = "" + else: + current += ch + if current: + parts.append(current) + return parts + + def _extract_headings(self, content: str) -> List[Tuple[int, str, str]]: + """提取标题: [(level, text, slug)]""" + headings = [] + in_code = False + for line in content.split('\n'): + if line.strip().startswith('```'): + in_code = not in_code + continue + if in_code: + continue + match = re.match(r'^(#{1,6})\s+(.+)', line) + if match: + level = len(match.group(1)) + text = match.group(2).strip() + # 生成 slug + slug = re.sub(r'[^\w\s-]', '', text.lower()) + slug = re.sub(r'\s+', '-', slug.strip()) + headings.append((level, text, slug)) + return headings + + def _op_toc(self, args: List[str]) -> str: + if not args: + return "错误：请提供 Markdown 文件或内容" + content, source = self._load_content(args[0]) + headings = self._extract_headings(content) + + if not headings: + return "📭 未找到标题" + + result = f" 目录 ({source}):\n" + result += "─" * 40 + "\n" + for level, text, slug in headings: + indent = " " * (level - 1) + result += f"{indent}- [{text}](#{slug})\n" + return result.rstrip() + + def _op_headings(self, args: List[str]) -> str: + if not args: + return "错误：请提供 Markdown 文件或内容" + content, source = self._load_content(args[0]) + headings = self._extract_headings(content) + + if not headings: + return "📭 未找到标题" + + result = f" 标题列表 ({len(headings)} 个):\n" + for level, text, _ in headings: + prefix = "#" * level + result += f" {prefix:8s} {text}\n" + return result.rstrip() + + def _op_stats(self, args: List[str]) -> str: + if not args: + return "错误：请提供 Markdown 文件或内容" + content, source = self._load_content(args[0]) + + lines = content.split('\n') + total_lines = len(lines) + blank_lines = sum(1 for l in lines if not l.strip()) + code_blocks = content.count('```') // 2 + headings = len(self._extract_headings(content)) + links = len(re.findall(r'\[([^\]]+)\]\([^)]+\)', content)) + images = len(re.findall(r'!\[([^\]]*)\]\([^)]+\)', content)) + # 中文字符 + chinese = len(re.findall(r'[\u4e00-\u9fff]', content)) + # 英文单词 + english = len(re.findall(r'[a-zA-Z]+', content)) + + # 段落数（连续非空行） + paragraphs = 0 + in_para = False + for l in lines: + if l.strip(): + if not in_para: + paragraphs += 1 + in_para = True + else: + in_para = False + + result = f"📊 Markdown 统计 ({source})\n" + result += "─" * 35 + "\n" + result += f" 总行数: {total_lines}\n" + result += f" 空行: {blank_lines}\n" + result += f" 段落: {paragraphs}\n" + result += f" 代码块: {code_blocks}\n" + result += f" 标题: {headings}\n" + result += f" 链接: {links}\n" + result += f" 图片: {images}\n" + result += f" 中文字: {chinese}\n" + result += f" 英文词: {english}\n" + result += f" 字符数: {len(content)}\n" + return result.rstrip() + + def _op_table(self, args: List[str]) -> str: + if not args: + return "错误：请提供 JSON 数组" + data_str = args[0] + try: + data = json.loads(data_str) + except json.JSONDecodeError as e: + return f"❌ JSON 解析错误: {e}" + + if not isinstance(data, list) or not data: + return "❌ 需要非空 JSON 数组" + if not isinstance(data[0], dict): + return "❌ 数组元素必须是对象" + + headers = list(data[0].keys()) + # 计算列宽 + widths = {h: len(h) for h in headers} + for row in data: + for h in headers: + widths[h] = max(widths[h], len(str(row.get(h, "")))) + + # 生成表格 + header_line = "| " + " | ".join(h.ljust(widths[h]) for h in headers) + " |" + sep_line = "| " + " | ".join("-" * widths[h] for h in headers) + " |" + rows = [] + for row in data: + rows.append("| " + " | ".join(str(row.get(h, "")).ljust(widths[h]) for h in headers) + " |") + + result = f" Markdown 表格 ({len(data)} 行):\n\n" + result += header_line + "\n" + sep_line + "\n" + "\n".join(rows) + return result + + def _op_checklist(self, args: List[str]) -> str: + if not args: + return "错误：请提供 Markdown 文件" + content, source = self._load_content(args[0]) + + todos = [] + done = [] + for i, line in enumerate(content.split('\n'), 1): + match = re.match(r'^(\s*)[-*]\s*\[([ xX])\]\s*(.+)', line) + if match: + indent = match.group(1) + checked = match.group(2).lower() == 'x' + text = match.group(3).strip() + if checked: + done.append((i, text)) + else: + todos.append((i, text)) + + result = f" 待办事项 ({source}):\n" + result += "─" * 45 + "\n" + result += f" ☑ 已完成: {len(done)} 个\n" + result += f" 未完成: {len(todos)} 个\n" + result += "─" * 45 + "\n" + + if todos: + result += "\n 未完成:\n" + for line_no, text in todos[:30]: + result += f" L{line_no:4d} {text}\n" + if done: + result += "\n 已完成:\n" + for line_no, text in done[:20]: + result += f" L{line_no:4d} {text}\n" + return result.rstrip() + + def _op_links(self, args: List[str]) -> str: + if not args: + return "错误：请提供 Markdown 文件或内容" + content, source = self._load_content(args[0]) + + links = re.findall(r'\[([^\]]+)\]\(([^)]+)\)', content) + if not links: + return f"📭 未找到链接 ({source})" + + result = f" 链接列表 ({len(links)} 个, {source}):\n" + result += "─" * 50 + "\n" + seen = set() + for text, url in links: + if url not in seen: + seen.add(url) + result += f" {text[:30]:30s} → {url}\n" + return result.rstrip() + + def _op_images(self, args: List[str]) -> str: + if not args: + return "错误：请提供 Markdown 文件或内容" + content, source = self._load_content(args[0]) + + images = re.findall(r'!\[([^\]]*)\]\(([^)]+)\)', content) + if not images: + return f"📭 未找到图片 ({source})" + + result = f" ️ 图片列表 ({len(images)} 个, {source}):\n" + result += "─" * 50 + "\n" + seen = set() + for alt, url in images: + if url not in seen: + seen.add(url) + result += f" {alt[:25]:25s} → {url}\n" + return result.rstrip() + + def _op_frontmatter(self, args: List[str]) -> str: + if not args: + return "错误：请提供 Markdown 文件" + content, source = self._load_content(args[0]) + + match = re.match(r'^---\n(.*?)\n---', content, re.DOTALL) + if not match: + return f"📭 未找到 frontmatter ({source})" + + fm = match.group(1) + result = f" Frontmatter ({source}):\n" + result += "─" * 35 + "\n" + result += fm + return result + + def _op_format(self, args: List[str]) -> str: + if not args: + return "错误：请提供 Markdown 文件或内容" + content, source = self._load_content(args[0]) + lines = content.split('\n') + formatted = [] + prev_blank = False + + for line in lines: + stripped = line.strip() + # 确保标题前后有空行 + if re.match(r'^#{1,6}\s', stripped): + if formatted and not prev_blank: + formatted.append('') + formatted.append(stripped) + prev_blank = False + continue + # 确保列表项格式一致 + if re.match(r'^[-*]\s', stripped): + formatted.append(re.sub(r'^[-*]\s', '- ', stripped)) + prev_blank = False + continue + # 去除多余空行 + if not stripped: + if not prev_blank: + formatted.append('') + prev_blank = True + continue + + prev_blank = False + formatted.append(line.rstrip()) + + # 确保文件末尾有换行 + while formatted and not formatted[-1]: + formatted.pop() + formatted.append('') + + return f"✅ 格式化完成 ({source}):\n" + '\n'.join(formatted) + + def _op_wordcount(self, args: List[str]) -> str: + if not args: + return "错误：请提供 Markdown 文件或内容" + content, source = self._load_content(args[0]) + + # 移除代码块 + no_code = re.sub(r'```[\s\S]*?```', '', content) + # 移除行内代码 + no_code = re.sub(r'`[^`]+`', '', no_code) + # 移除链接标记 + no_code = re.sub(r'\[([^\]]+)\]\([^)]+\)', r'\1', no_code) + # 移除图片标记 + no_code = re.sub(r'!\[([^\]]*)\]\([^)]+\)', '', no_code) + # 移除标题标记 + no_code = re.sub(r'^#{1,6}\s+', '', no_code, flags=re.MULTILINE) + # 移除加粗/斜体标记 + no_code = re.sub(r'\*{1,2}([^*]+)\*{1,2}', r'\1', no_code) + + chinese = len(re.findall(r'[\u4e00-\u9fff]', no_code)) + english_words = re.findall(r'[a-zA-Z]+', no_code) + english = len(english_words) + total_chars = len(no_code.strip()) + + # 阅读时间估算（中文 300字/分钟, 英文 200词/分钟） + read_time_cn = chinese / 300 + read_time_en = english / 200 + read_time = read_time_cn + read_time_en + + result = f" 详细字数统计 ({source}):\n" + result += "─" * 35 + "\n" + result += f" 中文字数: {chinese}\n" + result += f" 英文单词: {english}\n" + result += f" 总字符数: {total_chars}\n" + result += f" 预计阅读: {read_time:.1f} 分钟\n" + return result.rstrip() + + def _op_outline(self, args: List[str]) -> str: + if not args: + return "错误：请提供 Markdown 文件或内容" + content, source = self._load_content(args[0]) + headings = self._extract_headings(content) + + if not headings: + return "📭 未找到标题" + + result = f" 大纲视图 ({source}):\n" + result += "═" * 40 + "\n" + for level, text, _ in headings: + if level == 1: + result += f"\n {text}\n" + result += "─" * 30 + "\n" + elif level == 2: + result += f" {text}\n" + elif level == 3: + result += f" {text}\n" + else: + result += f" {'·' * (level - 3)} {text}\n" + return result.rstrip() + + def _op_lint(self, args: List[str]) -> str: + if not args: + return "错误：请提供 Markdown 文件" + file_path = args[0] + if not os.path.isfile(file_path): + return f"❌ 文件不存在: {file_path}" + + with open(file_path, 'r', encoding='utf-8') as f: + content = f.read() + lines = content.split('\n') + + issues = [] + in_code = False + prev_blank = False + heading_levels = [] + + for i, line in enumerate(lines, 1): + stripped = line.strip() + + # 代码块跟踪 + if stripped.startswith('```'): + in_code = not in_code + continue + if in_code: + continue + + # 检查标题格式 + heading_match = re.match(r'^(#{1,6})\s+(.+)', line) + if heading_match: + level = len(heading_match.group(1)) + text = heading_match.group(2) + # 检查标题前后空行 + if i > 1 and lines[i - 2].strip() and not lines[i - 2].startswith('#'): + issues.append(f" L{i:4d} 标题前缺少空行") + # 检查标题层级跳跃 + if heading_levels and level > heading_levels[-1] + 1: + issues.append(f" L{i:4d} 标题层级跳跃 ({heading_levels[-1]} → {level})") + heading_levels.append(level) + # 检查标题末尾空格 + if text != text.rstrip(): + issues.append(f" L{i:4d} 标题末尾有多余空格") + else: + # 检查行尾空格 + if line != line.rstrip() and stripped: + trailing = len(line) - len(line.rstrip()) + if trailing >= 2: # 2个以上空格是换行符 + pass # 这是合法的 Markdown 换行 + elif trailing > 0: + issues.append(f" L{i:4d} 行尾有多余空格") + + # 检查连续空行 + if not stripped: + if prev_blank: + issues.append(f" L{i:4d} 连续空行") + prev_blank = True + else: + prev_blank = False + + # 检查列表格式 + list_match = re.match(r'^(\s*)[-*+]\s', line) + if list_match: + indent = len(list_match.group(1)) + if indent % 2 != 0 and indent > 0: + issues.append(f" L{i:4d} 列表缩进不是2的倍数") + + # 检查链接格式 + if re.search(r'\[[^\]]*\]\(\s*\)', line): + issues.append(f" L{i:4d} 链接URL为空") + + # 检查重复词 + words = stripped.lower().split() + for j in range(len(words) - 1): + if len(words[j]) > 2 and words[j] == words[j + 1]: + issues.append(f" L{i:4d} 重复词: '{words[j]}'") + + result = f" ️ Markdown 语法检查 ({file_path}):\n" + result += "─" * 45 + "\n" + + if not issues: + result += " 未发现问题！\n" + else: + result += f" 发现 {len(issues)} 个问题:\n\n" + for issue in issues[:50]: + result += f" {issue}\n" + if len(issues) > 50: + result += f"\n ... 还有 {len(issues) - 50} 个问题\n" + + return result.rstrip() + + +def test_plugin(): + plugin = Liugin() + print("Markdown 工具测试:") + print(plugin.handle('headings "# Hello\\n## World\\n### Sub"')) + print(plugin.handle('stats "# Hello\\n\\nThis is a test."')) + print(plugin.handle('table \'[{"name":"Alice","age":25},{"name":"Bob","age":30}]\'')) + + +if __name__ == "__main__": + test_plugin() diff --git a/plugins/memory_plugin.py b/plugins/memory_plugin.py new file mode 100644 index 0000000..2a04a66 --- /dev/null +++ b/plugins/memory_plugin.py @@ -0,0 +1,253 @@ +""" +记忆系统插件 — 包装 xcli_core/memory.py 中的 MemoryManager +使 AI 可以通过工具接口读写日记、搜索记忆、管理聊天记录、操作永久性记忆 +""" +import os +import sys + +# 添加项目根目录到 path +current_dir = os.path.dirname(os.path.abspath(__file__)) +project_root = os.path.dirname(current_dir) +sys.path.insert(0, project_root) + +from xcli_core.memory import MemoryManager + + +class Liugin: + """持久化记忆系统 — AI 可读写永久记忆、日记、搜索历史对话""" + + def __init__(self): + self.cli = None + self.memory = None + self.usage = """持久化记忆系统工具 + +操作: + diary <内容> - 写当日日记 + diary_ai <内容> - AI 写观察日记（标记为 AI 观察） + remember <内容> - 记录到长期记忆 (MEMORY.md 备忘 section) + search <关键词> - 全局搜索（日记+记忆+聊天记录） + context - 查看当前注入的记忆上下文 + diary_list - 列出所有日记文件 + diary_read <日期> - 读取指定日期的日记（如 2026-04-27） + +永久性记忆 (MEMORY.md) 操作: + memory_read - 读取整个 MEMORY.md + memory_write <内容> - 追加到 MEMORY.md 备忘 section + memory_sections - 列出所有记忆分类(section) + memory_read_section <名称> - 读取指定 section 的内容 + memory_write_section <名称> <内容> - 写入/覆盖指定 section（不存在则新建） + memory_delete_section <名称> - 删除指定 section + +聊天记录: + chat_list - 列出最近的聊天记录 + chat_search <关键词> - 在聊天记录中搜索 + +JSON 格式示例: + {"action": "use_tool", "tool": "memory_plugin", "args": "remember 用户偏好深色主题"} + {"action": "use_tool", "tool": "memory_plugin", "args": "memory_write_section 用户偏好 - 喜欢简洁的代码风格\n- 使用 Python 3.10+"} + {"action": "use_tool", "tool": "memory_plugin", "args": "memory_read_section 用户偏好"} + {"action": "use_tool", "tool": "memory_plugin", "args": "search 定时任务"} +""" + + def set_cli(self, cli): + self.cli = cli + project_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) + self.memory = MemoryManager(project_dir) + cli.memory_manager = self.memory + + def get_tool_info(self): + return { + "name": "memory_plugin", + "description": "持久化记忆系统 — AI 可读写永久记忆(MEMORY.md)、写日记、搜索历史对话。支持按 section 分类存储和修改记忆。", + "keywords": ["记忆", "memory", "日记", "diary", "搜索", "search", "历史", "history", + "remember", "聊天记录", "chat", "上下文", "context", "压缩", "compress", + "永久", "persistent", "存储", "store", "读取", "read", "修改", "modify"], + "usage": self.usage + } + + def handle(self, args: str) -> str: + if not self.memory: + return "错误：记忆系统未初始化" + + if not args or not args.strip(): + return self._help() + + parts = args.strip().split(None, 1) + action = parts[0].lower() + rest = parts[1].strip() if len(parts) > 1 else "" + + handlers = { + "diary": self._diary, + "diary_ai": self._diary_ai, + "remember": self._remember, + "search": self._search, + "context": self._context, + "diary_list": self._diary_list, + "diary_read": self._diary_read, + "chat_list": self._chat_list, + "chat_search": self._chat_search, + "memory_read": self._memory_read, + "memory_write": self._memory_write, + "memory_sections": self._memory_sections, + "memory_read_section": self._memory_read_section, + "memory_write_section": self._memory_write_section, + "memory_delete_section": self._memory_delete_section, + "help": lambda _: self._help(), + } + + handler = handlers.get(action) + if not handler: + return f"未知操作: {action}\n" + self._help() + + return handler(rest) + + # ── 日记 ── + + def _diary(self, content: str) -> str: + if not content: + return "错误：请提供日记内容\n用法: diary <内容>" + self.memory.write_diary(content) + return f"日记已写入 {self.memory._today_file()}" + + def _diary_ai(self, content: str) -> str: + if not content: + return "错误：请提供 AI 观察内容\n用法: diary_ai <内容>" + self.memory.write_ai_diary(content) + return "AI 观察日记已写入" + + def _diary_list(self, _: str) -> str: + files = self.memory.list_diary_files() + if not files: + return "还没有日记文件" + return "日记文件:\n" + "\n".join(f" {f}" for f in files[:20]) + + def _diary_read(self, date_str: str) -> str: + if not date_str: + return "错误：请提供日期\n用法: diary_read <日期，如 2026-04-27>" + content = self.memory.load_diary(date_str) + return content if content else f"没有找到 {date_str} 的日记" + + # ── 永久性记忆 (MEMORY.md) ── + + def _remember(self, content: str) -> str: + """快速记录到备忘 section""" + if not content: + return "错误：请提供要记住的内容\n用法: remember <内容>" + self.memory.append_memory("备忘", f"- {content}") + return "已记录到 MEMORY.md 长期记忆 (备忘 section)" + + def _memory_read(self, _: str) -> str: + content = self.memory.load_memory() + return content if content else "MEMORY.md 为空" + + def _memory_write(self, content: str) -> str: + """追加到备忘 section""" + if not content: + return "错误：请提供内容\n用法: memory_write <内容>" + self.memory.append_memory("备忘", f"- {content}") + return "已追加到 MEMORY.md (备忘 section)" + + def _memory_sections(self, _: str) -> str: + """列出所有 section""" + sections = self.memory.list_memory_sections() + if not sections: + return "MEMORY.md 为空，没有任何 section" + return "MEMORY.md 中的 section:\n" + "\n".join(f" {i+1}. {s}" for i, s in enumerate(sections)) + + def _memory_read_section(self, section: str) -> str: + """读取指定 section""" + if not section: + return "错误：请提供 section 名称\n用法: memory_read_section <名称>" + content = self.memory.read_memory_section(section) + if not content: + return f"section '{section}' 不存在或为空" + return f"## {section}\n{content}" + + def _memory_write_section(self, args: str) -> str: + """写入/覆盖指定 section""" + if not args: + return "错误：请提供 section 名称和内容\n用法: memory_write_section <名称> <内容>" + parts = args.split(None, 1) + section = parts[0] + content = parts[1] if len(parts) > 1 else "" + if not content: + return "错误：请提供内容\n用法: memory_write_section <名称> <内容>" + self.memory.write_memory_section(section, content) + return f"已写入 MEMORY.md section '{section}'" + + def _memory_delete_section(self, section: str) -> str: + """删除指定 section""" + if not section: + return "错误：请提供 section 名称\n用法: memory_delete_section <名称>" + if self.memory.delete_memory_section(section): + return f"已删除 MEMORY.md section '{section}'" + return f"section '{section}' 不存在" + + # ── 搜索 ── + + def _search(self, keyword: str) -> str: + if not keyword: + return "错误：请提供搜索关键词\n用法: search <关键词>" + results = self.memory.search_memory(keyword) + if not results: + return f"未找到与 '{keyword}' 相关的记忆" + lines = [f"搜索 '{keyword}' 的结果 ({len(results)} 条):"] + for r in results: + source = r.get("source", "") + snippet = r.get("snippet", "") + role = r.get("role", "") + line_num = r.get("line", "") + prefix = f"[{role}] " if role else "" + line_info = f" (L{line_num})" if line_num else "" + lines.append(f" {source}{line_info}: {prefix}{snippet}") + return "\n".join(lines) + + def _context(self, _: str) -> str: + ctx = self.memory.build_memory_context() + return ctx if ctx else "当前没有记忆上下文" + + # ── 聊天记录 ── + + def _chat_list(self, _: str) -> str: + chats = self.memory.list_chats() + if not chats: + return "没有保存的聊天记录" + lines = ["最近的聊天记录:"] + for c in chats: + lines.append(f" {c['name']} ({c['time']}, {c['size_kb']}KB)") + return "\n".join(lines) + + def _chat_search(self, keyword: str) -> str: + if not keyword: + return "错误：请提供关键词\n用法: chat_search <关键词>" + results = self.memory.search_chats(keyword) + if not results: + return f"未在聊天记录中找到 '{keyword}'" + lines = [f"聊天记录搜索 '{keyword}':"] + for r in results: + name = r.get("name", r.get("file", "")) + lines.append(f" {name} [{r.get('role', '')}]: {r.get('snippet', '')}") + return "\n".join(lines) + + def _help(self) -> str: + return """记忆系统用法: + +日记: + diary <内容> - 写当日日记 + diary_ai <内容> - AI 写观察日记 + diary_list - 列出日记 + diary_read <日期> - 读取日记 + +永久性记忆 (MEMORY.md): + remember <内容> - 快速记到备忘 + memory_read - 读取整个 MEMORY.md + memory_write <内容> - 追加到备忘 + memory_sections - 列出所有 section + memory_read_section <名称> - 读取指定 section + memory_write_section <名称> <内容> - 写入/覆盖 section + memory_delete_section <名称> - 删除 section + +搜索: + search <关键词> - 全局搜索 + chat_search <关键词> - 搜索聊天记录 + context - 查看记忆上下文""" diff --git a/plugins/network_tools.py b/plugins/network_tools.py new file mode 100644 index 0000000..b54e768 --- /dev/null +++ b/plugins/network_tools.py @@ -0,0 +1,295 @@ +import requests +import time +import socket +import ssl +import json +from urllib.parse import urlparse +from colorama import Fore, Style + + +class Liugin: + """网络工具插件""" + + _UA = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36' + + def __init__(self): + self.cli = None + self.timeout = 10 + self.max_retries = 2 + + def set_cli(self, cli): + self.cli = cli + self.cli.register_liugin_command('net', self.command_handler) + self.cli.register_liugin_command('ping', lambda a: self.handle(f"ping {a}")) + self.cli.register_liugin_command('website', lambda a: self.handle(f"status {a}")) + + def command_handler(self, args): + parts = args.strip().split(maxsplit=1) + if not parts: + return "用法: network_tools <操作> <参数>" + return self.handle(f"{parts[0].lower()} {parts[1] if len(parts) > 1 else ''}") + + def get_tool_info(self): + return { + "name": "network_tools", + "description": "网络工具：ping/get/status/headers/ip/dns/ssl/port/post/put/delete", + "keywords": ["网络", "ping", "get", "post", "dns", "ssl", "port", "ip", "headers", "status"], + "usage": ( + "network_tools <操作> <参数>\n\n" + "读取: get/status/headers \n" + "诊断: ping/dns/ssl <域名>\n" + "扫描: port <域名> [端口范围]\n" + "请求: post/put/delete [JSON体]\n" + "解析: ip <域名>" + ), + } + + def get_mcp_definition(self): + return { + "name": "network_tools", + "description": "网络工具：读取网页、诊断连接、发送HTTP请求、DNS/SSL/端口扫描", + "inputSchema": { + "type": "object", + "properties": { + "operation": { + "type": "string", + "enum": ["ping", "get", "status", "headers", "ip", "dns", "ssl", "port", "post", "put", "delete"], + }, + "target": {"type": "string", "description": "URL、域名或IP"}, + "extra": {"type": "string", "description": "附加参数：JSON body 或端口范围"} + }, + "required": ["operation", "target"] + } + } + + def convert_mcp_args(self, arguments): + op = arguments.get("operation", "") + target = arguments.get("target", "") + extra = arguments.get("extra", "") + return f"{op} {target} {extra}".strip() + + def handle(self, args): + try: + parts = args.strip().split(maxsplit=2) + if not parts: + return "参数不足" + op = parts[0].lower() + target = parts[1].strip() if len(parts) > 1 else "" + extra = parts[2].strip() if len(parts) > 2 else "" + + if op == "post": + return self._api(target, "POST", extra) + elif op == "put": + return self._api(target, "PUT", extra) + elif op == "delete": + return self._api(target, "DELETE", extra) + elif op == "ping": + return self._ping(target) + elif op == "get": + return self._get(target) + elif op == "status": + return self._status(target) + elif op == "headers": + return self._headers(target) + elif op == "ip": + return self._ip(target) + elif op == "dns": + return self._dns(target) + elif op == "ssl": + return self._ssl(target) + elif op == "port": + return self._port(target, extra) + else: + return f"不支持: {op}。支持: ping/get/status/headers/ip/dns/ssl/port/post/put/delete" + except Exception as e: + return f"错误: {e}" + + def _url(self, t): + return t if t.startswith(('http://', 'https://')) else 'https://' + t + + def _req(self, url, method='GET', data=None, ct=None): + headers = {'User-Agent': self._UA, 'Accept': '*/*'} + if ct: + headers['Content-Type'] = ct + for i in range(self.max_retries + 1): + try: + r = requests.request(method, url, timeout=self.timeout, headers=headers, allow_redirects=True, + json=data if ct == 'application/json' else None, + data=data if (ct and ct != 'application/json') else None) + if not r.encoding or r.encoding.lower() == 'iso-8859-1': + r.encoding = r.apparent_encoding or 'utf-8' + return r + except requests.exceptions.Timeout: + if i < self.max_retries: + time.sleep(1) + continue + return None + except Exception: + return None + return None + + def _ping(self, t): + url = self._url(t) + start = time.time() + r = self._req(url) + ms = (time.time() - start) * 1000 + if not r: + return f"Ping {t}: 连接失败" + status = "成功" if r.status_code < 400 else f"HTTP {r.status_code}" + extra = f"\n 重定向: {r.url}" if r.url != url else "" + return f"Ping {t}:\n 状态: {status}\n 延迟: {ms:.0f}ms\n HTTP: {r.status_code}{extra}" + + def _get(self, t): + url = self._url(t) + r = self._req(url) + if not r: + return f"GET {t}: 失败" + content = r.text + return f"GET {url} [{r.status_code}]:\n{content}" + + def _status(self, t): + url = self._url(t) + r = self._req(url) + if not r: + return f"STATUS {t}: 失败" + return ( + f"STATUS {url}:\n" + f" 状态码: {r.status_code} {r.reason}\n" + f" 延迟: {r.elapsed.total_seconds()*1000:.0f}ms\n" + f" 大小: {len(r.content)} bytes\n" + f" 服务器: {r.headers.get('Server', '?')}\n" + f" 类型: {r.headers.get('Content-Type', '?')}\n" + f" 最终URL: {r.url}" + ) + + def _headers(self, t): + url = self._url(t) + r = self._req(url, method='HEAD') + if not r: + r = self._req(url) + if not r: + return f"HEADERS {t}: 失败" + lines = [f"HEADERS {url}:"] + for k, v in r.headers.items(): + lines.append(f" {k}: {v}") + return "\n".join(lines) + + def _ip(self, t): + if t.startswith(('http://', 'https://')): + t = urlparse(t).netloc + try: + ips = list(set(addr[4][0] for addr in socket.getaddrinfo(t, None))) + return f"IP {t}:\n" + "\n".join(f" {ip}" for ip in ips) + except socket.gaierror: + return f"IP {t}: 解析失败" + + def _dns(self, t): + if t.startswith(('http://', 'https://')): + t = urlparse(t).netloc + lines = [f"DNS {t}:"] + try: + seen = set() + for item in socket.getaddrinfo(t, None): + ip = item[4][0] + fam = "IPv4" if item[0] == socket.AF_INET else "IPv6" + if (ip, fam) not in seen: + seen.add((ip, fam)) + lines.append(f" {fam}: {ip}") + except socket.gaierror as e: + lines.append(f" 失败: {e}") + fqdn = socket.getfqdn(t) + if fqdn != t: + lines.append(f" FQDN: {fqdn}") + return "\n".join(lines) + + def _ssl(self, t): + if t.startswith(('http://', 'https://')): + t = urlparse(t).netloc + host = t.split(':')[0] + lines = [f"SSL {t}:"] + try: + ctx = ssl.create_default_context() + with ctx.wrap_socket(socket.socket(), server_hostname=host) as s: + s.settimeout(self.timeout) + s.connect((host, 443)) + cert = s.getpeercert() + subj = dict(x[0] for x in cert.get('subject', [])) + iss = dict(x[0] for x in cert.get('issuer', [])) + lines.append(f" 主题: {subj.get('commonName', '?')}") + lines.append(f" 颁发: {iss.get('organizationName', iss.get('commonName', '?'))}") + lines.append(f" 生效: {cert.get('notBefore', '?')}") + lines.append(f" 过期: {cert.get('notAfter', '?')}") + san = cert.get('subjectAltName', []) + if san: + doms = [v for _, v in san[:5]] + lines.append(f" SAN: {', '.join(doms)}{'...' if len(san) > 5 else ''}") + lines.append(f" 状态: 有效") + except ssl.SSLCertVerificationError as e: + lines.append(f" 状态: 验证失败 - {e}") + except socket.timeout: + lines.append(f" 状态: 超时") + except ConnectionRefusedError: + lines.append(f" 状态: 连接被拒绝") + except Exception as e: + lines.append(f" 状态: {e}") + return "\n".join(lines) + + def _port(self, t, rng=''): + if t.startswith(('http://', 'https://')): + t = urlparse(t).netloc.split(':')[0] + if '-' in rng: + try: + s, e = rng.split('-', 1) + s, e = max(1, int(s)), min(65535, int(e)) + except ValueError: + s, e = 1, 1024 + else: + s, e = 1, 1024 + try: + ip = socket.gethostbyname(t) + except socket.gaierror: + return f"PORT {t}: 解析失败" + common = {21:'FTP',22:'SSH',23:'Telnet',25:'SMTP',53:'DNS',80:'HTTP',110:'POP3',143:'IMAP',443:'HTTPS',993:'IMAPS',995:'POP3S',3306:'MySQL',3389:'RDP',5432:'PostgreSQL',6379:'Redis',8080:'HTTP-Alt',8443:'HTTPS-Alt',27017:'MongoDB'} + open_p = [] + for p in range(s, e + 1): + try: + sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) + sock.settimeout(0.3) + if sock.connect_ex((ip, p)) == 0: + open_p.append((p, common.get(p, '?'))) + sock.close() + except Exception: + pass + lines = [f"PORT {t} ({s}-{e}), IP={ip}:"] + if open_p: + for p, svc in sorted(open_p): + lines.append(f" {p}/{svc}") + else: + lines.append(f" 无开放端口") + return "\n".join(lines) + + def _api(self, url, method, body_str): + url = self._url(url) + data = None + ct = None + if body_str: + try: + data = json.loads(body_str) + ct = 'application/json' + except json.JSONDecodeError: + data = body_str + ct = 'text/plain' + r = self._req(url, method=method, data=data, ct=ct) + if not r: + return f"{method} {url}: 失败" + lines = [f"{method} {url} [{r.status_code}]"] + ctype = r.headers.get('Content-Type', '') + if 'json' in ctype: + try: + body = json.dumps(r.json(), ensure_ascii=False, indent=2) + lines.append(body) + except Exception: + lines.append(r.text) + else: + lines.append(r.text) + return "\n".join(lines) diff --git a/plugins/regex_tester.py b/plugins/regex_tester.py new file mode 100644 index 0000000..af46c9f --- /dev/null +++ b/plugins/regex_tester.py @@ -0,0 +1,442 @@ +""" +正则表达式测试器插件 - 测试、调试、管理正则表达式 +支持匹配测试、提取、替换、常用模式库 +""" + +import re +import json +import os +from typing import List + + +class Liugin: + """正则表达式测试器 - 测试、调试、管理正则""" + + def __init__(self): + self.usage = """正则表达式测试器 + +操作: + test <正则> <文本> [-f flags] - 测试正则是否匹配 + match <正则> <文本> [-f flags] - 提取所有匹配项 + replace <正则> <文本> <替换> - 测试替换 + groups <正则> <文本> - 显示分组信息 + explain <正则> - 解释正则含义 + flags <正则> <文本> - 测试不同标志组合 + pattern [名称] - 列出/查看常用模式 + save <名称> <正则> [-d 描述] - 保存自定义模式 + delete_pattern <名称> - 删除自定义模式 + bench <正则> <文本> [-n 次数] - 性能测试 + +标志 (flags): + i - 忽略大小写 m - 多行模式 s - 点匹配换行 + x - 详细模式 a - ASCII模式 + +示例: + regex_tester test "\\d+" "abc123def456" + regex_tester match "[a-z]+@[a-z]+\\.[a-z]+" "test@example.com foo@bar.org" + regex_tester groups "(\\w+)@(\\w+)\\.(\\w+)" "user@domain.com" + regex_tester explain "[a-z]+@\\w+\\.\\w+" + regex_tester pattern email +""" + self.cli = None + self.patterns_file = "regex_patterns.json" + self.custom_patterns = self._load_patterns() + + def set_cli(self, cli): + self.cli = cli + + def get_tool_info(self): + return { + "name": "regex_tester", + "description": "正则表达式测试器 - 测试匹配、提取、替换、解释、常用模式库", + "keywords": ["正则", "regex", "匹配", "表达式", "测试", "替换", "提取", "模式"], + "usage": self.usage + } + + def get_mcp_definition(self): + return { + "name": "regex_tester", + "description": "正则表达式测试器，支持匹配测试、提取、替换、解释、性能测试", + "inputSchema": { + "type": "object", + "properties": { + "operation": { + "type": "string", + "enum": ["test", "match", "replace", "groups", "explain", + "flags", "pattern", "save", "bench"], + "description": "操作类型" + }, + "pattern": {"type": "string", "description": "正则表达式"}, + "text": {"type": "string", "description": "测试文本"}, + "replacement": {"type": "string", "description": "替换文本"}, + "flags": {"type": "string", "description": "标志 (i/m/s/x)"}, + "name": {"type": "string", "description": "模式名称"}, + "description": {"type": "string", "description": "模式描述"}, + "count": {"type": "integer", "description": "测试次数"} + }, + "required": ["operation"] + } + } + + def convert_mcp_args(self, arguments): + op = arguments.get("operation", "") + pattern = arguments.get("pattern", "") + text = arguments.get("text", "") + return f"{op} {pattern} {text}".strip() + + def _load_patterns(self): + try: + if os.path.exists(self.patterns_file): + with open(self.patterns_file, 'r', encoding='utf-8') as f: + return json.load(f) + except Exception: + pass + return self._default_patterns() + + def _save_patterns(self): + try: + with open(self.patterns_file, 'w', encoding='utf-8') as f: + json.dump(self.custom_patterns, f, ensure_ascii=False, indent=2) + except Exception: + pass + + def _default_patterns(self): + return { + "email": {"pattern": r"[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}", "desc": "邮箱地址"}, + "phone_cn": {"pattern": r"1[3-9]\d{9}", "desc": "中国手机号"}, + "url": {"pattern": r"https?://[^\s<>\"']+|www\.[^\s<>\"']+", "desc": "URL链接"}, + "ipv4": {"pattern": r"\b(?:\d{1,3}\.){3}\d{1,3}\b", "desc": "IPv4地址"}, + "date": {"pattern": r"\d{4}[-/]\d{1,2}[-/]\d{1,2}", "desc": "日期格式"}, + "time": {"pattern": r"\d{2}:\d{2}(:\d{2})?", "desc": "时间格式"}, + "chinese": {"pattern": r"[\u4e00-\u9fff]+", "desc": "中文字符"}, + "id_card": {"pattern": r"\d{17}[\dXx]", "desc": "身份证号"}, + "html_tag": {"pattern": r"<[^>]+>", "desc": "HTML标签"}, + "ip_port": {"pattern": r"\b(?:\d{1,3}\.){3}\d{1,3}:\d{1,5}\b", "desc": "IP:端口"}, + "mac_addr": {"pattern": r"([0-9A-Fa-f]{2}[:-]){5}[0-9A-Fa-f]{2}", "desc": "MAC地址"}, + "hex_color": {"pattern": r"#[0-9A-Fa-f]{3,8}", "desc": "十六进制颜色"}, + "number": {"pattern": r"-?\d+\.?\d*", "desc": "数字（整数/浮点）"}, + "word": {"pattern": r"\b\w+\b", "desc": "单词"}, + } + + def handle(self, args: str) -> str: + try: + parts = self._parse_args(args) + if not parts: + return "错误：请提供操作类型" + + operation = parts[0].lower() + handlers = { + "test": self._op_test, + "match": self._op_match, + "replace": self._op_replace, + "groups": self._op_groups, + "explain": self._op_explain, + "flags": self._op_flags, + "pattern": self._op_pattern, + "save": self._op_save, + "delete_pattern": self._op_delete_pattern, + "bench": self._op_bench, + } + + handler = handlers.get(operation) + if not handler: + return f"错误：不支持的操作 '{operation}'" + return handler(parts[1:]) + + except Exception as e: + return f"正则测试错误: {str(e)}" + + def _parse_args(self, args: str) -> List[str]: + parts, current, in_quotes, qc = [], "", False, None + for ch in args: + if ch in ('"', "'") and not in_quotes: + in_quotes, qc = True, ch + elif ch == qc and in_quotes: + in_quotes, qc = False, None + elif ch == ' ' and not in_quotes: + if current: + parts.append(current) + current = "" + else: + current += ch + if current: + parts.append(current) + return parts + + def _parse_flags(self, flags_str: str) -> int: + flags = 0 + for c in flags_str.lower(): + if c == 'i': flags |= re.IGNORECASE + elif c == 'm': flags |= re.MULTILINE + elif c == 's': flags |= re.DOTALL + elif c == 'x': flags |= re.VERBOSE + return flags + + def _op_test(self, args: List[str]) -> str: + if len(args) < 2: + return "错误：格式: test <正则> <文本> [-f 标志]" + pattern_str, text = args[0], args[1] + flags = 0 + for i, a in enumerate(args): + if a == "-f" and i + 1 < len(args): + flags = self._parse_flags(args[i + 1]) + + try: + pattern = re.compile(pattern_str, flags) + match = pattern.search(text) + if match: + return (f"✅ 匹配成功!\n" + f" 正则: {pattern_str}\n" + f" 位置: {match.start()}-{match.end()}\n" + f" 匹配: '{match.group()}'\n" + f" 全文: {pattern.findall(text)}") + else: + return f"❌ 无匹配\n 正则: {pattern_str}\n 文本: {text[:100]}" + except re.error as e: + return f"❌ 正则语法错误: {e}" + + def _op_match(self, args: List[str]) -> str: + if len(args) < 2: + return "错误：格式: match <正则> <文本>" + pattern_str, text = args[0], args[1] + flags = 0 + for i, a in enumerate(args): + if a == "-f" and i + 1 < len(args): + flags = self._parse_flags(args[i + 1]) + + try: + pattern = re.compile(pattern_str, flags) + matches = pattern.finditer(text) + + results = [] + for m in matches: + results.append(f" [{m.start():3d}-{m.end():3d}] '{m.group()}'") + + if results: + return f" 找到 {len(results)} 个匹配:\n" + "\n".join(results) + else: + return "❌ 未找到匹配" + except re.error as e: + return f"❌ 正则语法错误: {e}" + + def _op_replace(self, args: List[str]) -> str: + if len(args) < 3: + return "错误：格式: replace <正则> <文本> <替换>" + pattern_str, text, replacement = args[0], args[1], args[2] + + try: + result = re.sub(pattern_str, replacement, text) + count = len(re.findall(pattern_str, text)) + return (f" 替换结果 ({count} 处):\n" + f" 原文: {text}\n" + f" 结果: {result}") + except re.error as e: + return f"❌ 正则语法错误: {e}" + + def _op_groups(self, args: List[str]) -> str: + if len(args) < 2: + return "错误：格式: groups <正则> <文本>" + pattern_str, text = args[0], args[1] + + try: + pattern = re.compile(pattern_str) + match = pattern.search(text) + if not match: + return "❌ 无匹配" + + result = f" 分组信息:\n" + result += f" 完整匹配: '{match.group()}' (span: {match.span()})\n" + for i, group in enumerate(match.groups(), 1): + result += f" 分组 {i}: '{group}' (span: {match.span(i) if group else 'N/A'})\n" + if match.groupdict(): + result += f" 命名分组:\n" + for name, value in match.groupdict().items(): + result += f" {name}: '{value}'\n" + return result.rstrip() + except re.error as e: + return f"❌ 正则语法错误: {e}" + + def _op_explain(self, args: List[str]) -> str: + if not args: + return "错误：请提供正则表达式" + pattern_str = args[0] + + explanations = [] + i = 0 + while i < len(pattern_str): + ch = pattern_str[i] + + if ch == '\\': + if i + 1 < len(pattern_str): + next_ch = pattern_str[i + 1] + escape_map = { + 'd': '数字 [0-9]', 'D': '非数字', 'w': '字母/数字/下划线', + 'W': '非字母数字下划线', 's': '空白字符', 'S': '非空白字符', + 'b': '单词边界', 'B': '非单词边界', 'n': '换行', 't': '制表符', + } + if next_ch in escape_map: + explanations.append(('\\' + next_ch, escape_map[next_ch])) + else: + explanations.append(('\\' + next_ch, f'转义字符 {next_ch}')) + i += 2 + continue + + if ch == '.': + explanations.append(('.', '任意字符（除换行）')) + elif ch == '^': + explanations.append(('^', '行/字符串开头')) + elif ch == '$': + explanations.append(('$', '行/字符串结尾')) + elif ch == '*': + explanations.append(('*', '0次或多次')) + elif ch == '+': + explanations.append(('+', '1次或多次')) + elif ch == '?': + explanations.append(('?', '0次或1次')) + elif ch == '{': + end = pattern_str.find('}', i) + if end != -1: + quantifier = pattern_str[i:end + 1] + explanations.append((quantifier, f'量词: {quantifier}')) + i = end + 1 + continue + elif ch == '[': + end = pattern_str.find(']', i) + if end != -1: + char_class = pattern_str[i:end + 1] + explanations.append((char_class, f'字符类: {char_class}')) + i = end + 1 + continue + elif ch == '(': + if i + 1 < len(pattern_str) and pattern_str[i + 1] == '?': + if i + 2 < len(pattern_str): + special = pattern_str[i + 2] + if special == ':': + explanations.append(('(?:', '非捕获组')) + elif special == '=': + explanations.append(('(?=', '正向前瞻')) + elif special == '!': + explanations.append(('(?!', '负向前瞻')) + i += 3 + continue + explanations.append(('(', '捕获组开始')) + elif ch == ')': + explanations.append((')', '组结束')) + elif ch == '|': + explanations.append(('|', '或 (交替)')) + + i += 1 + + result = f" 正则解释: {pattern_str}\n" + result += "─" * 45 + "\n" + for token, meaning in explanations: + result += f" {token:12s} → {meaning}\n" + return result.rstrip() + + def _op_flags(self, args: List[str]) -> str: + if len(args) < 2: + return "错误：格式: flags <正则> <文本>" + pattern_str, text = args[0], args[1] + + flag_combos = [ + ("", 0, "默认"), + ("i", re.IGNORECASE, "忽略大小写"), + ("m", re.MULTILINE, "多行模式"), + ("s", re.DOTALL, "点匹配换行"), + ("im", re.IGNORECASE | re.MULTILINE, "忽略大小写+多行"), + ] + + result = f" ️ 标志测试: {pattern_str}\n" + result += "─" * 45 + "\n" + for flag_str, flag_val, desc in flag_combos: + try: + matches = re.findall(pattern_str, text, flag_val) + count = len(matches) if isinstance(matches, list) else 1 + result += f" [{flag_str or '-':3s}] {desc:12s} → {count} 个匹配: {matches[:3]}\n" + except re.error as e: + result += f" [{flag_str or '-':3s}] {desc:12s} → 错误: {e}\n" + return result.rstrip() + + def _op_pattern(self, args: List[str]) -> str: + if args: + name = args[0] + if name in self.custom_patterns: + p = self.custom_patterns[name] + return f" 模式 '{name}':\n 正则: {p['pattern']}\n 描述: {p.get('desc', '')}" + return f"❌ 未找到模式: {name}" + + result = " 常用正则模式:\n" + result += "─" * 50 + "\n" + for name, p in self.custom_patterns.items(): + result += f" {name:15s} {p['pattern'][:35]:35s} {p.get('desc', '')}\n" + return result.rstrip() + + def _op_save(self, args: List[str]) -> str: + if len(args) < 2: + return "错误：格式: save <名称> <正则> [-d 描述]" + name, pattern_str = args[0], args[1] + desc = "" + for i, a in enumerate(args): + if a == "-d" and i + 1 < len(args): + desc = args[i + 1] + + # 验证正则 + try: + re.compile(pattern_str) + except re.error as e: + return f"❌ 正则语法错误: {e}" + + self.custom_patterns[name] = {"pattern": pattern_str, "desc": desc} + self._save_patterns() + return f"✅ 已保存模式 '{name}': {pattern_str}" + + def _op_delete_pattern(self, args: List[str]) -> str: + if not args: + return "错误：请提供模式名称" + name = args[0] + if name in self.custom_patterns: + del self.custom_patterns[name] + self._save_patterns() + return f" ️ 已删除模式: {name}" + return f"❌ 未找到模式: {name}" + + def _op_bench(self, args: List[str]) -> str: + if len(args) < 2: + return "错误：格式: bench <正则> <文本> [-n 次数]" + pattern_str, text = args[0], args[1] + count = 10000 + for i, a in enumerate(args): + if a == "-n" and i + 1 < len(args): + count = int(args[i + 1]) + + try: + import time + pattern = re.compile(pattern_str) + + start = time.perf_counter() + for _ in range(count): + pattern.findall(text) + elapsed = time.perf_counter() - start + + per_op = elapsed / count * 1_000_000 # 微秒 + return (f"⏱ 性能测试:\n" + f" 正则: {pattern_str}\n" + f" 次数: {count}\n" + f" 总耗时: {elapsed:.3f}s\n" + f" 每次: {per_op:.2f}μs\n" + f" 吞吐: {count / elapsed:.0f} ops/s") + except re.error as e: + return f"❌ 正则语法错误: {e}" + + +def test_plugin(): + plugin = Liugin() + print("正则表达式测试器测试:") + print(plugin.handle('test "\\d+" "abc123def456"')) + print(plugin.handle('match "[a-z]+" "hello world foo bar"')) + print(plugin.handle('groups "(\\w+)@(\\w+)\\.(\\w+)" "user@domain.com"')) + print(plugin.handle('explain "\\d{4}-\\d{2}-\\d{2}"')) + + +if __name__ == "__main__": + test_plugin() diff --git a/plugins/scheduler.py b/plugins/scheduler.py new file mode 100644 index 0000000..048d4a1 --- /dev/null +++ b/plugins/scheduler.py @@ -0,0 +1,441 @@ +""" +定时任务插件 - AI 可设定定时任务，到时自动激活提醒 +支持一次性和重复性定时任务 +""" +import json +import os +import time +import threading +from datetime import datetime, timedelta +from colorama import Fore, Style + + +class Liugin: + """定时任务插件""" + + def __init__(self): + self.usage = """定时任务工具使用方法： + +JSON格式示例： +{"action": "use_tool", "tool": "scheduler", "args": "add 30m 提醒我检查代码"} - 30分钟后提醒 +{"action": "use_tool", "tool": "scheduler", "args": "add 2h 提交代码"} - 2小时后提醒 +{"action": "use_tool", "tool": "scheduler", "args": "add 14:30 开会"} - 今天14:30提醒 +{"action": "use_tool", "tool": "scheduler", "args": "add 2026-04-28 10:00 发布v5.2"} - 指定日期时间提醒 +{"action": "use_tool", "tool": "scheduler", "args": "list"} - 列出所有定时任务 +{"action": "use_tool", "tool": "scheduler", "args": "delete 1"} - 删除任务ID为1的任务 +{"action": "use_tool", "tool": "scheduler", "args": "clear"} - 清除所有已完成/已取消的任务 + +时间格式说明： +- 相对时间: 30s / 30m / 2h / 1d（秒/分/时/天） +- 今日时间: HH:MM（如 14:30） +- 绝对时间: YYYY-MM-DD HH:MM（如 2026-04-28 10:00） +- 重复任务: 每个时间前加 r: 前缀，如 r:30m / r:2h / r:14:30 + 重复任务会自动重新调度，不会自动删除 + +功能说明： +- add <时间> <描述> - 添加定时任务 +- list - 列出所有定时任务 +- delete <任务ID> - 删除指定任务 +- clear - 清除已完成/已取消的任务 + +当定时任务到期时，AI 会自动被激活并收到提醒。""" + + self.cli = None + self.tasks_file = os.path.join( + os.path.dirname(os.path.dirname(os.path.abspath(__file__))), + "scheduler_tasks.json" + ) + self.tasks = [] + self._lock = threading.Lock() + self._monitor_thread = None + self._monitor_running = False + self._load_tasks() + + def set_cli(self, cli): + """设置CLI实例引用""" + self.cli = cli + self.cli.register_liugin_command('scheduler', self.command_handler) + self.cli.register_liugin_command('remind', self.command_handler) + # 启动后台监控线程 + self._start_monitor() + + def command_handler(self, args): + """处理 /scheduler 或 /remind 命令""" + return self.handle(args) + + def get_tool_info(self): + return { + "name": "scheduler", + "description": "定时任务工具，AI 可设定定时提醒。支持相对时间(30m/2h)、今日时间(14:30)、绝对时间(2026-04-28 10:00)、重复任务(r:30m)", + "keywords": ["定时", "提醒", "scheduler", "remind", "闹钟", "alarm", "schedule", "计划"], + "usage": self.usage + } + + # ── 数据持久化 ── + + def _load_tasks(self): + """从文件加载任务""" + try: + if os.path.exists(self.tasks_file): + with open(self.tasks_file, 'r', encoding='utf-8') as f: + self.tasks = json.load(f) + except Exception: + self.tasks = [] + + def _save_tasks(self): + """保存任务到文件""" + try: + with open(self.tasks_file, 'w', encoding='utf-8') as f: + json.dump(self.tasks, f, ensure_ascii=False, indent=2) + except Exception: + pass + + # ── 时间解析 ── + + def _parse_time(self, time_str: str) -> tuple: + """ + 解析时间字符串 + 返回: (datetime, is_repeat, repeat_seconds) + """ + time_str = time_str.strip() + now = datetime.now() + is_repeat = False + repeat_seconds = 0 + + # 检查是否是重复任务 + if time_str.startswith('r:'): + is_repeat = True + time_str = time_str[2:].strip() + + # 相对时间: 30s / 30m / 2h / 1d + if time_str[-1:].lower() in ('s', 'm', 'h', 'd') and time_str[:-1].strip().isdigit(): + num = int(time_str[:-1].strip()) + unit = time_str[-1].lower() + multipliers = {'s': 1, 'm': 60, 'h': 3600, 'd': 86400} + seconds = num * multipliers[unit] + if is_repeat: + repeat_seconds = seconds + return now + timedelta(seconds=seconds), is_repeat, repeat_seconds + + # 绝对时间: YYYY-MM-DD HH:MM + try: + dt = datetime.strptime(time_str, "%Y-%m-%d %H:%M") + if is_repeat: + # 重复任务的绝对时间当作每日重复 + repeat_seconds = 86400 # 24h + return dt, is_repeat, repeat_seconds + except ValueError: + pass + + # 今日时间: HH:MM + try: + dt = datetime.strptime(time_str, "%H:%M") + target = now.replace(hour=dt.hour, minute=dt.minute, second=0, microsecond=0) + if target <= now: + target += timedelta(days=1) + if is_repeat: + repeat_seconds = 86400 + return target, is_repeat, repeat_seconds + except ValueError: + pass + + return None, False, 0 + + # ── 核心操作 ── + + def _add_task(self, time_str: str, message: str) -> str: + """添加定时任务""" + target_time, is_repeat, repeat_seconds = self._parse_time(time_str) + if target_time is None: + return f"无法解析时间: {time_str}。支持格式: 30m / 2h / 14:30 / 2026-04-28 10:00 / r:30m" + + with self._lock: + task_id = max([t.get('id', 0) for t in self.tasks], default=0) + 1 + task = { + "id": task_id, + "message": message, + "trigger_at": target_time.strftime("%Y-%m-%d %H:%M:%S"), + "repeat": is_repeat, + "repeat_seconds": repeat_seconds, + "status": "pending", # pending / fired / canceled + "created_at": datetime.now().strftime("%Y-%m-%d %H:%M:%S"), + } + self.tasks.append(task) + self._save_tasks() + + time_display = target_time.strftime("%Y-%m-%d %H:%M:%S") + repeat_info = f" (每{self._format_seconds(repeat_seconds)}重复)" if is_repeat else "" + return f"定时任务 #{task_id} 已创建{repeat_info}\n⏰ {time_display} → {message}" + + def _list_tasks(self) -> str: + """列出所有定时任务""" + with self._lock: + if not self.tasks: + return "暂无定时任务" + + lines = [] + now = datetime.now() + for t in self.tasks: + tid = t['id'] + status = t['status'] + msg = t['message'] + trigger = t['trigger_at'] + repeat = t.get('repeat', False) + + # 状态图标 + if status == 'pending': + remaining = self._calc_remaining(trigger, now) + icon = "⏰" + suffix = f" ({remaining})" if remaining else "" + repeat_tag = f" [每{self._format_seconds(t.get('repeat_seconds', 0))}重复]" if repeat else "" + lines.append(f" {icon} #{tid}{suffix}{repeat_tag}: {msg}") + elif status == 'fired': + lines.append(f" ✅ #{tid} (已触发): {msg}") + elif status == 'canceled': + lines.append(f" ❌ #{tid} (已取消): {msg}") + + return "\n".join(lines) if lines else "暂无定时任务" + + def _delete_task(self, task_id_str: str) -> str: + """删除指定任务""" + try: + task_id = int(task_id_str) + except ValueError: + return f"无效的任务ID: {task_id_str}" + + with self._lock: + for t in self.tasks: + if t['id'] == task_id: + t['status'] = 'canceled' + self._save_tasks() + return f"定时任务 #{task_id} 已取消: {t['message']}" + return f"未找到任务 #{task_id}" + + def _clear_tasks(self) -> str: + """清除已完成/已取消的任务""" + with self._lock: + before = len(self.tasks) + self.tasks = [t for t in self.tasks if t['status'] == 'pending'] + removed = before - len(self.tasks) + self._save_tasks() + return f"已清除 {removed} 个已结束的任务" if removed else "没有需要清除的任务" + + # ── 后台监控 ── + + def _start_monitor(self): + """启动后台监控线程""" + if self._monitor_running: + return + self._monitor_running = True + self._monitor_thread = threading.Thread(target=self._monitor_loop, daemon=True) + self._monitor_thread.start() + + def _stop_monitor(self): + """停止后台监控""" + self._monitor_running = False + + def _monitor_loop(self): + """后台监控循环 — 每秒检查到期任务""" + while self._monitor_running: + try: + self._check_due_tasks() + except Exception: + pass + time.sleep(1) + + def _check_due_tasks(self): + """检查并触发到期任务""" + now = datetime.now() + now_str = now.strftime("%Y-%m-%d %H:%M:%S") + + with self._lock: + for task in self.tasks: + if task['status'] != 'pending': + continue + + trigger_at = task['trigger_at'] + if now_str >= trigger_at: + # 触发任务 + self._fire_task(task, now) + + # 保存可能的变更 + self._save_tasks() + + def _fire_task(self, task: dict, now: datetime): + """触发一个到期任务""" + task_id = task['id'] + message = task['message'] + is_repeat = task.get('repeat', False) + repeat_seconds = task.get('repeat_seconds', 0) + + # 标记为已触发 + task['status'] = 'fired' + task['fired_at'] = now.strftime("%Y-%m-%d %H:%M:%S") + + # 重复任务：重新调度 + if is_repeat and repeat_seconds > 0: + next_time = now + timedelta(seconds=repeat_seconds) + # 创建新的重复任务 + new_task = { + "id": max([t.get('id', 0) for t in self.tasks], default=0) + 1, + "message": message, + "trigger_at": next_time.strftime("%Y-%m-%d %H:%M:%S"), + "repeat": True, + "repeat_seconds": repeat_seconds, + "status": "pending", + "created_at": now.strftime("%Y-%m-%d %H:%M:%S"), + "parent_id": task_id, + } + self.tasks.append(new_task) + + # 发送系统通知 + try: + from xcli_core.notification import notify_task_complete + notify_task_complete(f"定时提醒: {message}") + except Exception: + pass + + # 打印醒目提醒 + if not is_generating: + # CLI 模式 + print() + print(f"{Fore.YELLOW}{'═' * 50}{Style.RESET_ALL}") + print(f"{Fore.YELLOW} ⏰ 定时任务提醒 #{task_id}{Style.RESET_ALL}") + print(f"{Fore.YELLOW}{'─' * 50}{Style.RESET_ALL}") + print(f" {Fore.CYAN}任务:{Style.RESET_ALL} {message}") + print(f" {Fore.CYAN}时间:{Style.RESET_ALL} {now.strftime('%H:%M:%S')}") + if is_repeat: + next_str = (now + timedelta(seconds=repeat_seconds)).strftime("%Y-%m-%d %H:%M:%S") + print(f" {Fore.CYAN}下次:{Style.RESET_ALL} {next_str}") + print(f"{Fore.YELLOW}{'═' * 50}{Style.RESET_ALL}") + + # 自动激活 AI — 将提醒注入对话 + self._activate_ai(task_id, message) + + def _activate_ai(self, task_id: int, message: str): + """激活 AI 处理定时任务提醒""" + if not self.cli: + return + + reminder = ( + f"[系统定时提醒] 定时任务 #{task_id} 已到期。\n" + f"任务内容: {message}\n" + f"请根据任务内容进行相应的操作或提醒用户。" + ) + + # CLI 模式：在新线程中调用，避免阻塞监控 + def _cli_activate(): + try: + # 先给用户一个视觉提示 + print(f"\n{Fore.GREEN} AI 正在处理定时提醒...{Style.RESET_ALL}") + print(f"{Fore.WHITE}> {Style.RESET_ALL}", end='', flush=True) + self.cli.process_conversation(reminder) + # 重新显示输入提示 + print(f"\n{Fore.WHITE}> {Style.RESET_ALL}", end='', flush=True) + except Exception: + pass + threading.Thread(target=_cli_activate, daemon=True).start() + + # ── 辅助函数 ── + + @staticmethod + def _format_seconds(seconds: int) -> str: + """格式化秒数为可读文本""" + if seconds <= 0: + return "" + if seconds < 60: + return f"{seconds}秒" + if seconds < 3600: + return f"{seconds // 60}分钟" + if seconds < 86400: + h = seconds // 3600 + m = (seconds % 3600) // 60 + return f"{h}小时{m}分钟" if m else f"{h}小时" + d = seconds // 86400 + return f"{d}天" + + @staticmethod + def _calc_remaining(trigger_str: str, now: datetime) -> str: + """计算剩余时间""" + try: + trigger = datetime.strptime(trigger_str, "%Y-%m-%d %H:%M:%S") + diff = trigger - now + if diff.total_seconds() <= 0: + return "即将触发" + secs = int(diff.total_seconds()) + if secs < 60: + return f"剩余 {secs}秒" + if secs < 3600: + return f"剩余 {secs // 60}分钟" + if secs < 86400: + h = secs // 3600 + m = (secs % 3600) // 60 + return f"剩余 {h}小时{m}分钟" if m else f"剩余 {h}小时" + d = secs // 86400 + return f"剩余 {d}天" + except Exception: + return "" + + # ── 插件入口 ── + + def handle(self, args: str) -> str: + """处理工具调用""" + if not args or not args.strip(): + return self.usage + + parts = args.strip().split(None, 1) + action = parts[0].lower() + rest = parts[1].strip() if len(parts) > 1 else "" + + if action == 'add': + if not rest: + return "用法: add <时间> <描述>\n示例: add 30m 检查代码 / add 14:30 开会 / add r:2h 站会" + # 分离时间和描述 + time_parts = rest.split(None, 1) + if len(time_parts) < 2: + return "请同时提供时间和描述。示例: add 30m 检查代码" + return self._add_task(time_parts[0], time_parts[1]) + + elif action == 'list': + return self._list_tasks() + + elif action in ('delete', 'cancel', 'rm'): + if not rest: + return "用法: delete <任务ID>" + return self._delete_task(rest) + + elif action == 'clear': + return self._clear_tasks() + + else: + return f"未知操作: {action}\n可用操作: add / list / delete / clear" + + def get_mcp_definition(self): + """返回 MCP 工具定义""" + return { + "name": "scheduler", + "description": "定时任务工具，设定定时提醒。到期时 AI 会自动激活并收到提醒。", + "parameters": { + "type": "object", + "properties": { + "action": { + "type": "string", + "enum": ["add", "list", "delete", "clear"], + "description": "操作类型" + }, + "time": { + "type": "string", + "description": "时间: 30m(相对) / 14:30(今日) / 2026-04-28 10:00(绝对) / r:30m(重复)" + }, + "message": { + "type": "string", + "description": "任务描述/提醒内容" + }, + "task_id": { + "type": "integer", + "description": "任务ID (用于 delete)" + } + }, + "required": ["action"] + } + } diff --git a/plugins/snippet_manager.py b/plugins/snippet_manager.py new file mode 100644 index 0000000..53c320b --- /dev/null +++ b/plugins/snippet_manager.py @@ -0,0 +1,449 @@ +""" +代码片段管理器插件 - 保存、搜索、复用常用代码片段 +支持分类、标签、搜索、导出，JSON 持久化存储 +""" + +import json +import os +import time +import hashlib +from datetime import datetime +from typing import List, Optional + + +class Liugin: + """代码片段管理器 - 保存和复用代码片段""" + + def __init__(self): + self.usage = """代码片段管理器 + +操作: + add <名称> -l <语言> -c "代码" [-t 标签1,标签2] [-d 描述] + - 添加代码片段 + list [-l 语言] [-t 标签] - 列出片段（可按语言/标签过滤） + get <名称或ID> - 获取片段详情 + search <关键词> - 搜索片段（名称/描述/代码/标签） + delete <名称或ID> - 删除片段 + edit <名称或ID> -c "新代码" - 更新片段代码 + export [文件] - 导出所有片段 + import <文件> - 导入片段 + tags - 列出所有标签 + stats - 统计信息 + copy <名称或ID> - 复制到剪贴板（如可用） + recent [-n 数量] - 最近添加的片段 + +示例: + snippet_manager add quick_sort -l python -c "def qsort(arr): ..." -t 排序,算法 + snippet_manager list -l python + snippet_manager search 排序 + snippet_manager get quick_sort +""" + self.cli = None + self.snippets_file = "snippets.json" + self.snippets = [] + self._load_snippets() + + def set_cli(self, cli): + self.cli = cli + + def get_tool_info(self): + return { + "name": "snippet_manager", + "description": "代码片段管理器 - 保存、搜索、复用常用代码片段，支持分类和标签", + "keywords": ["代码", "片段", "snippet", "模板", "复用", "保存", "搜索", "代码片段"], + "usage": self.usage + } + + def get_mcp_definition(self): + return { + "name": "snippet_manager", + "description": "代码片段管理器，支持添加、搜索、获取、删除代码片段", + "inputSchema": { + "type": "object", + "properties": { + "operation": { + "type": "string", + "enum": ["add", "list", "get", "search", "delete", + "edit", "export", "import", "tags", "stats", "recent", "copy"], + "description": "操作类型" + }, + "name": {"type": "string", "description": "片段名称或ID"}, + "language": {"type": "string", "description": "编程语言"}, + "code": {"type": "string", "description": "代码内容"}, + "tags": {"type": "string", "description": "标签（逗号分隔）"}, + "description": {"type": "string", "description": "描述"}, + "keyword": {"type": "string", "description": "搜索关键词"}, + "file": {"type": "string", "description": "文件路径"}, + "count": {"type": "integer", "description": "数量"} + }, + "required": ["operation"] + } + } + + def convert_mcp_args(self, arguments): + op = arguments.get("operation", "") + name = arguments.get("name", "") + parts = [op] + if name: + parts.append(name) + if arguments.get("keyword"): + parts.append(arguments["keyword"]) + if arguments.get("file"): + parts.append(arguments["file"]) + if arguments.get("count"): + parts.append(str(arguments["count"])) + if arguments.get("language"): + parts.extend(["-l", arguments["language"]]) + if arguments.get("code"): + parts.extend(["-c", f'"{arguments["code"]}"']) + if arguments.get("tags"): + parts.extend(["-t", arguments["tags"]]) + if arguments.get("description"): + parts.extend(["-d", f'"{arguments["description"]}"']) + return " ".join(parts) + + def _load_snippets(self): + try: + if os.path.exists(self.snippets_file): + with open(self.snippets_file, 'r', encoding='utf-8') as f: + self.snippets = json.load(f) + except Exception: + self.snippets = [] + + def _save_snippets(self): + try: + with open(self.snippets_file, 'w', encoding='utf-8') as f: + json.dump(self.snippets, f, ensure_ascii=False, indent=2) + return None + except Exception as e: + return f"保存失败: {e}" + + def _gen_id(self, name: str) -> str: + return hashlib.md5(f"{name}{time.time()}".encode()).hexdigest()[:8] + + def handle(self, args: str) -> str: + try: + parts = self._parse_args(args) + if not parts: + return self._op_list([]) + + operation = parts[0].lower() + handlers = { + "add": self._op_add, + "list": self._op_list, + "get": self._op_get, + "search": self._op_search, + "delete": self._op_delete, + "edit": self._op_edit, + "export": self._op_export, + "import": self._op_import, + "tags": self._op_tags, + "stats": self._op_stats, + "recent": self._op_recent, + "copy": self._op_copy, + } + + handler = handlers.get(operation) + if not handler: + return f"错误：不支持的操作 '{operation}'" + return handler(parts[1:]) + + except Exception as e: + return f"片段管理错误: {str(e)}" + + def _parse_args(self, args: str) -> List[str]: + parts, current, in_quotes, qc = [], "", False, None + for ch in args: + if ch in ('"', "'") and not in_quotes: + in_quotes, qc = True, ch + elif ch == qc and in_quotes: + in_quotes, qc = False, None + elif ch == ' ' and not in_quotes: + if current: + parts.append(current) + current = "" + else: + current += ch + if current: + parts.append(current) + return parts + + def _op_add(self, args: List[str]) -> str: + if not args: + return "错误：请提供片段名称" + name = args[0] + language, code, tags, desc = "", "", [], "" + + i = 1 + while i < len(args): + if args[i] == "-l" and i + 1 < len(args): + language = args[i + 1]; i += 1 + elif args[i] == "-c" and i + 1 < len(args): + code = args[i + 1]; i += 1 + elif args[i] == "-t" and i + 1 < len(args): + tags = [t.strip() for t in args[i + 1].split(",") if t.strip()]; i += 1 + elif args[i] == "-d" and i + 1 < len(args): + desc = args[i + 1]; i += 1 + i += 1 + + if not code: + return "错误：请用 -c 提供代码内容" + + # 检查重名 + for s in self.snippets: + if s["name"] == name: + return f"错误：片段 '{name}' 已存在，用 edit 更新" + + snippet = { + "id": self._gen_id(name), + "name": name, + "language": language, + "code": code, + "tags": tags, + "description": desc, + "created_at": datetime.now().strftime("%Y-%m-%d %H:%M:%S"), + "usage_count": 0 + } + self.snippets.append(snippet) + err = self._save_snippets() + if err: + return err + return f"✅ 已添加片段 '{name}' (ID: {snippet['id']}, 语言: {language or '未指定'})" + + def _op_list(self, args: List[str]) -> str: + lang_filter, tag_filter = None, None + i = 0 + while i < len(args): + if args[i] == "-l" and i + 1 < len(args): + lang_filter = args[i + 1].lower(); i += 1 + elif args[i] == "-t" and i + 1 < len(args): + tag_filter = args[i + 1].lower(); i += 1 + i += 1 + + filtered = self.snippets + if lang_filter: + filtered = [s for s in filtered if s.get("language", "").lower() == lang_filter] + if tag_filter: + filtered = [s for s in filtered if any(tag_filter in t.lower() for t in s.get("tags", []))] + + if not filtered: + return "📭 没有找到代码片段" + + result = f"\n📝 代码片段列表 (共 {len(filtered)} 个)\n" + result += "─" * 55 + "\n" + for s in filtered: + lang = s.get("language", "未知") + tags = ", ".join(s.get("tags", [])) if s.get("tags") else "" + code_preview = s.get("code", "")[:60].replace("\n", "↵") + result += f" [{s['id']}] {s['name']} ({lang})\n" + if tags: + result += f" ️ {tags}\n" + result += f" {code_preview}...\n" + result += f" ⏱ {s.get('created_at', '未知')}\n\n" + + result += "─" * 55 + return result + + def _op_get(self, args: List[str]) -> str: + if not args: + return "错误：请提供片段名称或ID" + key = args[0] + snippet = self._find_snippet(key) + if not snippet: + return f"❌ 未找到片段: {key}" + + snippet["usage_count"] = snippet.get("usage_count", 0) + 1 + err = self._save_snippets() + + result = f"\n 片段: {snippet['name']}\n" + result += "─" * 50 + "\n" + result += f" ID: {snippet['id']}\n" + result += f" 语言: {snippet.get('language', '未指定')}\n" + if snippet.get("tags"): + result += f" ️ 标签: {', '.join(snippet['tags'])}\n" + if snippet.get("description"): + result += f" 描述: {snippet['description']}\n" + result += f" 创建: {snippet.get('created_at', '未知')}\n" + result += f" 使用: {snippet.get('usage_count', 0)} 次\n" + result += "─" * 50 + "\n" + result += f" 代码:\n{snippet['code']}\n" + result += "─" * 50 + return result + + def _op_search(self, args: List[str]) -> str: + if not args: + return "错误：请提供搜索关键词" + keyword = " ".join(args).lower() + + results = [] + for s in self.snippets: + searchable = f"{s['name']} {s.get('description', '')} {s.get('code', '')} {' '.join(s.get('tags', []))} {s.get('language', '')}".lower() + if keyword in searchable: + results.append(s) + + if not results: + return f" 未找到匹配 '{keyword}' 的片段" + + output = f" 搜索结果 ({len(results)} 个):\n" + output += "─" * 50 + "\n" + for s in results: + lang = s.get("language", "") + output += f" [{s['id']}] {s['name']} ({lang}) - {s.get('description', '')[:40]}\n" + return output.rstrip() + + def _op_delete(self, args: List[str]) -> str: + if not args: + return "错误：请提供片段名称或ID" + key = args[0] + for i, s in enumerate(self.snippets): + if s["name"] == key or s["id"] == key: + removed = self.snippets.pop(i) + err = self._save_snippets() + return f" ️ 已删除片段: {removed['name']}" + (f" (警告: {err})" if err else "") + return f"❌ 未找到片段: {key}" + + def _op_edit(self, args: List[str]) -> str: + if not args: + return "错误：请提供片段名称或ID" + key = args[0] + snippet = self._find_snippet(key) + if not snippet: + return f"❌ 未找到片段: {key}" + + new_code = None + new_desc = None + i = 1 + while i < len(args): + if args[i] == "-c" and i + 1 < len(args): + new_code = args[i + 1]; i += 1 + elif args[i] == "-d" and i + 1 < len(args): + new_desc = args[i + 1]; i += 1 + i += 1 + + if new_code: + snippet["code"] = new_code + if new_desc: + snippet["description"] = new_desc + snippet["updated_at"] = datetime.now().strftime("%Y-%m-%d %H:%M:%S") + + if self._save_snippets(): + return f"✅ 已更新片段: {snippet['name']}" + return f"❌ 更新片段失败: 写入磁盘出错" + + def _op_export(self, args: List[str]) -> str: + output_file = args[0] if args else "snippets_export.json" + try: + with open(output_file, 'w', encoding='utf-8') as f: + json.dump(self.snippets, f, ensure_ascii=False, indent=2) + return f"✅ 已导出 {len(self.snippets)} 个片段到: {output_file}" + except Exception as e: + return f"❌ 导出失败: {e}" + + def _op_import(self, args: List[str]) -> str: + if not args: + return "错误：请提供导入文件路径" + file_path = args[0] + if not os.path.isfile(file_path): + return f"❌ 文件不存在: {file_path}" + try: + with open(file_path, 'r', encoding='utf-8') as f: + imported = json.load(f) + if not isinstance(imported, list): + return "❌ 文件格式错误：需要 JSON 数组" + + existing_names = {s["name"] for s in self.snippets} + added = 0 + for s in imported: + if isinstance(s, dict) and s.get("name") and s["name"] not in existing_names: + s["id"] = self._gen_id(s["name"]) + self.snippets.append(s) + existing_names.add(s["name"]) + added += 1 + + if self._save_snippets(): + return f"✅ 已导入 {added} 个片段 (跳过 {len(imported) - added} 个重复)" + return f"❌ 导入失败: 写入磁盘出错" + except Exception as e: + return f"❌ 导入失败: {e}" + + def _op_tags(self, args: List[str]) -> str: + tag_count = {} + for s in self.snippets: + for t in s.get("tags", []): + tag_count[t] = tag_count.get(t, 0) + 1 + + if not tag_count: + return " ️ 暂无标签" + + result = " ️ 标签列表:\n" + for tag, count in sorted(tag_count.items(), key=lambda x: -x[1]): + result += f" {tag} ({count})\n" + return result.rstrip() + + def _op_stats(self, args: List[str]) -> str: + total = len(self.snippets) + if not total: + return "📊 暂无片段" + + lang_count = {} + total_usage = 0 + for s in self.snippets: + lang = s.get("language", "未知") + lang_count[lang] = lang_count.get(lang, 0) + 1 + total_usage += s.get("usage_count", 0) + + result = f"📊 片段统计\n" + result += "─" * 30 + "\n" + result += f" 总数: {total}\n" + result += f" 总使用: {total_usage} 次\n" + result += f" 语言分布:\n" + for lang, count in sorted(lang_count.items(), key=lambda x: -x[1]): + result += f" {lang}: {count}\n" + return result.rstrip() + + def _op_recent(self, args: List[str]) -> str: + count = 5 + for i, a in enumerate(args): + if a == "-n" and i + 1 < len(args): + count = int(args[i + 1]) + + recent = sorted(self.snippets, key=lambda s: s.get("created_at", ""), reverse=True)[:count] + if not recent: + return "📭 暂无片段" + + result = f"⏰ 最近 {len(recent)} 个片段:\n" + for s in recent: + result += f" [{s['id']}] {s['name']} - {s.get('created_at', '')}\n" + return result.rstrip() + + def _op_copy(self, args: List[str]) -> str: + if not args: + return "错误：请提供片段名称或ID" + snippet = self._find_snippet(args[0]) + if not snippet: + return f"❌ 未找到片段: {args[0]}" + + snippet["usage_count"] = snippet.get("usage_count", 0) + 1 + err = self._save_snippets() + if err: + return err + return f" 代码内容 ({snippet['name']}):\n{snippet['code']}" + + def _find_snippet(self, key: str) -> Optional[dict]: + for s in self.snippets: + if s["name"] == key or s["id"] == key: + return s + return None + + +def test_plugin(): + plugin = Liugin() + print("代码片段管理器测试:") + print(plugin.handle('add hello -l python -c "print(\'Hello, World!\')" -t 示例,入门 -d 最简单的Python程序')) + print(plugin.handle('add fib -l python -c "def fib(n): return n if n < 2 else fib(n-1)+fib(n-2)" -t 算法,递归')) + print(plugin.handle('list')) + print(plugin.handle('search python')) + + +if __name__ == "__main__": + test_plugin() diff --git a/plugins/speech_recognition.py b/plugins/speech_recognition.py new file mode 100644 index 0000000..7dcfc3b --- /dev/null +++ b/plugins/speech_recognition.py @@ -0,0 +1,549 @@ +""" +语音识别插件 - 弹窗录音界面 +AI 触发后弹出独立录音窗口 +""" + +import os +import json +import subprocess +import sys +import time +from typing import Optional, Dict, Any, List + +# 结果保存路径 +RESULT_FILE = os.path.join(os.path.dirname(os.path.abspath(__file__)), "speech_temp", "last_result.txt") +TEMP_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), "speech_temp") + + +class Liugin: + """语音识别插件""" + + def __init__(self): + self.plugin_dir = os.path.dirname(os.path.abspath(__file__)) + self.temp_dir = TEMP_DIR + os.makedirs(self.temp_dir, exist_ok=True) + + self.usage = """语音识别插件使用方法： +speech_recognition <操作> [参数] + +录音识别: +- record - 弹出录音窗口，录音并识别 + +文件识别: +- file <音频文件路径> - 识别音频文件内容 + +其他: +- status - 查看状态 +- result - 获取上次识别结果 + +支持的音频格式: wav, mp3, m4a, flac, ogg +""" + self.cli = None + + def set_cli(self, cli): + self.cli = cli + + def get_tool_info(self): + return { + "name": "speech_recognition", + "description": "语音识别插件，弹出录音窗口进行语音识别，将语音转换为文字", + "keywords": ["语音", "识别", "录音", "转文字", "speech", "voice", "recognition"], + "usage": self.usage + } + + def get_mcp_definition(self): + return { + "name": "speech_recognition", + "description": "语音识别插件，弹出录音窗口进行语音识别", + "inputSchema": { + "type": "object", + "properties": { + "operation": { + "type": "string", + "enum": ["record", "file", "status", "result"], + "description": "操作类型" + }, + "file_path": {"type": "string", "description": "音频文件路径"} + }, + "required": ["operation"] + } + } + + def convert_mcp_args(self, arguments: Dict[str, Any]) -> str: + op = arguments.get("operation", "") + parts = [op] + if op == "file": + parts.append(arguments.get("file_path", "")) + return " ".join(filter(None, parts)) + + def handle(self, args: str) -> str: + try: + parts = self._parse_args(args) + if not parts: + return "错误：请提供操作类型。\n" + self.usage + + operation = parts[0].lower() + + handlers = { + "record": self._op_record, + "file": self._op_file, + "status": self._op_status, + "result": self._op_result, + } + + if operation in handlers: + return handlers[operation](parts[1:]) + else: + return f"错误：未知操作 '{operation}'\n可用操作: " + ", ".join(handlers.keys()) + + except Exception as e: + return f"处理请求失败: {e}" + + def _parse_args(self, args: str) -> List[str]: + parts = [] + current = "" + in_quotes = False + quote_char = None + for char in args: + if char in ('"', "'") and not in_quotes: + in_quotes = True + quote_char = char + elif char == quote_char and in_quotes: + in_quotes = False + quote_char = None + elif char == ' ' and not in_quotes: + if current: + parts.append(current) + current = "" + else: + current += char + if current: + parts.append(current) + return parts + + # ==================== 弹窗录音 ==================== + + def _op_record(self, args: List[str]) -> str: + """弹出录音窗口""" + + # 创建录音窗口脚本 + recorder_script = os.path.join(self.temp_dir, "recorder_gui.py") + + gui_code = f'''import tkinter as tk +from tkinter import messagebox +import os +import sys +import threading +import time + +RESULT_FILE = r"{RESULT_FILE}" +TEMP_DIR = r"{TEMP_DIR}" + +class VoiceRecorder: + def __init__(self): + self.root = tk.Tk() + self.root.title("语音识别录音") + self.root.geometry("450x350") + self.root.resizable(False, False) + + # 居中显示 + self.root.update_idletasks() + x = (self.root.winfo_screenwidth() - 450) // 2 + y = (self.root.winfo_screenheight() - 350) // 2 + self.root.geometry(f"450x350+{{x}}+{{y}}") + + # 录音状态 + self.is_recording = False + self.record_file = None + self.frames = [] + self.start_time = None + self.p = None + self.stream = None + + # 创建界面 + self._create_ui() + + # 检查 pyaudio + self.has_pyaudio = self._check_pyaudio() + if not self.has_pyaudio: + self.status_label.config(text="请安装 pyaudio: pip install pyaudio", fg="red") + + def _check_pyaudio(self): + try: + import pyaudio + return True + except: + return False + + def _create_ui(self): + # 标题 + title_label = tk.Label(self.root, text=" 语音识别录音", font=("Arial", 18, "bold")) + title_label.pack(pady=15) + + # 状态标签 + self.status_label = tk.Label(self.root, text="点击开始录音", font=("Arial", 11)) + self.status_label.pack(pady=5) + + # 时间标签 + self.time_label = tk.Label(self.root, text="00:00", font=("Arial", 28, "bold"), fg="#2196F3") + self.time_label.pack(pady=10) + + # 按钮框架 + btn_frame = tk.Frame(self.root) + btn_frame.pack(pady=15) + + # 开始/停止按钮 + self.record_btn = tk.Button( + btn_frame, text=" 开始录音", font=("Arial", 12), + width=12, height=2, command=self.toggle_record, + bg="#4CAF50", fg="white", cursor="hand2" + ) + self.record_btn.pack(side=tk.LEFT, padx=10) + + # 识别按钮 + self.recognize_btn = tk.Button( + btn_frame, text=" 识别", font=("Arial", 12), + width=12, height=2, command=self.recognize, + bg="#2196F3", fg="white", cursor="hand2", state=tk.DISABLED + ) + self.recognize_btn.pack(side=tk.LEFT, padx=10) + + # 结果显示 + result_frame = tk.LabelFrame(self.root, text="识别结果", font=("Arial", 10)) + result_frame.pack(pady=10, padx=15, fill=tk.BOTH, expand=True) + + self.result_text = tk.Text(result_frame, height=5, width=50, font=("Arial", 10)) + self.result_text.pack(pady=5, padx=5, fill=tk.BOTH, expand=True) + + def toggle_record(self): + if not self.has_pyaudio: + messagebox.showerror("错误", "请先安装 pyaudio:\npip install pyaudio") + return + + if self.is_recording: + self.stop_record() + else: + self.start_record() + + def start_record(self): + import pyaudio + + self.is_recording = True + self.frames = [] + self.start_time = time.time() + self.record_btn.config(text=" 停止录音", bg="#f44336") + self.status_label.config(text=" 正在录音...", fg="red") + self.recognize_btn.config(state=tk.DISABLED) + + CHUNK = 1024 + FORMAT = pyaudio.paInt16 + CHANNELS = 1 + RATE = 16000 + + self.p = pyaudio.PyAudio() + self.stream = self.p.open( + format=FORMAT, channels=CHANNELS, rate=RATE, + input=True, frames_per_buffer=CHUNK + ) + + # 更新时间 + self._update_time() + + # 录音线程 + def record_loop(): + while self.is_recording: + try: + data = self.stream.read(CHUNK, exception_on_overflow=False) + self.frames.append(data) + except: + break + + self.record_thread = threading.Thread(target=record_loop, daemon=True) + self.record_thread.start() + + def stop_record(self): + self.is_recording = False + self.record_btn.config(text=" 开始录音", bg="#4CAF50") + self.status_label.config(text="录音完成，可以识别", fg="green") + self.recognize_btn.config(state=tk.NORMAL) + + # 停止录音 + if self.stream: + self.stream.stop_stream() + self.stream.close() + if self.p: + self.p.terminate() + + # 保存文件 + import wave + import pyaudio + self.record_file = os.path.join(TEMP_DIR, f"record_{{int(time.time())}}.wav") + wf = wave.open(self.record_file, "wb") + wf.setnchannels(1) + wf.setsampwidth(pyaudio.get_sample_size(pyaudio.paInt16)) + wf.setframerate(16000) + wf.writeframes(b"".join(self.frames)) + wf.close() + + self.result_text.delete(1.0, tk.END) + self.result_text.insert(tk.END, " 录音已保存\n点击 [识别] 按钮进行语音识别") + + def _update_time(self): + if self.is_recording: + elapsed = int(time.time() - self.start_time) + mins = elapsed // 60 + secs = elapsed % 60 + self.time_label.config(text=f"{{mins:02d}}:{{secs:02d}}") + self.root.after(100, self._update_time) + + def recognize(self): + if not self.record_file or not os.path.exists(self.record_file): + messagebox.showerror("错误", "没有录音文件，请先录音") + return + + self.status_label.config(text="正在识别...", fg="blue") + self.result_text.delete(1.0, tk.END) + self.result_text.insert(tk.END, " 识别中，请稍候...") + self.root.update() + + # 尝试识别 + result = self._do_recognize() + + self.result_text.delete(1.0, tk.END) + if result: + self.result_text.insert(tk.END, result) + self.status_label.config(text="识别完成", fg="green") + # 保存结果 + with open(RESULT_FILE, "w", encoding="utf-8") as f: + f.write(result) + else: + self.result_text.insert(tk.END, " 识别失败\n\n请安装识别引擎:\n• pip install openai-whisper\n• pip install SpeechRecognition") + self.status_label.config(text="识别失败", fg="red") + + def _do_recognize(self): + # 尝试 Whisper + try: + import whisper + self.status_label.config(text="使用 Whisper 识别...", fg="blue") + self.root.update() + model = whisper.load_model("base") + result = model.transcribe(self.record_file, language="zh") + text = result.get("text", "").strip() + if text: + return f" {{text}}" + except Exception as e: + print(f"Whisper error: {{e}}") + + # 尝试 SpeechRecognition + try: + import speech_recognition as sr + self.status_label.config(text="使用 Google 识别...", fg="blue") + self.root.update() + r = sr.Recognizer() + with sr.AudioFile(self.record_file) as source: + audio = r.record(source) + text = r.recognize_google(audio, language="zh-CN") + if text: + return f" {{text}}" + except Exception as e: + print(f"SpeechRecognition error: {{e}}") + + return None + + def run(self): + self.root.mainloop() + + # 清理 + if self.is_recording: + self.is_recording = False + if self.stream: + self.stream.close() + if self.p: + self.p.terminate() + +if __name__ == "__main__": + app = VoiceRecorder() + app.run() +''' + + # 写入脚本 + with open(recorder_script, "w", encoding="utf-8") as f: + f.write(gui_code) + + # 启动录音窗口 + try: + subprocess.Popen([sys.executable, recorder_script], + creationflags=subprocess.CREATE_NEW_CONSOLE) + return " 已弹出录音窗口，请在窗口中进行录音和识别\n\n使用方法：\n1. 点击「开始录音」\n2. 对着麦克风说话\n3. 点击「停止录音」\n4. 点击「识别」获取文字结果" + except Exception as e: + return f" 启动录音窗口失败: {e}" + + # ==================== 文件识别 ==================== + + def _op_file(self, args: List[str]) -> str: + """识别音频文件""" + if not args: + return "错误：请提供音频文件路径" + + file_path = args[0] + + if not os.path.exists(file_path): + return f" 文件不存在: {file_path}" + + return self._recognize_file(file_path) + + def _recognize_file(self, file_path: str) -> str: + """识别音频文件内容""" + + # 尝试使用 whisper（本地） + result = self._try_whisper(file_path) + if result: + self._save_result(result) + return result + + # 尝试使用 speech_recognition 库 + result = self._try_speech_recognition(file_path) + if result: + self._save_result(result) + return result + + return " 语音识别失败：未安装识别引擎\n\n安装方法:\n1. Whisper (推荐): pip install openai-whisper\n2. SpeechRecognition: pip install SpeechRecognition\n3. PyAudio (录音): pip install pyaudio" + + def _save_result(self, result: str): + """保存识别结果""" + try: + with open(RESULT_FILE, "w", encoding="utf-8") as f: + f.write(result) + except: + pass + + def _try_whisper(self, file_path: str) -> Optional[str]: + """使用 Whisper 识别""" + try: + import whisper + + print(f"[语音识别] 使用 Whisper 识别中...") + model = whisper.load_model("base") + result = model.transcribe(file_path, language="zh") + + text = result.get("text", "").strip() + if text: + return f" 识别结果:\n{text}" + return None + + except ImportError: + return None + except Exception as e: + print(f"[语音识别] Whisper 错误: {e}") + return None + + def _try_speech_recognition(self, file_path: str) -> Optional[str]: + """使用 SpeechRecognition 库识别""" + wav_file = file_path + try: + import speech_recognition as sr + + print(f"[语音识别] 使用 SpeechRecognition 识别中...") + r = sr.Recognizer() + + # 转换为 wav 格式 + wav_file = self._convert_to_wav(file_path) + + with sr.AudioFile(wav_file) as source: + audio = r.record(source) + + # 尝试 Google 语音识别 + try: + text = r.recognize_google(audio, language="zh-CN") + if text: + return f" 识别结果:\n{text}" + except: + pass + + return None + + except ImportError: + return None + except Exception as e: + print(f"[语音识别] SpeechRecognition 错误: {e}") + return None + finally: + # 清理转换的临时文件 + if wav_file != file_path and os.path.exists(wav_file): + try: + os.remove(wav_file) + except: + pass + + def _convert_to_wav(self, file_path: str) -> str: + """转换音频为 wav 格式""" + if file_path.lower().endswith('.wav'): + return file_path + + try: + wav_file = os.path.join(self.temp_dir, f"convert_{int(time.time())}.wav") + + # 使用 ffmpeg 转换 + subprocess.run([ + 'ffmpeg', '-y', '-i', file_path, + '-acodec', 'pcm_s16le', + '-ar', '16000', + '-ac', '1', + wav_file + ], capture_output=True, check=True) + + return wav_file + + except Exception as e: + print(f"[语音识别] 转换错误: {e}") + return file_path + + # ==================== 其他 ==================== + + def _op_status(self, args: List[str]) -> str: + """查看状态""" + lines = [" 语音识别插件状态"] + + # 检查可用引擎 + engines = [] + + try: + import whisper + engines.append("whisper ") + except: + engines.append("whisper (pip install openai-whisper)") + + try: + import speech_recognition + engines.append("speech_recognition ") + except: + engines.append("speech_recognition (pip install SpeechRecognition)") + + try: + import pyaudio + engines.append("pyaudio (录音支持)") + except: + engines.append("pyaudio (pip install pyaudio)") + + lines.append("\n可用引擎:") + for e in engines: + lines.append(f" - {e}") + + return "\n".join(lines) + + def _op_result(self, args: List[str]) -> str: + """获取上次识别结果""" + if os.path.exists(RESULT_FILE): + try: + with open(RESULT_FILE, "r", encoding="utf-8") as f: + return f.read() + except: + pass + return "暂无识别结果" + + +if __name__ == "__main__": + plugin = Liugin() + print("语音识别插件") + print(f"临时目录: {plugin.temp_dir}") + print("\n" + plugin.usage) diff --git a/plugins/sub_agent.py b/plugins/sub_agent.py new file mode 100644 index 0000000..9ef0d75 --- /dev/null +++ b/plugins/sub_agent.py @@ -0,0 +1,523 @@ +""" +子 Agent 插件 - 多 Agent 协作系统 +主 AI 可以创建子 Agent、下达指令、获取结果 +""" +import os +import json +import uuid +import time +import threading +from datetime import datetime +from typing import Dict, List, Optional + + +class SubAgent: + """单个子 Agent 实例""" + + def __init__(self, agent_id: str, name: str, task: str, system_prompt: str): + self.id = agent_id + self.name = name + self.task = task + self.status = "idle" # idle / running / done / failed + self.system_prompt = system_prompt + self.conversation = [] # 独立对话历史 + self.result = None + self.error = None + self.created_at = datetime.now().strftime("%H:%M:%S") + self.finished_at = None + self.steps = 0 # 已执行步数 + self.max_steps = 50 + self._lock = threading.Lock() + + def to_dict(self): + return { + "id": self.id, + "name": self.name, + "task": self.task, + "status": self.status, + "steps": self.steps, + "created_at": self.created_at, + "finished_at": self.finished_at, + "has_result": self.result is not None, + "has_error": self.error is not None, + } + + +class Liugin: + """子 Agent 系统 - 创建、管理、协作""" + + def __init__(self): + self.usage = """子 Agent 系统 - 多 Agent 协作 + +管理: + spawn <名称> <任务描述> - 创建子 Agent 并分配任务 + spawn <名称> <任务> --system <提示词> - 创建并指定系统提示词 + list - 列出所有子 Agent + status - 查看子 Agent 状态 + result - 获取子 Agent 执行结果 + send <消息> - 向子 Agent 发送消息 + kill - 终止子 Agent + clean - 清理已完成的 Agent + stats - 统计信息 + +消息格式 (AI 调用): + {"action": "use_tool", "tool": "sub_agent", "args": "spawn coder 请帮我重构 main.py"} + {"action": "use_tool", "tool": "sub_agent", "args": "result agent_xxx"} + {"action": "use_tool", "tool": "sub_agent", "args": "send agent_xxx 用户要求加上类型提示"} + +说明: + - 子 Agent 独立运行，有自己的对话历史 + - 子 Agent 可以使用 code_editor、git_tools 等工具 + - 主 AI 可以同时管理多个子 Agent + - 子 Agent 完成后通过 result 获取结果 +""" + self.cli = None + self.agents: Dict[str, SubAgent] = {} + self._lock = threading.Lock() + + def set_cli(self, cli): + self.cli = cli + + def get_tool_info(self): + return { + "name": "sub_agent", + "description": "子 Agent 系统 - 创建子 Agent 执行独立任务，支持并行多任务、结果回收、消息传递", + "keywords": ["agent", "子agent", "并行", "任务", "协程", "多agent", "spawn", "sub"], + "usage": self.usage + } + + def get_mcp_definition(self): + return { + "name": "sub_agent", + "description": "子 Agent 多任务协作系统", + "inputSchema": { + "type": "object", + "properties": { + "operation": {"type": "string", "description": "操作: spawn/list/status/result/send/kill/clean/stats"}, + "name": {"type": "string", "description": "Agent 名称"}, + "task": {"type": "string", "description": "任务描述"}, + "agent_id": {"type": "string", "description": "Agent ID"}, + "message": {"type": "string", "description": "发送的消息"} + }, + "required": ["operation"] + } + } + + def convert_mcp_args(self, arguments): + op = arguments.get("operation", "") + name = arguments.get("name", "") + task = arguments.get("task", "") + return f"{op} {name} {task}".strip() + + # ── 路由 ── + + def handle(self, args: str) -> str: + try: + parts = args.strip().split(maxsplit=1) + if not parts: + return "错误：请提供操作类型" + + op = parts[0].lower() + rest = parts[1] if len(parts) > 1 else "" + + handlers = { + "spawn": self._spawn, + "list": self._list, + "status": self._status, + "result": self._result, + "send": self._send, + "kill": self._kill, + "clean": self._clean, + "stats": self._stats, + } + + handler = handlers.get(op) + if not handler: + return f"错误：不支持的操作 '{op}'" + return handler(rest) + + except Exception as e: + return f"子 Agent 错误: {str(e)}" + + # ── 操作 ── + + def _spawn(self, args: str) -> str: + """创建子 Agent""" + # 解析 --system 参数 + system_prompt = "" + if " --system " in args: + args, system_prompt = args.split(" --system ", 1) + system_prompt = system_prompt.strip() + + parts = args.strip().split(maxsplit=1) + if len(parts) < 2: + return "错误：格式: spawn <名称> <任务描述>" + + name = parts[0].strip() + task = parts[1].strip() + + # 生成 ID + agent_id = f"agent_{name}_{uuid.uuid4().hex[:6]}" + + # 默认系统提示词 + if not system_prompt: + system_prompt = ( + f"你是子 Agent「{name}」，负责执行以下任务：\n" + f"{task}\n\n" + "你可以使用 code_editor、git_tools、cmd_executor、file_manager 等工具。\n" + "完成任务后，用以下格式报告结果：\n" + '{"status": "done", "summary": "简要总结", "details": "详细结果"}\n\n' + "请开始执行任务。" + ) + + agent = SubAgent(agent_id, name, task, system_prompt) + with self._lock: + self.agents[agent_id] = agent + + # 在后台线程执行 + thread = threading.Thread(target=self._run_agent, args=(agent,), daemon=True) + thread.start() + + return (f" 已创建子 Agent\n" + f" ID: {agent_id}\n" + f" 名称: {name}\n" + f" 任务: {task}\n" + f" 状态: running") + + def _run_agent(self, agent: SubAgent): + """在后台执行子 Agent""" + with agent._lock: + agent.status = "running" + + try: + engine = None + if self.cli and hasattr(self.cli, 'current_engine'): + engine = self.cli.current_engine + + if not engine: + with agent._lock: + agent.status = "failed" + agent.error = "无可用的 AI 引擎" + agent.finished_at = datetime.now().strftime("%H:%M:%S") + return + + # 第一轮：让子 Agent 开始执行任务 + current_input = agent.task + max_steps = agent.max_steps + + while agent.steps < max_steps: + with agent._lock: + if agent.status != "running": + break + agent.steps += 1 + + # 调用引擎 + response = engine.generate_response( + current_input, + system_prompt=agent.system_prompt + ) + + if not response: + with agent._lock: + agent.status = "failed" + agent.error = "引擎返回空响应" + break + + # 记录对话 + with agent._lock: + agent.conversation.append({"role": "user", "content": current_input}) + agent.conversation.append({"role": "assistant", "content": response}) + + # 检查是否包含完成信号 + if self._is_task_done(response): + with agent._lock: + agent.status = "done" + agent.result = response + break + + # 检查是否需要工具调用 + tool_result = self._try_execute_tool(response) + if tool_result: + current_input = f"工具执行结果:\n{tool_result}\n\n请继续执行任务。" + else: + with agent._lock: + agent.status = "done" + agent.result = response + break + + with agent._lock: + if agent.status == "running": + agent.status = "done" + agent.result = "任务执行结束。" + agent.finished_at = datetime.now().strftime("%H:%M:%S") + + except Exception as e: + with agent._lock: + agent.status = "failed" + agent.error = str(e) + agent.finished_at = datetime.now().strftime("%H:%M:%S") + + def _is_task_done(self, response: str) -> bool: + """检查响应中是否包含完成信号""" + done_markers = ['"status": "done"', '"status":"done"', + '任务完成', '已完成', '执行完毕'] + return any(m in response for m in done_markers) + + def _try_execute_tool(self, response: str) -> Optional[str]: + """尝试从响应中提取并执行工具调用""" + if not self.cli: + return None + + # 查找 JSON 工具调用 + import re + + # 模式: {"action": "use_tool", "tool": "...", "args": "..."} + patterns = [ + r'\{"action"\s*:\s*"use_tool"\s*,\s*"tool"\s*:\s*"([^"]+)"\s*,\s*"args"\s*:\s*"([^"]*(?:\\.[^"]*)*)"\s*\}', + r'\{"action"\s*:\s*"use_tool"\s*,\s*"tool"\s*:\s*"([^"]+)"\s*,\s*"args"\s*:\s*(\{[^}]+\})\s*\}', + ] + + for pattern in patterns: + match = re.search(pattern, response, re.DOTALL) + if match: + tool_name = match.group(1) + tool_args = match.group(2) + + # 反转义 + tool_args = tool_args.replace('\\"', '"').replace('\\n', '\n') + + # 查找并执行工具 + if hasattr(self.cli, 'liugin_manager'): + for tool in self.cli.liugin_manager.tools: + if tool.get('name') == tool_name: + handler = tool.get('handler') + if handler: + try: + result = handler(tool_args) + return result + except Exception as e: + return f"工具执行错误: {e}" + break + + # 模式2: 多个 JSON 指令 (数组) + array_match = re.search(r'\[\s*\{.*?\}\s*\]', response, re.DOTALL) + if array_match: + try: + commands = json.loads(array_match.group()) + if isinstance(commands, list): + results = [] + for cmd in commands: + if isinstance(cmd, dict) and cmd.get('action') == 'use_tool': + tool_name = cmd.get('tool', '') + tool_args = cmd.get('args', '') + if isinstance(tool_args, dict): + tool_args = json.dumps(tool_args, ensure_ascii=False) + + for tool in self.cli.liugin_manager.tools: + if tool.get('name') == tool_name: + handler = tool.get('handler') + if handler: + try: + r = handler(tool_args) + results.append(f"[{tool_name}] {r}") + except Exception as e: + results.append(f"[{tool_name}] 错误: {e}") + break + if results: + return '\n'.join(results) + except json.JSONDecodeError: + pass + + return None + + def _find_agent(self, agent_id: str): + """线程安全地查找 Agent（精确匹配 + 模糊匹配）""" + with self._lock: + agent = self.agents.get(agent_id) + if not agent: + matches = [a for a in self.agents.values() if agent_id in a.id or agent_id == a.name] + if matches: + agent = matches[0] + return agent + + def _list(self, args: str) -> str: + """列出所有子 Agent""" + with self._lock: + if not self.agents: + return "没有子 Agent" + agents_list = list(self.agents.values()) + + result = [f"子 Agent 列表 ({len(agents_list)} 个):\n"] + + # 按状态分组 + running = [a for a in agents_list if a.status == "running"] + done = [a for a in agents_list if a.status == "done"] + failed = [a for a in agents_list if a.status == "failed"] + + if running: + result.append(f" 运行中 ({len(running)}):") + for a in running: + result.append(f" {a.id} [{a.name}] 步骤:{a.steps} 任务:{a.task[:40]}") + + if done: + result.append(f" 已完成 ({len(done)}):") + for a in done: + result.append(f" {a.id} [{a.name}] 任务:{a.task[:40]}") + + if failed: + result.append(f" 失败 ({len(failed)}):") + for a in failed: + result.append(f" {a.id} [{a.name}] 错误:{a.error[:40] if a.error else '?'}") + + return '\n'.join(result) + + def _status(self, args: str) -> str: + """查看子 Agent 状态""" + agent_id = args.strip() + if not agent_id: + return "错误：请提供 Agent ID" + + agent = self._find_agent(agent_id) + if not agent: + return f"错误：未找到 Agent '{agent_id}'" + + lines = [ + f"Agent: {agent.id}", + f" 名称: {agent.name}", + f" 任务: {agent.task}", + f" 状态: {agent.status}", + f" 步骤: {agent.steps}", + f" 创建: {agent.created_at}", + ] + if agent.finished_at: + lines.append(f" 完成: {agent.finished_at}") + if agent.error: + lines.append(f" 错误: {agent.error}") + lines.append(f" 对话轮次: {len(agent.conversation)}") + + return '\n'.join(lines) + + def _result(self, args: str) -> str: + """获取子 Agent 结果""" + agent_id = args.strip() + if not agent_id: + return "错误：请提供 Agent ID" + + agent = self._find_agent(agent_id) + if not agent: + return f"错误：未找到 Agent '{agent_id}'" + + if agent.status == "running": + return f"Agent {agent.id} 仍在运行中 (步骤 {agent.steps})" + + if agent.status == "failed": + return f"Agent {agent.id} 执行失败: {agent.error}" + + if agent.result: + result = agent.result + return f"Agent {agent.id} 结果:\n{result}" + + return f"Agent {agent.id} 暂无结果" + + def _send(self, args: str) -> str: + """向子 Agent 发送消息""" + parts = args.strip().split(maxsplit=1) + if len(parts) < 2: + return "错误：格式: send <消息>" + + agent_id = parts[0] + message = parts[1] + + agent = self._find_agent(agent_id) + if not agent: + return f"错误：未找到 Agent '{agent_id}'" + + if agent.status != "running": + return f"Agent {agent.id} 未在运行 (状态: {agent.status})" + + # 在后台线程处理消息 + thread = threading.Thread(target=self._process_message, args=(agent, message), daemon=True) + thread.start() + + return f" 消息已发送给 {agent.id}" + + def _process_message(self, agent: SubAgent, message: str, depth: int = 0): + """处理发送给子 Agent 的消息""" + if depth > 10: + return "递归深度超限" + try: + engine = None + if self.cli and hasattr(self.cli, 'current_engine'): + engine = self.cli.current_engine + + if not engine: + return + + with agent._lock: + agent.conversation.append({"role": "user", "content": message}) + agent.steps += 1 + + response = engine.generate_response( + message, + system_prompt=agent.system_prompt + ) + + if response: + with agent._lock: + agent.conversation.append({"role": "assistant", "content": response}) + + if self._is_task_done(response): + with agent._lock: + agent.status = "done" + agent.result = response + agent.finished_at = datetime.now().strftime("%H:%M:%S") + else: + tool_result = self._try_execute_tool(response) + if tool_result: + # 继续执行 + self._process_message(agent, f"工具结果:\n{tool_result}\n请继续。", depth + 1) + + except Exception as e: + with agent._lock: + agent.error = str(e) + agent.status = "failed" + agent.finished_at = datetime.now().strftime("%H:%M:%S") + + def _kill(self, args: str) -> str: + """终止子 Agent""" + agent_id = args.strip() + agent = self._find_agent(agent_id) + if not agent: + return f"错误：未找到 Agent '{agent_id}'" + + with agent._lock: + agent.status = "failed" + agent.error = "被主 Agent 终止" + agent.finished_at = datetime.now().strftime("%H:%M:%S") + return f" 已终止 {agent.id}" + + def _clean(self, args: str) -> str: + """清理已完成的 Agent""" + with self._lock: + to_remove = [aid for aid, a in self.agents.items() + if a.status in ("done", "failed")] + for aid in to_remove: + del self.agents[aid] + + return f" 已清理 {len(to_remove)} 个已完成的 Agent" + + def _stats(self, args: str) -> str: + """统计信息""" + with self._lock: + total = len(self.agents) + running = sum(1 for a in self.agents.values() if a.status == "running") + done = sum(1 for a in self.agents.values() if a.status == "done") + failed = sum(1 for a in self.agents.values() if a.status == "failed") + total_steps = sum(a.steps for a in self.agents.values()) + + return (f" 子 Agent 统计\n" + f" 总数: {total}\n" + f" 运行中: {running}\n" + f" 已完成: {done}\n" + f" 失败: {failed}\n" + f" 总步数: {total_steps}") diff --git a/plugins/task_manager.py b/plugins/task_manager.py new file mode 100644 index 0000000..fe31556 --- /dev/null +++ b/plugins/task_manager.py @@ -0,0 +1,289 @@ +""" +任务管理插件 - 提供任务追踪和进度管理功能 +""" + +import json +import os +from datetime import datetime +from colorama import Fore, Style + + +class Liugin: + """任务管理插件 - 类似 iFlow CLI 的 todo 功能""" + + def __init__(self): + self.usage = """任务管理工具使用方法： + +JSON格式示例： +{"action": "use_tool", "tool": "task_manager", "args": "add 创建登录页面"} - 添加新任务 +{"action": "use_tool", "tool": "task_manager", "args": "list"} - 列出所有任务 +{"action": "use_tool", "tool": "task_manager", "args": "complete 1"} - 完成任务ID为1的任务 +{"action": "use_tool", "tool": "task_manager", "args": "in_progress 2"} - 将任务ID为2标记为进行中 +{"action": "use_tool", "tool": "task_manager", "args": "delete 3"} - 删除任务ID为3的任务 +{"action": "use_tool", "tool": "task_manager", "args": "clear"} - 清除所有已完成的任务 + +功能说明： +- add <任务描述> - 添加新任务（自动分配ID） +- list - 列出所有任务及其状态 +- complete <任务ID> - 标记任务为已完成 +- in_progress <任务ID> - 标记任务为进行中 +- delete <任务ID> - 删除指定任务 +- clear - 清除所有已完成的任务 + +状态说明： +- pending: 待处理 +- in_progress: 进行中 +- completed: 已完成 +- failed: 失败""" + self.cli = None + self.tasks_file = "tasks.json" + self.tasks = [] + self._load_tasks() + + def set_cli(self, cli): + """设置CLI实例引用""" + self.cli = cli + # 注册插件命令 + self.cli.register_liugin_command('task', self.command_handler) + self.cli.register_liugin_command('todo', self.command_handler) + + def command_handler(self, args): + """处理 /task 或 /todo 命令""" + return self.handle(args) + + def get_tool_info(self): + return { + "name": "task_manager", + "description": "任务管理工具，提供任务追踪和进度管理功能，支持添加、完成、删除任务", + "keywords": ["任务", "task", "todo", "管理", "进度", "追踪", "list", "complete"], + "usage": self.usage + } + + def _load_tasks(self): + """从文件加载任务""" + try: + if os.path.exists(self.tasks_file): + with open(self.tasks_file, 'r', encoding='utf-8') as f: + self.tasks = json.load(f) + except Exception as e: + self.tasks = [] + + def _save_tasks(self): + """保存任务到文件""" + try: + with open(self.tasks_file, 'w', encoding='utf-8') as f: + json.dump(self.tasks, f, ensure_ascii=False, indent=2) + except Exception as e: + return f"保存任务失败: {e}" + return None + + def get_mcp_definition(self): + return { + "name": "task_manager", + "description": "任务管理工具，支持添加、完成、删除任务", + "inputSchema": { + "type": "object", + "properties": { + "operation": { + "type": "string", + "enum": ["add", "done", "delete", "list", "clear"], + "description": "操作类型" + }, + "task": { + "type": "string", + "description": "任务内容（add/done/delete 时使用）" + } + }, + "required": ["operation"] + } + } + + def convert_mcp_args(self, arguments): + op = arguments.get("operation", "") + task = arguments.get("task", "") + return f"{op} {task}".strip() + + def handle(self, args): + """处理任务管理请求""" + try: + parts = args.strip().split() + if not parts: + return self._list_tasks() + + operation = parts[0].lower() + + if operation == "add": + # 添加任务 + if len(parts) < 2: + return "错误：请提供任务描述。格式: add <任务描述>" + task_desc = " ".join(parts[1:]) + return self._add_task(task_desc) + + elif operation == "list": + # 列出任务 + return self._list_tasks() + + elif operation == "complete": + # 完成任务 + if len(parts) < 2: + return "错误：请提供任务ID。格式: complete <任务ID>" + task_id = parts[1] + return self._update_task_status(task_id, "completed") + + elif operation == "in_progress": + # 标记为进行中 + if len(parts) < 2: + return "错误：请提供任务ID。格式: in_progress <任务ID>" + task_id = parts[1] + return self._update_task_status(task_id, "in_progress") + + elif operation == "delete": + # 删除任务 + if len(parts) < 2: + return "错误：请提供任务ID。格式: delete <任务ID>" + task_id = parts[1] + return self._delete_task(task_id) + + elif operation == "clear": + # 清除已完成任务 + return self._clear_completed() + + else: + return f"错误：不支持的操作 '{operation}'。支持的操作有: add, list, complete, in_progress, delete, clear" + + except Exception as e: + return f"任务管理操作错误: {str(e)}" + + def _add_task(self, description): + """添加新任务""" + # 使用最大ID+1的方式分配ID，避免删除后ID重复 + existing_ids = [int(t.get("id", 0)) for t in self.tasks if t.get("id", "").isdigit()] + task_id = str(max(existing_ids, default=0) + 1) + new_task = { + "id": task_id, + "task": description, + "status": "pending", + "created_at": datetime.now().strftime("%Y-%m-%d %H:%M:%S"), + "priority": "medium" + } + self.tasks.append(new_task) + error = self._save_tasks() + if error: + return error + return f" 已添加任务 #{task_id}: {description}" + + def _list_tasks(self): + """列出所有任务""" + if not self.tasks: + return " 当前没有任务" + + result = f"\n 任务列表 (共 {len(self.tasks)} 个任务)\n" + result += "=" * 50 + "\n" + + pending_count = 0 + in_progress_count = 0 + completed_count = 0 + + for task in self.tasks: + status = task.get('status', 'pending') + task_id = task.get('id', '?') + description = task.get('task', '') + created_at = task.get('created_at', '') + + # 统计 + if status == 'pending': + pending_count += 1 + status_icon = "" + status_color = Fore.YELLOW + elif status == 'in_progress': + in_progress_count += 1 + status_icon = "" + status_color = Fore.CYAN + elif status == 'completed': + completed_count += 1 + status_icon = "" + status_color = Fore.GREEN + else: + status_icon = "" + status_color = Fore.RED + + result += f"{status_icon} [{task_id}] {status_color}{status}{Style.RESET_ALL} - {description}\n" + result += f" 创建时间: {created_at}\n\n" + + result += "=" * 50 + "\n" + result += f" 统计: {Fore.YELLOW}待处理 {pending_count}{Style.RESET_ALL} | {Fore.CYAN}进行中 {in_progress_count}{Style.RESET_ALL} | {Fore.GREEN}已完成 {completed_count}{Style.RESET_ALL}\n" + + return result + + def _update_task_status(self, task_id, new_status): + """更新任务状态""" + for task in self.tasks: + if task.get('id') == task_id: + old_status = task.get('status') + task['status'] = new_status + if new_status == 'completed': + task['completed_at'] = datetime.now().strftime("%Y-%m-%d %H:%M:%S") + error = self._save_tasks() + if error: + return error + return f" 任务 #{task_id} 状态已更新: {old_status} → {new_status}" + + return f" 未找到任务ID: {task_id}" + + def _delete_task(self, task_id): + """删除任务""" + for i, task in enumerate(self.tasks): + if task.get('id') == task_id: + deleted_task = self.tasks.pop(i) + error = self._save_tasks() + if error: + return error + return f" 已删除任务 #{task_id}: {deleted_task.get('task', '')}" + + return f" 未找到任务ID: {task_id}" + + def _clear_completed(self): + """清除所有已完成的任务""" + completed_count = len([t for t in self.tasks if t.get('status') == 'completed']) + if completed_count == 0: + return " 没有已完成的任务需要清除" + + self.tasks = [t for t in self.tasks if t.get('status') != 'completed'] + error = self._save_tasks() + if error: + return error + return f" 已清除 {completed_count} 个已完成的任务" + + +# 测试函数 +def test_plugin(): + """测试插件功能""" + plugin = Liugin() + print("任务管理插件测试:") + + print("\n1. 添加任务:") + print(plugin.handle("add 创建登录页面")) + print(plugin.handle("add 实现用户认证")) + print(plugin.handle("add 添加数据库连接")) + + print("\n2. 列出任务:") + print(plugin.handle("list")) + + print("\n3. 标记任务为进行中:") + print(plugin.handle("in_progress 1")) + + print("\n4. 完成任务:") + print(plugin.handle("complete 1")) + + print("\n5. 再次列出任务:") + print(plugin.handle("list")) + + print("\n6. 清除已完成任务:") + print(plugin.handle("clear")) + + print("\n7. 最终任务列表:") + print(plugin.handle("list")) + + +if __name__ == "__main__": + test_plugin() \ No newline at end of file diff --git a/plugins/terminal.py b/plugins/terminal.py new file mode 100644 index 0000000..828eed9 --- /dev/null +++ b/plugins/terminal.py @@ -0,0 +1,411 @@ +""" +终端模拟器 v2 — AI 的虚拟键盘和屏幕 +===================================== +设计理念：AI 面前有一个终端，它能做的事就是： + 1. 打字（type） + 2. 按键（key） + 3. 看屏幕（read） +就这么简单。 +""" +import os +import re +import sys +import time +import uuid +import json +import threading +import subprocess +import platform +from collections import deque + +_IS_WIN = platform.system() == "Windows" + + +class Terminal: + """一个终端 = 一个子进程 + 一个屏幕缓冲""" + + def __init__(self, sid: str, shell: str = "", cwd: str = ""): + self.id = sid + self.shell = shell or self._default_shell() + self.cwd = cwd or os.getcwd() + self._proc = None + self._screen = deque(maxlen=5000) # 屏幕行 + self._raw = "" # 未处理原始输出 + self._lock = threading.Lock() + self._start() + + @staticmethod + def _default_shell(): + if _IS_WIN: + return os.environ.get("COMSPEC", "cmd.exe") + for s in ["/bin/bash", "/bin/sh"]: + if os.path.isfile(s): + return s + return "/bin/sh" + + def _start(self): + env = {**os.environ, "TERM": "dumb", "NO_COLOR": "1", + "PYTHONUNBUFFERED": "1", "PROMPT_COMMAND": ""} + if not _IS_WIN: + base = os.path.basename(self.shell) + if "bash" in base: + env["PS1"] = "" + args = [self.shell, "--norc", "--noprofile"] + elif "python" in base: + args = [self.shell, "-i"] + else: + args = [self.shell] + flags = 0 + else: + args = [self.shell, "/K", "chcp 65001 >nul"] + flags = subprocess.CREATE_NO_WINDOW + + self._proc = subprocess.Popen( + args, stdin=subprocess.PIPE, stdout=subprocess.PIPE, + stderr=subprocess.STDOUT, bufsize=0, cwd=self.cwd, + env=env, creationflags=flags if _IS_WIN else 0, + ) + threading.Thread(target=self._reader, daemon=True).start() + time.sleep(0.3) + + def _reader(self): + fd = self._proc.stdout.fileno() + while self._proc.poll() is None: + try: + chunk = os.read(fd, 4096) + if not chunk: + break + text = chunk.decode("utf-8", errors="replace") + with self._lock: + self._raw += text + for line in text.split("\n"): + self._screen.append(line) + except (OSError, ValueError): + break + + def alive(self): + return self._proc and self._proc.poll() is None + + # ── 核心操作：打字 ── + + def type(self, text: str): + """像人一样打字，每个字符发到 stdin""" + if not self.alive(): + return + try: + self._proc.stdin.write(text.encode("utf-8")) + self._proc.stdin.flush() + except (OSError, BrokenPipeError): + pass + + # ── 核心操作：按键 ── + + _KEYS = { + "enter": "\n", "return": "\n", + "tab": "\t", + "backspace": "\x7f", "bs": "\x7f", + "esc": "\x1b", "escape": "\x1b", + "space": " ", + "delete": "\x1b[3~", "del": "\x1b[3~", + "insert": "\x1b[2~", + "up": "\x1b[A", "down": "\x1b[B", + "right": "\x1b[C", "left": "\x1b[D", + "home": "\x1b[H", "end": "\x1b[F", + "pageup": "\x1b[5~", "pagedown": "\x1b[6~", + "f1": "\x1bOP", "f2": "\x1bOQ", "f3": "\x1bOR", "f4": "\x1bOS", + "f5": "\x1b[15~", "f6": "\x1b[17~", "f7": "\x1b[18~", "f8": "\x1b[19~", + "f9": "\x1b[20~", "f10": "\x1b[21~", "f11": "\x1b[23~", "f12": "\x1b[24~", + } + + # Ctrl+ 字母映射 + _CTRL = {chr(i): chr(i - 64) for i in range(65, 91)} # A-Z → \x01-\x1a + + def key(self, name: str): + """ + 按一个键。 + 支持: enter, tab, esc, up, down, left, right, + ctrl+c, ctrl+d, ctrl+z, ctrl+l, ctrl+a, ctrl+e, + f1-f12, backspace, delete, home, end, space, ... + """ + if not self.alive(): + return + name = name.lower().strip() + + # Ctrl+ 组合 + if name.startswith("ctrl+"): + letter = name[5:] + seq = self._CTRL.get(letter.upper()) + if seq: + self._send_raw(seq) + return + + # 普通按键 + seq = self._KEYS.get(name) + if seq: + self._send_raw(seq) + elif len(name) == 1: + # 单个字符直接发 + self._send_raw(name) + + def combo(self, *keys): + """ + 组合键，如 combo("ctrl", "shift", "t") + 目前主要支持 ctrl+单字母 + """ + parts = [k.lower() for k in keys] + if "ctrl" in parts and len(parts) == 2: + other = [k for k in parts if k != "ctrl"][0] + self.key(f"ctrl+{other}") + elif "alt" in parts: + # Alt+key → ESC + key + other = [k for k in parts if k != "alt"][0] + self._send_raw("\x1b" + other) + elif "shift" in parts: + other = [k for k in parts if k != "shift"][0] + self._send_raw(other.upper() if len(other) == 1 else other) + + def _send_raw(self, data: str): + try: + self._proc.stdin.write(data.encode("utf-8")) + self._proc.stdin.flush() + except (OSError, BrokenPipeError): + pass + + # ── 核心操作：看屏幕 ── + + def read(self, lines: int = 0) -> str: + """读取屏幕当前内容""" + with self._lock: + if lines > 0: + buf = list(self._screen)[-lines:] + else: + buf = list(self._screen) + return self._clean("\n".join(buf)) + + def read_new(self, timeout: float = 1) -> str: + """等待并读取新输出""" + with self._lock: + self._raw = "" + time.sleep(timeout) + with self._lock: + out = self._raw + self._raw = "" + return self._clean(out) + + def wait(self, seconds: float = 1): + """等待，让终端输出完""" + time.sleep(seconds) + + def _clean(self, text: str) -> str: + if not text: + return "" + text = re.sub(r'\x1b\[[0-9;]*[a-zA-Z]', '', text) + text = re.sub(r'\x1b\][^\x07]*\x07', '', text) + text = re.sub(r'[\x00-\x08\x0b\x0c\x0e-\x1f]', '', text) + text = text.replace('\r\n', '\n').replace('\r', '\n') + text = re.sub(r'\n{4,}', '\n\n\n', text) + return text.strip() + + def close(self): + try: + if self._proc and self._proc.poll() is None: + self._send_raw("exit\n") + time.sleep(0.2) + if self._proc.poll() is None: + self._proc.terminate() + try: + self._proc.wait(timeout=3) + except subprocess.TimeoutExpired: + self._proc.kill() + except Exception: + pass + self._proc = None + + +# ═══════════════════════════════════════════════════════════════ +# Liugin 插件 +# ═══════════════════════════════════════════════════════════════ + +class Liugin: + """终端模拟器 v2 — AI 的虚拟键盘和屏幕""" + + def __init__(self): + self.cli = None + self._terminals: dict = {} + self._current = "main" + + def set_cli(self, cli): + self.cli = cli + + def get_tool_info(self): + return { + "name": "terminal", + "description": "终端模拟器 — AI 的虚拟键盘和屏幕。" + "启动终端、打字、按键、看屏幕，像人一样操作。", + "keywords": [ + "终端", "terminal", "shell", "键盘", "按键", "打字", + "屏幕", "交互", "REPL", "cmd", "bash", "python", + ], + "usage": ( + "terminal <操作> [参数]\n\n" + " open [shell] - 打开终端，返回初始画面\n" + " type <文字> - 打字（发送到终端）\n" + " key <按键名> - 按一个键（enter/tab/ctrl+c/方向键...）\n" + " read [行数] - 看屏幕内容\n" + " last [行数] - 看最近N行（默认20，避免上下文爆炸）\n" + " wait [秒] - 等待输出完毕\n" + " switch - 切换终端\n" + " list - 列出所有终端\n" + " close [ID] - 关闭终端\n\n" + "按键: enter tab esc space backspace delete\n" + " up down left right home end\n" + " ctrl+c ctrl+d ctrl+z ctrl+l ctrl+a ctrl+e\n" + " f1-f12\n\n" + "示例:\n" + " terminal open - 打开 bash\n" + " terminal open python3 - 打开 Python\n" + " terminal type ls -la - 打字\n" + " terminal key enter - 按回车\n" + " terminal read - 看屏幕\n" + " terminal key ctrl+c - 中断" + ), + } + + def get_mcp_definition(self): + return { + "name": "terminal", + "description": "终端模拟器 — AI 的虚拟键盘和屏幕", + "inputSchema": { + "type": "object", + "properties": { + "action": { + "type": "string", + "enum": ["open", "type", "key", "read", "last", "wait", + "switch", "list", "close"], + }, + "text": {"type": "string", "description": "要打的字 / shell路径"}, + "key": {"type": "string", "description": "按键名"}, + "last": {"type": "integer", "description": "最近N行"}, + "seconds": {"type": "number", "description": "等待秒数"}, + "session": {"type": "string", "description": "终端 ID"}, + }, + "required": ["action"], + }, + } + + def convert_mcp_args(self, arguments): + a = arguments.get("action", "") + parts = [a] + for k in ["text", "key", "lines", "seconds", "session"]: + v = arguments.get(k) + if v is not None: + parts.append(str(v)) + return " ".join(parts) + + def handle(self, args: str) -> str: + parts = args.strip().split(maxsplit=1) + if not parts: + return self._help() + action = parts[0].lower() + rest = parts[1].strip() if len(parts) > 1 else "" + + # 支持 `read 20` 省写 + if rest.isdigit() and action in ('read', 'last'): + action, rest = 'last', rest + + h = { + "open": self._h_open, "type": self._h_type, + "key": self._h_key, "read": self._h_read, + "last": self._h_last, "wait": self._h_wait, + "switch": self._h_switch, "list": self._h_list, + "close": self._h_close, + }.get(action) + if not h: + return f"不支持 '{action}'\n{self._help()}" + try: + return h(rest) + except Exception as e: + return f"终端错误: {e}" + + def _help(self): + return ( + "terminal open [shell] - 打开终端\n" + "terminal type <文字> - 打字\n" + "terminal key <按键> - 按键\n" + "terminal read [行数] - 看屏幕\n" + "terminal wait [秒] - 等待\n" + "terminal list - 列出终端\n" + "terminal close - 关闭" + ) + + def _get(self, sid: str = "") -> Terminal: + sid = sid or self._current + if sid not in self._terminals: + self._terminals[sid] = Terminal(sid) + return self._terminals[sid] + + def _h_open(self, rest: str) -> str: + sid = f"s{len(self._terminals) + 1}" if self._terminals else "main" + t = Terminal(sid, shell=rest.strip()) + self._terminals[sid] = t + self._current = sid + screen = t.read() + return f"✓ 终端 {sid} 已打开\n{screen}" + + def _h_type(self, rest: str) -> str: + if not rest: + return "请提供要打的字" + t = self._get() + t.type(rest) + t.wait(0.3) + return f"← 打字: {rest}" + + def _h_key(self, rest: str) -> str: + if not rest: + return "请提供按键名" + t = self._get() + t.key(rest) + t.wait(0.3) + return f"← 按键: {rest}" + + def _h_read(self, rest: str) -> str: + t = self._get() + return t.read() or "(屏幕为空)" + + def _h_last(self, rest: str) -> str: + t = self._get() + n = int(rest) if rest.strip().isdigit() else 20 + return t.read(n) or "(屏幕为空)" + + def _h_wait(self, rest: str) -> str: + secs = float(rest) if rest.strip() else 1.0 + t = self._get() + t.wait(secs) + return t.read() + + def _h_switch(self, rest: str) -> str: + sid = rest.strip() + if sid not in self._terminals: + return f"终端 '{sid}' 不存在" + self._current = sid + return f"✓ 切换到 {sid}" + + def _h_list(self, _: str) -> str: + if not self._terminals: + return "无终端" + lines = [] + for sid, t in self._terminals.items(): + cur = " ← 当前" if sid == self._current else "" + dot = "●" if t.alive() else "○" + lines.append(f" {dot} {sid} [{t.shell}]{cur}") + return "\n".join(lines) + + def _h_close(self, rest: str) -> str: + sid = rest.strip() or self._current + if sid not in self._terminals: + return f"终端 '{sid}' 不存在" + self._terminals[sid].close() + del self._terminals[sid] + if self._current == sid: + self._current = next(iter(self._terminals), "main") + return f"✓ 终端 {sid} 已关闭" diff --git a/plugins/tool_search.py b/plugins/tool_search.py new file mode 100644 index 0000000..653cafb --- /dev/null +++ b/plugins/tool_search.py @@ -0,0 +1,121 @@ +""" +工具搜索助手 - 支持按需发现工具 +""" +import json + + +class Liugin: + """工具搜索助手 - 允许 AI 按需搜索和发现可用工具""" + + def __init__(self): + self.usage = """工具搜索使用方法： +tool_search <关键词> - 根据关键词搜索可用工具 + +例如: +- tool_search 文件 - 搜索与文件相关的工具 +- tool_search 网络 - 搜索与网络相关的工具 +- tool_search 图片 - 搜索与图片相关的工具 + +此工具帮助 AI 在需要特定功能时快速找到合适的工具， +而不是预加载所有工具到上下文中。""" + self.cli = None + + def set_cli(self, cli): + """设置 CLI 实例引用""" + self.cli = cli + + def get_tool_info(self): + return { + "name": "tool_search", + "description": "工具搜索助手，支持按需发现和搜索可用工具。当你不确定有哪些工具可用时，可以使用此工具搜索相关功能的工具。", + "keywords": ["搜索", "工具", "发现", "search", "tool", "find", "可用工具", "工具列表"], + "usage": """tool_search 工具使用说明： +JSON格式示例： +{"action": "use_tool", "tool": "tool_search", "args": "文件"} - 搜索与文件相关的工具 +{"action": "use_tool", "tool": "tool_search", "args": "网络"} - 搜索与网络相关的工具 +{"action": "use_tool", "tool": "tool_search", "args": "图片"} - 搜索与图片相关的工具 + +功能说明： +- 支持关键词匹配（工具名称、描述、关键词） +- 返回匹配度最高的前 5 个工具 +- 包含工具的详细使用说明 +- 帮助 AI 快速找到合适的工具而不需要预加载所有工具""" + } + + def get_mcp_definition(self): + return { + "name": "tool_search", + "description": "工具搜索助手，搜索可用工具的用法和信息", + "inputSchema": { + "type": "object", + "properties": { + "query": { + "type": "string", + "description": "搜索关键词或工具名" + } + }, + "required": ["query"] + } + } + + def convert_mcp_args(self, arguments): + return arguments.get("query", "") + + def handle(self, args): + """处理工具搜索请求""" + try: + # 解析参数 + query = args.strip() + + if not query: + return "错误：请提供搜索关键词。格式: tool_search <关键词>" + + # 搜索工具 + if self.cli and hasattr(self.cli, 'liugin_manager'): + matches = self.cli.liugin_manager.search_tools(query, limit=5) + + if not matches: + return f"未找到与 '{query}' 相关的工具。" + + # 格式化搜索结果 + result_lines = [f"找到 {len(matches)} 个与 '{query}' 相关的工具:\n"] + + for i, match in enumerate(matches, 1): + result_lines.append(f"{i}. {match['name']}") + result_lines.append(f" 描述: {match['description']}") + + # 显示协议类型 + protocol = match.get('protocol', 'liugin') + result_lines.append(f" 协议: {protocol}") + + # 关键词 + keywords = match.get('keywords', []) + if keywords: + result_lines.append(f" 关键词: {', '.join(keywords)}") + + # 根据协议类型显示不同的使用说明 + if protocol == 'skill': + # Skill 协议：显示完整指令 + instance = match.get('instance') + if instance: + instructions = getattr(instance, 'instructions', '') + if instructions: + result_lines.append(f" 指令:\n{instructions}") + else: + usage = match.get('usage', '') + if usage: + result_lines.append(f" 用法: {usage}") + else: + # Plugin 协议：显示 usage + if match.get('usage'): + usage = match['usage'] + result_lines.append(f" 用法: {usage}") + + result_lines.append("") + + return "\n".join(result_lines) + else: + return "错误：无法访问工具管理器。" + + except Exception as e: + return f"工具搜索失败: {str(e)}" \ No newline at end of file diff --git a/plugins/workflow.py b/plugins/workflow.py new file mode 100644 index 0000000..9ae1504 --- /dev/null +++ b/plugins/workflow.py @@ -0,0 +1,808 @@ +""" +工作流插件 - YAML 定义的多步骤自动化流程 + +支持: + - 顺序执行多步骤 + - 步骤间变量传递 ({{prev.output}}) + - 条件分支 (on_fail / on_success) + - 错误处理 (continue_on_error) + - 状态持久化 (断点续跑) + - 调用其他插件作为步骤 + +用法: + /workflow run + /workflow list + /workflow status + /workflow resume + /workflow abort +""" + +import json +import os +import re +import time +import uuid +from datetime import datetime +from colorama import Fore, Style + + +# ── YAML 解析（内置轻量实现，不依赖 PyYAML） ── + +def _parse_yaml(text: str) -> dict: + """轻量 YAML 解析器，支持工作流所需的子集""" + import yaml # 延迟导入，失败时回退 + return yaml.safe_load(text) + + +def _parse_yaml_fallback(text: str) -> dict: + """内置回退解析器，仅支持简单结构""" + result = {} + current_key = None + current_list = None + current_dict = None + + for line in text.split('\n'): + stripped = line.strip() + if not stripped or stripped.startswith('#'): + continue + + indent = len(line) - len(line.lstrip()) + + if indent == 0 and ':' in stripped: + key, _, val = stripped.partition(':') + key = key.strip() + val = val.strip() + if val: + result[key] = _yaml_value(val) + else: + result[key] = None + current_key = key + current_list = None + current_dict = None + elif indent > 0 and stripped.startswith('- '): + if current_key: + if not isinstance(result.get(current_key), list): + result[current_key] = [] + item_text = stripped[2:].strip() + if ':' in item_text: + item = {} + k, _, v = item_text.partition(':') + item[k.strip()] = _yaml_value(v.strip()) + current_dict = item + result[current_key].append(item) + else: + result[current_key].append(_yaml_value(item_text)) + elif indent > 0 and ':' in stripped and current_dict is not None: + key, _, val = stripped.partition(':') + current_dict[key.strip()] = _yaml_value(val.strip()) + + return result + + +def _yaml_value(s: str): + """转换单个 YAML 值""" + if not s: + return None + # 去除引号 + if (s.startswith('"') and s.endswith('"')) or (s.startswith("'") and s.endswith("'")): + return s[1:-1] + if s.lower() in ('true', 'yes', 'on'): + return True + if s.lower() in ('false', 'no', 'off'): + return False + if s.lower() in ('null', 'none', '~'): + return None + try: + return int(s) + except ValueError: + pass + try: + return float(s) + except ValueError: + pass + return s + + +def _load_yaml_file(path: str) -> dict: + """加载 YAML 文件""" + with open(path, 'r', encoding='utf-8') as f: + text = f.read() + try: + return _parse_yaml(text) + except ImportError: + return _parse_yaml_fallback(text) + + +# ── 变量替换引擎 ── + +def _resolve_vars(text: str, context: dict) -> str: + """ + 替换 {{key}} 和 {{key.nested}} 形式的变量 + + 支持: + {{var}} → context['var'] + {{step.output}} → context['steps']['step']['output'] + {{step.exit_code}} → context['steps']['step']['exit_code'] + {{env.HOME}} → os.environ['HOME'] + {{args.name}} → context['args']['name'] + """ + def replacer(match): + path = match.group(1).strip() + parts = path.split('.') + + if parts[0] == 'env': + return os.environ.get('.'.join(parts[1:]), '') + + if parts[0] == 'args' and len(parts) > 1: + val = context.get('args', {}) + for p in parts[1:]: + if isinstance(val, dict): + val = val.get(p, '') + else: + return '' + return str(val) + + if parts[0] == 'steps' and len(parts) >= 3: + step_name = parts[1] + attr = parts[2] + step_data = context.get('steps', {}).get(step_name, {}) + val = step_data.get(attr, '') + # 支持 deeper nesting: {{steps.foo.output.field}} + for p in parts[3:]: + if isinstance(val, dict): + val = val.get(p, '') + else: + return '' + return str(val) + + # 顶层变量 + val = context + for p in parts: + if isinstance(val, dict): + val = val.get(p, '') + else: + return '' + return str(val) + + return re.sub(r'\{\{(.+?)\}\}', replacer, text) + + +def _resolve_value(val, context): + """递归解析值中的变量（支持 dict/list/str）""" + if isinstance(val, str): + return _resolve_vars(val, context) + elif isinstance(val, dict): + return {k: _resolve_value(v, context) for k, v in val.items()} + elif isinstance(val, list): + return [_resolve_value(item, context) for item in val] + return val + + +# ── 工作流引擎 ── + +class WorkflowEngine: + """工作流执行引擎""" + + def __init__(self, cli_instance=None): + self.cli = cli_instance + self.workflows_dir = "workflows" + self.state_dir = os.path.join(self.workflows_dir, ".state") + os.makedirs(self.state_dir, exist_ok=True) + + def _out(self, msg): + """统一输出""" + print(msg) + + def run(self, path: str, args: dict = None) -> str: + """执行工作流""" + if not os.path.exists(path): + return f"❌ 工作流文件不存在: {path}" + + try: + wf = _load_yaml_file(path) + except Exception as e: + return f"❌ 解析工作流文件失败: {e}" + + wf_name = wf.get('name', os.path.basename(path).replace('.yaml', '').replace('.yml', '')) + steps = wf.get('steps', []) + if not steps: + return f"❌ 工作流 '{wf_name}' 没有步骤" + + wf_id = f"{wf_name}-{uuid.uuid4().hex[:8]}" + context = { + 'args': args or {}, + 'steps': {}, + 'workflow': { + 'id': wf_id, + 'name': wf_name, + 'path': path, + 'started_at': datetime.now().isoformat(), + } + } + + # 保存初始状态 + self._save_state(wf_id, { + 'workflow': wf_name, + 'path': path, + 'status': 'running', + 'current_step': 0, + 'context': context, + 'started_at': context['workflow']['started_at'], + }) + + self._out(f"\n{Fore.CYAN}🔄 工作流 '{wf_name}' 开始 (ID: {wf_id}){Style.RESET_ALL}") + self._out(f" 共 {len(steps)} 个步骤\n") + + failed = False + for i, step in enumerate(steps): + step_name = step.get('name', f'step_{i+1}') + step_type = step.get('type', 'tool') + condition = step.get('if', None) + continue_on_error = step.get('continue_on_error', False) + + # 检查条件 + if condition: + resolved_condition = _resolve_vars(condition, context) + if not self._eval_condition(resolved_condition): + self._out(f" {Fore.YELLOW}⏭ [{step_name}] 条件不满足，跳过{Style.RESET_ALL}") + context['steps'][step_name] = { + 'output': '', 'exit_code': 0, 'skipped': True + } + continue + + # 解析步骤参数 + resolved_step = _resolve_value(step, context) + + self._out(f" {Fore.CYAN}▶ [{step_name}] {step_type}{Style.RESET_ALL}") + + # 更新状态 + self._save_state(wf_id, { + 'workflow': wf_name, + 'path': path, + 'status': 'running', + 'current_step': i, + 'current_step_name': step_name, + 'context': context, + 'started_at': context['workflow']['started_at'], + }) + + try: + result = self._execute_step(resolved_step, context) + context['steps'][step_name] = result + + if result.get('exit_code', 0) == 0: + output_preview = str(result.get('output', ''))[:100] + self._out(f" {Fore.GREEN}✓ [{step_name}] 完成{Style.RESET_ALL}" + f"{' → ' + output_preview if output_preview else ''}") + else: + failed = True + self._out(f" {Fore.RED}✗ [{step_name}] 失败 (exit={result.get('exit_code')}){Style.RESET_ALL}") + self._out(f" {result.get('error', result.get('output', ''))[:200]}") + + if not continue_on_error: + # 检查 on_fail 分支 + on_fail = resolved_step.get('on_fail') + if on_fail: + self._out(f" {Fore.YELLOW}→ 执行 on_fail 分支{Style.RESET_ALL}") + self._execute_on_fail(on_fail, context) + break + else: + self._out(f" {Fore.YELLOW}⚠ continue_on_error=true，继续{Style.RESET_ALL}") + + except Exception as e: + failed = True + context['steps'][step_name] = { + 'output': '', 'exit_code': 1, 'error': str(e) + } + self._out(f" {Fore.RED}✗ [{step_name}] 异常: {e}{Style.RESET_ALL}") + if not continue_on_error: + break + + # 完成状态 + status = 'failed' if failed else 'completed' + context['workflow']['finished_at'] = datetime.now().isoformat() + context['workflow']['status'] = status + + self._save_state(wf_id, { + 'workflow': wf_name, + 'path': path, + 'status': status, + 'current_step': len(steps), + 'context': context, + 'started_at': context['workflow']['started_at'], + 'finished_at': context['workflow']['finished_at'], + }) + + icon = '✅' if not failed else '❌' + self._out(f"\n{icon} 工作流 '{wf_name}' {status} (ID: {wf_id})") + return f"{icon} 工作流 '{wf_name}' {status}" + + def resume(self, wf_id: str) -> str: + """从断点恢复执行工作流""" + state = self._load_state(wf_id) + if not state: + return f"❌ 未找到工作流状态: {wf_id}" + + if state.get('status') == 'completed': + return f"ℹ️ 工作流已完成: {wf_id}" + + path = state.get('path', '') + if not os.path.exists(path): + return f"❌ 工作流文件不存在: {path}" + + try: + wf = _load_yaml_file(path) + except Exception as e: + return f"❌ 解析工作流文件失败: {e}" + + steps = wf.get('steps', []) + start_from = state.get('current_step', 0) + context = state.get('context', {}) + + self._out(f"\n{Fore.CYAN}🔄 恢复工作流 '{wf.get('name', wf_id)}' 从步骤 {start_from + 1}{Style.RESET_ALL}") + + failed = False + for i in range(start_from, len(steps)): + step = steps[i] + step_name = step.get('name', f'step_{i+1}') + step_type = step.get('type', 'tool') + continue_on_error = step.get('continue_on_error', False) + + resolved_step = _resolve_value(step, context) + self._out(f" {Fore.CYAN}▶ [{step_name}] {step_type}{Style.RESET_ALL}") + + try: + result = self._execute_step(resolved_step, context) + context['steps'][step_name] = result + + if result.get('exit_code', 0) == 0: + self._out(f" {Fore.GREEN}✓ [{step_name}] 完成{Style.RESET_ALL}") + else: + failed = True + self._out(f" {Fore.RED}✗ [{step_name}] 失败{Style.RESET_ALL}") + if not continue_on_error: + break + except Exception as e: + failed = True + context['steps'][step_name] = {'output': '', 'exit_code': 1, 'error': str(e)} + self._out(f" {Fore.RED}✗ [{step_name}] 异常: {e}{Style.RESET_ALL}") + if not continue_on_error: + break + + status = 'failed' if failed else 'completed' + self._save_state(wf_id, {**state, 'status': status, 'current_step': len(steps)}) + + return f"{'✅' if not failed else '❌'} 工作流 {status}" + + def list_workflows(self) -> str: + """列出所有工作流文件""" + if not os.path.exists(self.workflows_dir): + return "📁 workflows/ 目录不存在" + + files = [f for f in os.listdir(self.workflows_dir) + if f.endswith(('.yaml', '.yml')) and not f.startswith('.')] + + if not files: + return "📁 workflows/ 目录中没有工作流文件" + + result = f"📁 工作流列表 ({len(files)} 个):\n" + for f in sorted(files): + path = os.path.join(self.workflows_dir, f) + try: + wf = _load_yaml_file(path) + name = wf.get('name', f.replace('.yaml', '').replace('.yml', '')) + desc = wf.get('description', '') + steps_count = len(wf.get('steps', [])) + result += f" 📄 {f}\n" + result += f" 名称: {name} 步骤: {steps_count}\n" + if desc: + result += f" 描述: {desc}\n" + except Exception: + result += f" 📄 {f} (解析失败)\n" + return result + + def status(self, wf_id: str) -> str: + """查看工作流状态""" + state = self._load_state(wf_id) + if not state: + return f"❌ 未找到工作流: {wf_id}" + + ctx = state.get('context', {}) + wf_info = ctx.get('workflow', {}) + steps_done = ctx.get('steps', {}) + + lines = [ + f"📋 工作流: {state.get('workflow', '?')}", + f" ID: {wf_id}", + f" 状态: {state.get('status', '?')}", + f" 进度: 步骤 {state.get('current_step', 0)}", + f" 开始: {state.get('started_at', '?')}", + ] + if state.get('finished_at'): + lines.append(f" 结束: {state['finished_at']}") + + if steps_done: + lines.append(f" 已完成步骤:") + for name, data in steps_done.items(): + icon = '✓' if data.get('exit_code', 0) == 0 else ('⏭' if data.get('skipped') else '✗') + lines.append(f" {icon} {name}") + + return '\n'.join(lines) + + def list_states(self) -> str: + """列出所有工作流运行状态""" + if not os.path.exists(self.state_dir): + return "没有工作流运行记录" + + files = [f for f in os.listdir(self.state_dir) if f.endswith('.json')] + if not files: + return "没有工作流运行记录" + + result = f"📋 工作流运行记录 ({len(files)} 个):\n" + for f in sorted(files, reverse=True)[:20]: + wf_id = f.replace('.json', '') + try: + with open(os.path.join(self.state_dir, f), 'r') as fh: + state = json.load(fh) + status_icon = {'running': '🔄', 'completed': '✅', 'failed': '❌'}.get(state.get('status'), '❓') + result += f" {status_icon} {wf_id} — {state.get('workflow', '?')} ({state.get('status', '?')})\n" + except Exception: + result += f" ❓ {wf_id}\n" + return result + + def abort(self, wf_id: str) -> str: + """中止工作流""" + state = self._load_state(wf_id) + if not state: + return f"❌ 未找到工作流: {wf_id}" + + state['status'] = 'aborted' + self._save_state(wf_id, state) + return f"🛑 工作流已中止: {wf_id}" + + # ── 步骤执行 ── + + def _execute_step(self, step: dict, context: dict) -> dict: + """执行单个步骤""" + step_type = step.get('type', 'tool') + + if step_type == 'tool': + return self._exec_tool_step(step, context) + elif step_type == 'shell': + return self._exec_shell_step(step, context) + elif step_type == 'set': + return self._exec_set_step(step, context) + elif step_type == 'echo': + return self._exec_echo_step(step, context) + elif step_type == 'wait': + return self._exec_wait_step(step, context) + elif step_type == 'if': + return self._exec_if_step(step, context) + else: + return {'output': '', 'exit_code': 1, 'error': f'未知步骤类型: {step_type}'} + + def _exec_tool_step(self, step: dict, context: dict) -> dict: + """执行插件工具步骤""" + tool_name = step.get('tool', '') + tool_args = step.get('args', '') + + if not tool_name: + return {'output': '', 'exit_code': 1, 'error': '未指定 tool 名称'} + + if not self.cli: + return {'output': '', 'exit_code': 1, 'error': 'CLI 实例不可用'} + + try: + # 获取工具管理器 + tool_mgr = getattr(self.cli, 'tool_manager', None) or getattr(self.cli, 'liugin_manager', None) + if not tool_mgr: + return {'output': '', 'exit_code': 1, 'error': '工具管理器不可用'} + + # 解析参数 + args_str = str(tool_args) if tool_args else '' + + # 调用工具 + if hasattr(tool_mgr, 'execute'): + result = tool_mgr.execute(tool_name, args_str) + output = result.get('result', '') if isinstance(result, dict) else str(result) + elif hasattr(tool_mgr, 'tools'): + # LiuginManager 兼容 + tool = tool_mgr.get_tool_by_name(tool_name) + if tool and 'handler' in tool: + output = tool['handler'](args_str) + else: + return {'output': '', 'exit_code': 1, 'error': f'未找到工具: {tool_name}'} + else: + return {'output': '', 'exit_code': 1, 'error': '无法调用工具'} + + return {'output': str(output), 'exit_code': 0} + + except Exception as e: + return {'output': '', 'exit_code': 1, 'error': str(e)} + + def _exec_shell_step(self, step: dict, context: dict) -> dict: + """执行 shell 命令步骤""" + import subprocess + + cmd = step.get('command', step.get('cmd', '')) + if not cmd: + return {'output': '', 'exit_code': 1, 'error': '未指定 command'} + + cwd = step.get('cwd', None) + timeout = step.get('timeout', 60) + + try: + result = subprocess.run( + cmd, shell=True, capture_output=True, text=True, + timeout=timeout, cwd=cwd + ) + return { + 'output': result.stdout.strip(), + 'error': result.stderr.strip(), + 'exit_code': result.returncode, + } + except subprocess.TimeoutExpired: + return {'output': '', 'exit_code': 1, 'error': f'命令超时 ({timeout}s)'} + except Exception as e: + return {'output': '', 'exit_code': 1, 'error': str(e)} + + def _exec_set_step(self, step: dict, context: dict) -> dict: + """设置变量步骤""" + variables = step.get('variables', step.get('vars', {})) + for key, val in variables.items(): + context[key] = _resolve_value(val, context) + return {'output': f'设置 {len(variables)} 个变量', 'exit_code': 0} + + def _exec_echo_step(self, step: dict, context: dict) -> dict: + """打印步骤""" + message = step.get('message', step.get('text', '')) + resolved = _resolve_vars(str(message), context) + self._out(f" 💬 {resolved}") + return {'output': resolved, 'exit_code': 0} + + def _exec_wait_step(self, step: dict, context: dict) -> dict: + """等待步骤""" + seconds = step.get('seconds', step.get('time', 1)) + time.sleep(seconds) + return {'output': f'等待 {seconds} 秒', 'exit_code': 0} + + def _exec_if_step(self, step: dict, context: dict) -> dict: + """条件分支步骤""" + condition = step.get('condition', '') + resolved = _resolve_vars(str(condition), context) + + if self._eval_condition(resolved): + then_steps = step.get('then', []) + return self._run_sub_steps(then_steps, context) + else: + else_steps = step.get('else', []) + if else_steps: + return self._run_sub_steps(else_steps, context) + return {'output': '条件不满足，无 else 分支', 'exit_code': 0} + + def _run_sub_steps(self, steps: list, context: dict) -> dict: + """执行子步骤列表""" + outputs = [] + for sub_step in steps: + result = self._execute_step(sub_step, context) + outputs.append(result.get('output', '')) + if result.get('exit_code', 0) != 0: + return result + return {'output': '\n'.join(outputs), 'exit_code': 0} + + def _eval_condition(self, condition: str) -> bool: + """评估条件表达式""" + condition = condition.strip() + if not condition: + return True + + # 简单比较: "value == expected" + for op in ['==', '!=', '>=', '<=', '>', '<']: + if op in condition: + left, _, right = condition.partition(op) + left = left.strip().strip('"').strip("'") + right = right.strip().strip('"').strip("'") + try: + left_n, right_n = float(left), float(right) + if op == '==': return left_n == right_n + if op == '!=': return left_n != right_n + if op == '>=': return left_n >= right_n + if op == '<=': return left_n <= right_n + if op == '>': return left_n > right_n + if op == '<': return left_n < right_n + except ValueError: + if op == '==': return left == right + if op == '!=': return left != right + + # 布尔值 + if condition.lower() in ('true', '1', 'yes'): + return True + if condition.lower() in ('false', '0', 'no', ''): + return False + + # 非空即真 + return bool(condition) + + def _execute_on_fail(self, on_fail, context: dict): + """执行 on_fail 处理""" + if isinstance(on_fail, str): + self._out(f" 💬 {on_fail}") + elif isinstance(on_fail, list): + for step in on_fail: + self._execute_step(step, context) + + # ── 状态持久化 ── + + def _save_state(self, wf_id: str, state: dict): + """保存工作流状态""" + path = os.path.join(self.state_dir, f"{wf_id}.json") + try: + with open(path, 'w', encoding='utf-8') as f: + json.dump(state, f, ensure_ascii=False, indent=2, default=str) + except Exception as e: + self._out(f"{Fore.YELLOW}⚠ 保存状态失败: {e}{Style.RESET_ALL}") + + def _load_state(self, wf_id: str) -> dict: + """加载工作流状态""" + path = os.path.join(self.state_dir, f"{wf_id}.json") + if not os.path.exists(path): + return {} + try: + with open(path, 'r', encoding='utf-8') as f: + return json.load(f) + except Exception: + return {} + + +# ── Liugin 插件接口 ── + +class Liugin: + """工作流插件""" + + def __init__(self): + self.engine = None + self.usage = """工作流工具使用方法： + +JSON格式示例： +{"action": "use_tool", "tool": "workflow", "args": "run deploy.yaml"} - 执行工作流 +{"action": "use_tool", "tool": "workflow", "args": "list"} - 列出工作流文件 +{"action": "use_tool", "tool": "workflow", "args": "states"} - 查看运行记录 +{"action": "use_tool", "tool": "workflow", "args": "status "} - 查看状态 +{"action": "use_tool", "tool": "workflow", "args": "resume "} - 恢复执行 +{"action": "use_tool", "tool": "workflow", "args": "abort "} - 中止工作流 + +工作流 YAML 格式示例： +name: deploy +description: 部署流程 +steps: + - name: lint + type: shell + command: "npm run lint" + - name: test + type: shell + command: "npm test" + continue_on_error: true + - name: build + type: shell + command: "npm run build" + if: "{{test.exit_code}} == 0" + - name: notify + type: echo + message: "构建完成: {{build.output}}" + +支持的步骤类型: + - tool: 调用插件工具 (tool, args) + - shell: 执行系统命令 (command, cwd, timeout) + - echo: 打印消息 (message) + - wait: 等待 (seconds) + - set: 设置变量 (variables) + - if: 条件分支 (condition, then, else) + +变量引用: + {{steps.step_name.output}} - 步骤输出 + {{steps.step_name.exit_code}} - 步骤退出码 + {{env.VAR_NAME}} - 环境变量 + {{args.param}} - 工作流参数""" + + def set_cli(self, cli): + self.cli = cli + self.engine = WorkflowEngine(cli) + cli.register_liugin_command('workflow', self.command_handler) + cli.register_liugin_command('wf', self.command_handler) + + def command_handler(self, args): + return self.handle(args) + + def get_tool_info(self): + return { + "name": "workflow", + "description": "工作流引擎 - YAML 定义的多步骤自动化流程，支持变量传递、条件分支、断点续跑", + "keywords": ["workflow", "工作流", "流程", "自动化", "pipeline", "deploy", "build", "run"], + "usage": self.usage + } + + def get_mcp_definition(self): + return { + "name": "workflow", + "description": "工作流引擎 - 执行、管理 YAML 定义的自动化工作流", + "inputSchema": { + "type": "object", + "properties": { + "operation": { + "type": "string", + "enum": ["run", "list", "states", "status", "resume", "abort"], + "description": "操作类型" + }, + "target": { + "type": "string", + "description": "工作流文件路径(run) 或工作流ID(status/resume/abort)" + }, + "args": { + "type": "object", + "description": "工作流参数 (run 时使用)" + } + }, + "required": ["operation"] + } + } + + def convert_mcp_args(self, arguments): + op = arguments.get("operation", "") + target = arguments.get("target", "") + args = arguments.get("args", "") + if args and isinstance(args, dict): + args_str = ' '.join(f'{k}={v}' for k, v in args.items()) + return f"{op} {target} {args_str}".strip() + return f"{op} {target}".strip() + + def handle(self, args): + try: + args = args.strip() + if not args: + return self.usage + + parts = args.split(None, 2) + action = parts[0].lower() + + if action == 'run': + if len(parts) < 2: + return "❌ 请指定工作流文件: workflow run " + path = parts[1] + # 解析内联参数 + wf_args = {} + if len(parts) > 2: + for part in parts[2].split(): + if '=' in part: + k, v = part.split('=', 1) + wf_args[k] = v + return self.engine.run(path, wf_args) + + elif action == 'list': + return self.engine.list_workflows() + + elif action == 'states': + return self.engine.list_states() + + elif action == 'status': + if len(parts) < 2: + return "❌ 请指定工作流 ID: workflow status " + return self.engine.status(parts[1]) + + elif action == 'resume': + if len(parts) < 2: + return "❌ 请指定工作流 ID: workflow resume " + return self.engine.resume(parts[1]) + + elif action == 'abort': + if len(parts) < 2: + return "❌ 请指定工作流 ID: workflow abort " + return self.engine.abort(parts[1]) + + else: + # 默认当作 run + if os.path.exists(action): + return self.engine.run(action) + return f"❌ 未知操作: {action}\n\n{self.usage}" + + except Exception as e: + return f"❌ 工作流操作错误: {e}" diff --git a/plugins_config.py b/plugins_config.py new file mode 100644 index 0000000..5a2cdbf --- /dev/null +++ b/plugins_config.py @@ -0,0 +1,28 @@ +# 小狸插件配置 - 由启动器自动生成 +ENABLE_AI_SEARCH = True +ENABLE_AUTO_ENGINEER = True +ENABLE_BROWSER_AUTO = True +ENABLE_CMD_EXECUTOR = True +ENABLE_CODE_EDITOR = True +ENABLE_COMPILE_CHECK = True +ENABLE_FILE_MANAGER = True +ENABLE_FRONTEND_TESTER = True +ENABLE_GIT_TOOLS = True +ENABLE_GUI_AUTO = True +ENABLE_ID_GENERATOR = True +ENABLE_IMAGE_READER = True +ENABLE_JSON_TOOLKIT = True +ENABLE_MARKDOWN_TOOL = True +ENABLE_MEMORY_PLUGIN = True +ENABLE_NETWORK_TOOLS = True +ENABLE_REGEX_TESTER = True +ENABLE_SCHEDULER = True +ENABLE_SNIPPET_MANAGER = True +ENABLE_SPEECH_RECOGNITION = True +ENABLE_SUB_AGENT = True +ENABLE_TASK_MANAGER = True +ENABLE_TERMINAL = True +ENABLE_TOOL_SEARCH = True +ENABLE_WORKFLOW = True + +ENABLE_ONEBOT = False diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 0000000..3961759 --- /dev/null +++ b/requirements.txt @@ -0,0 +1,12 @@ +# 小狸 Pro-CLI 依赖 +# 生成于 2026-07-05 00:17 + +PIL +ascii_magic +colorama +cv2 +numpy +ollama +openai +requests +tkinter diff --git a/scheduler_tasks.json b/scheduler_tasks.json new file mode 100644 index 0000000..0637a08 --- /dev/null +++ b/scheduler_tasks.json @@ -0,0 +1 @@ +[] \ No newline at end of file diff --git a/skills/__init__.py b/skills/__init__.py new file mode 100644 index 0000000..a993e0d --- /dev/null +++ b/skills/__init__.py @@ -0,0 +1,28 @@ +""" +Agent Skills 协议实现 +支持两种格式: +1. 标准开源格式: SKILL.md (YAML frontmatter + Markdown) +2. Python 类格式: Skill 子类 (用于需要代码执行的技能) +""" + +from .base import ( + # 基础类 + Skill, + SkillResult, + SkillParameter, + ParameterType, + SkillLoader, + # Markdown 技能 + MarkdownSkill, +) + +__all__ = [ + 'Skill', + 'SkillResult', + 'SkillParameter', + 'ParameterType', + 'SkillLoader', + 'MarkdownSkill', +] + +__version__ = '1.0.0' diff --git a/skills/base.py b/skills/base.py new file mode 100644 index 0000000..285c0e9 --- /dev/null +++ b/skills/base.py @@ -0,0 +1,382 @@ +""" +Agent Skills 协议基类 +支持两种格式: +1. 标准开源格式: SKILL.md (YAML frontmatter + Markdown) +2. Python 类格式: Skill 子类 (用于需要代码执行的技能) +""" + +import os +import re +import json +import threading +import importlib +import inspect +from abc import ABC, abstractmethod +from dataclasses import dataclass, field +from enum import Enum +from typing import Optional, List, Dict, Any, Union + + +class ParameterType(Enum): + """参数类型枚举 - 映射到 JSON Schema""" + STRING = "string" + INTEGER = "integer" + NUMBER = "number" + BOOLEAN = "boolean" + ARRAY = "array" + OBJECT = "object" + + +@dataclass +class SkillParameter: + """技能参数定义""" + name: str + param_type: ParameterType + description: str + required: bool = True + default: Any = None + enum: Optional[List[Any]] = None + + def to_json_schema(self) -> Dict[str, Any]: + """转换为 JSON Schema 格式""" + schema = { + "type": self.param_type.value, + "description": self.description + } + if self.enum: + schema["enum"] = self.enum + return schema + + +@dataclass +class SkillResult: + """技能执行结果""" + success: bool + data: Any = None + message: str = "" + error: Optional[str] = None + metadata: Dict[str, Any] = field(default_factory=dict) + + def __str__(self) -> str: + if self.success: + return self.message or str(self.data) + return f"Error: {self.error}" + + def to_dict(self) -> Dict[str, Any]: + return { + "success": self.success, + "data": self.data, + "message": self.message, + "error": self.error, + "metadata": self.metadata + } + + +class Skill(ABC): + """技能基类 - 用于 Python 实现的技能""" + + def __init__(self): + self.name: str = "" + self.description: str = "" + self.version: str = "1.0.0" + self.author: str = "" + self.tags: List[str] = [] + self._cli = None + + @property + @abstractmethod + def parameters(self) -> List[SkillParameter]: + pass + + @abstractmethod + def execute(self, **kwargs) -> SkillResult: + pass + + def set_cli(self, cli) -> None: + self._cli = cli + + def get_tool_definition(self) -> Dict[str, Any]: + """获取 OpenAI 格式的工具定义""" + properties = {} + required = [] + for param in self.parameters: + properties[param.name] = param.to_json_schema() + if param.required: + required.append(param.name) + return { + "type": "function", + "function": { + "name": self.name, + "description": self.description, + "parameters": { + "type": "object", + "properties": properties, + "required": required + } + } + } + + def get_anthropic_tool_definition(self) -> Dict[str, Any]: + """获取 Anthropic 格式的工具定义""" + properties = {} + required = [] + for param in self.parameters: + properties[param.name] = param.to_json_schema() + if param.required: + required.append(param.name) + return { + "name": self.name, + "description": self.description, + "input_schema": { + "type": "object", + "properties": properties, + "required": required + } + } + + def run(self, **kwargs) -> SkillResult: + """执行技能（带参数验证）""" + error = self._validate_parameters(**kwargs) + if error: + return SkillResult(success=False, error=error) + return self.execute(**kwargs) + + def _validate_parameters(self, **kwargs) -> Optional[str]: + """验证参数""" + for param in self.parameters: + if param.required and param.name not in kwargs: + return f"缺少必需参数: {param.name}" + return None + + +@dataclass +class MarkdownSkill: + """Markdown 格式的技能 (标准 Agent Skills 格式)""" + name: str + description: str + version: str = "1.0.0" + author: str = "" + license: str = "MIT" + tools: List[str] = field(default_factory=list) + instructions: str = "" + file_path: str = "" + scripts_dir: str = "" + parameters: Dict[str, Any] = field(default_factory=dict) # 从 frontmatter 解析 + + def get_tool_definition(self) -> Dict[str, Any]: + """获取 OpenAI 格式的工具定义 - 从元数据动态生成""" + properties = {} + required = [] + + if self.parameters: + # 从 frontmatter 中的 parameters 生成 + for name, schema in self.parameters.items(): + if isinstance(schema, dict): + properties[name] = schema + if schema.get("required", False): + required.append(name) + else: + # 通用定义：operation + args + properties = { + "operation": { + "type": "string", + "description": f"要执行的操作（可用工具: {', '.join(self.tools)}）" if self.tools else "要执行的操作" + }, + "args": { + "type": "string", + "description": "操作参数" + } + } + required = ["operation"] + + return { + "type": "function", + "function": { + "name": self.name, + "description": self.description, + "parameters": { + "type": "object", + "properties": properties, + "required": required + } + } + } + + def get_anthropic_tool_definition(self) -> Dict[str, Any]: + """获取 Anthropic 格式的工具定义""" + tool_def = self.get_tool_definition() + func = tool_def.get("function", {}) + return { + "name": func.get("name", self.name), + "description": func.get("description", self.description), + "input_schema": func.get("parameters", {"type": "object", "properties": {}}) + } + + +class SkillLoader: + """技能加载器 - 支持标准 SKILL.md 和 Python 类两种格式""" + + def __init__(self, skills_dir: str = None): + self.skills_dir = skills_dir + self._skills: Dict[str, Union[Skill, MarkdownSkill]] = {} + self._lock = threading.RLock() + + @property + def skills(self) -> Dict[str, Union[Skill, MarkdownSkill]]: + return self._skills.copy() + + def discover_skills(self, skills_dir: str = None) -> List[Dict[str, str]]: + """发现所有技能""" + search_dir = skills_dir or self.skills_dir + if not search_dir or not os.path.isdir(search_dir): + return [] + + discovered = [] + for item in os.listdir(search_dir): + item_path = os.path.join(search_dir, item) + + # 跳过特殊文件 + if item in ('__init__.py', 'base.py') or item.startswith('_') or item.startswith('.'): + continue + + # SKILL.md 格式 (目录) + skill_md = os.path.join(item_path, "SKILL.md") + if os.path.isdir(item_path) and os.path.isfile(skill_md): + discovered.append({"name": item, "type": "markdown", "path": skill_md}) + + # Python 单文件格式 + elif item.endswith('.py') and os.path.isfile(item_path): + discovered.append({"name": item[:-3], "type": "python", "path": item_path}) + + return discovered + + def parse_skill_md(self, file_path: str) -> Optional[MarkdownSkill]: + """解析 SKILL.md 文件""" + try: + with open(file_path, 'r', encoding='utf-8') as f: + content = f.read() + + # 解析 YAML frontmatter + if not content.startswith('---'): + return None + + end_idx = content.find('---', 3) + if end_idx == -1: + return None + + frontmatter = content[3:end_idx].strip() + instructions = content[end_idx + 3:].strip() + + # 解析 YAML (简化版) + metadata = {} + current_list = None + current_key = None + + for line in frontmatter.split('\n'): + stripped = line.strip() + if not stripped: + continue + + # 列表项 + if stripped.startswith('- '): + if current_key and current_key not in metadata: + metadata[current_key] = [] + if current_key and isinstance(metadata.get(current_key), list): + metadata[current_key].append(stripped[2:]) + continue + + # 键值对 + if ':' in line: + current_key = None + colon_idx = line.index(':') + key = line[:colon_idx].strip() + value = line[colon_idx + 1:].strip() + + if value: + # 处理列表格式 [a, b, c] + if value.startswith('[') and value.endswith(']'): + value = [v.strip() for v in value[1:-1].split(',') if v.strip()] + metadata[key] = value + else: + current_key = key + current_list = [] + + skill_dir = os.path.dirname(file_path) + scripts_dir = os.path.join(skill_dir, "scripts") + + # 解析参数定义 (从 frontmatter 中的 parameters 字段) + parameters = {} + if "parameters" in metadata and isinstance(metadata["parameters"], dict): + parameters = metadata["parameters"] + elif "params" in metadata and isinstance(metadata["params"], dict): + parameters = metadata["params"] + + return MarkdownSkill( + name=metadata.get('name', os.path.basename(skill_dir)), + description=metadata.get('description', ''), + version=metadata.get('version', '1.0.0'), + author=metadata.get('author', ''), + license=metadata.get('license', 'MIT'), + tools=metadata.get('tools', []) if isinstance(metadata.get('tools'), list) else [], + instructions=instructions, + file_path=file_path, + scripts_dir=scripts_dir if os.path.isdir(scripts_dir) else "" + ) + + except Exception as e: + print(f"解析 SKILL.md 失败 ({file_path}): {e}") + return None + + def load_skill(self, skill_info: Dict[str, str]) -> Optional[Union[Skill, MarkdownSkill]]: + """加载单个技能""" + skill_type = skill_info.get('type') + skill_path = skill_info.get('path') + skill_name = skill_info.get('name') + + if skill_type == "markdown": + skill = self.parse_skill_md(skill_path) + if skill: + self._skills[skill.name] = skill + return skill + + elif skill_type == "python": + try: + # 动态导入 Python 模块 + spec = importlib.util.spec_from_file_location(skill_name, skill_path) + module = importlib.util.module_from_spec(spec) + spec.loader.exec_module(module) + + # 查找 Skill 子类 + for name, obj in inspect.getmembers(module, inspect.isclass): + if issubclass(obj, Skill) and obj is not Skill: + skill = obj() + self._skills[skill.name] = skill + return skill + + except Exception as e: + print(f"加载 Python 技能 '{skill_name}' 失败: {e}") + + return None + + def load_all_skills(self, skills_dir: str = None) -> Dict[str, Union[Skill, MarkdownSkill]]: + """加载所有技能""" + discovered = self.discover_skills(skills_dir) + + for skill_info in discovered: + self.load_skill(skill_info) + + return self.skills + + def get_skill(self, name: str) -> Optional[Union[Skill, MarkdownSkill]]: + """获取已加载的技能""" + return self._skills.get(name) + + def get_all_tool_definitions(self, format: str = "openai") -> List[Dict]: + """获取所有技能的工具定义""" + definitions = [] + for skill in self._skills.values(): + if format == "anthropic": + definitions.append(skill.get_anthropic_tool_definition()) + else: + definitions.append(skill.get_tool_definition()) + return definitions \ No newline at end of file diff --git a/skills/code_stats.py b/skills/code_stats.py new file mode 100644 index 0000000..64c8326 --- /dev/null +++ b/skills/code_stats.py @@ -0,0 +1,140 @@ +""" +代码统计 Skill - 统计项目代码行数、文件数等 +""" +import os +from skills.base import Skill, SkillResult, SkillParameter, ParameterType + + +class CodeStatsSkill(Skill): + """代码统计技能 - 统计目录中的代码行数、文件数、注释率等""" + + def __init__(self): + super().__init__() + self.name = "code_stats" + self.description = "统计项目代码量：文件数、代码行、注释行、空行、注释率" + self.version = "1.0.0" + self.author = "mimo" + self.tags = ["代码", "统计", "stats", "lines"] + + @property + def parameters(self): + return [ + SkillParameter( + name="directory", + param_type=ParameterType.STRING, + description="要统计的目录路径", + required=True + ), + SkillParameter( + name="file_pattern", + param_type=ParameterType.STRING, + description="文件匹配模式，如 *.py", + required=False, + default="*.py" + ), + ] + + def execute(self, **kwargs) -> SkillResult: + directory = kwargs.get("directory", ".") + file_pattern = kwargs.get("file_pattern", "*.py") + + if not os.path.isdir(directory): + return SkillResult(success=False, error=f"目录不存在: {directory}") + + # 确定文件扩展名 + if file_pattern.startswith("*."): + ext = file_pattern[1:] + file_filter = lambda f: f.endswith(ext) + else: + file_filter = lambda f: True + + total_files = 0 + total_lines = 0 + total_code = 0 + total_blank = 0 + total_comment = 0 + file_details = [] + + skip_dirs = {'.git', 'node_modules', '__pycache__', '.venv', 'venv', 'env'} + + for root, dirs, files in os.walk(directory): + dirs[:] = [d for d in dirs if d not in skip_dirs and not d.startswith('.')] + + for filename in sorted(files): + if not file_filter(filename): + continue + + filepath = os.path.join(root, filename) + rel_path = os.path.relpath(filepath, directory) + total_files += 1 + + file_lines = 0 + file_code = 0 + file_blank = 0 + file_comment = 0 + + try: + with open(filepath, 'r', encoding='utf-8') as f: + for line in f: + total_lines += 1 + file_lines += 1 + stripped = line.strip() + if not stripped: + total_blank += 1 + file_blank += 1 + elif stripped.startswith('#'): + total_comment += 1 + file_comment += 1 + else: + total_code += 1 + file_code += 1 + except (UnicodeDecodeError, PermissionError): + continue + + file_details.append({ + "file": rel_path, + "lines": file_lines, + "code": file_code, + "comment": file_comment, + "blank": file_blank, + }) + + # 按代码行数排序 + file_details.sort(key=lambda x: x["code"], reverse=True) + + # 构建报告 + comment_rate = (total_comment / max(total_code, 1)) * 100 + + report_lines = [ + f" 代码统计 ({directory})", + f"{'─' * 40}", + f" 文件数: {total_files}", + f" 总行数: {total_lines}", + f" 代码行: {total_code}", + f" 注释行: {total_comment}", + f" 空行: {total_blank}", + f" 注释率: {comment_rate:.1f}%", + ] + + if file_details: + report_lines.append(f"\n 文件明细 (按代码行数排序):") + for fd in file_details[:20]: + report_lines.append( + f" {fd['file']:40} {fd['code']:5} 行代码" + ) + if len(file_details) > 20: + report_lines.append(f" ... 还有 {len(file_details) - 20} 个文件") + + return SkillResult( + success=True, + message='\n'.join(report_lines), + data={ + "total_files": total_files, + "total_lines": total_lines, + "total_code": total_code, + "total_comment": total_comment, + "total_blank": total_blank, + "comment_rate": comment_rate, + "files": file_details + } + ) diff --git a/skills/file-manager/SKILL.md b/skills/file-manager/SKILL.md new file mode 100644 index 0000000..aa5e0ef --- /dev/null +++ b/skills/file-manager/SKILL.md @@ -0,0 +1,305 @@ +--- +name: file-manager +description: File and directory management tool for creating, reading, writing, deleting, moving, copying, and searching files. Use this skill when the user needs to perform file operations, list directories, search by pattern or content, or get file metadata like size and modification time. +license: MIT +version: 1.0.0 +author: Xiaoli Team (based on openakita/openakita) +tools: + - read_file + - write_file + - bash +--- + +# File Manager Skill + +A comprehensive file and directory management toolset for AI agents. + +## Capabilities + +- **Create**: Files and directories +- **Read**: File contents with encoding support +- **Write**: Create or overwrite files +- **Append**: Add content to existing files +- **Delete**: Remove files or directories +- **Move**: Move or rename files and directories +- **Copy**: Duplicate files or directories +- **Search**: Find files by pattern or content +- **List**: Browse directory contents +- **Info**: Get file metadata (size, dates, permissions) + +## Script Usage + +This skill includes a Python script for structured JSON output: + +```bash +python scripts/file_ops.py list [--recursive] [--pattern "*.py"] +python scripts/file_ops.py read [--encoding utf-8] [--lines N] +python scripts/file_ops.py write --content "内容" [--append] +python scripts/file_ops.py copy +python scripts/file_ops.py move +python scripts/file_ops.py delete [--recursive] +python scripts/file_ops.py search --pattern "*.py" [--content "搜索词"] +python scripts/file_ops.py info +``` + +## Direct Shell Commands + +### List Directory Contents + +When asked to show files in a directory: + +```bash +# List current directory +ls -la + +# List specific directory +ls -la /path/to/directory + +# Recursive listing (Unix) +find /path -type f -name "*.py" + +# Windows +dir /s /b C:\path\*.py +``` + +### Read File + +When asked to read a file: + +```bash +# Read entire file +cat filename.txt + +# Read with line numbers +cat -n filename.txt + +# Read first N lines +head -n 50 filename.txt + +# Read last N lines +tail -n 50 filename.txt +``` + +### Write File + +When asked to create or write a file: + +```bash +# Write content to file (overwrites) +echo "content" > filename.txt + +# Write multiple lines +cat > filename.txt << 'EOF' +Line 1 +Line 2 +Line 3 +EOF + +# Windows PowerShell +Set-Content -Path filename.txt -Value "content" +``` + +### Append to File + +When asked to add content to an existing file: + +```bash +# Append to file +echo "new line" >> filename.txt + +# Append multiple lines +cat >> filename.txt << 'EOF' +Additional line 1 +Additional line 2 +EOF +``` + +### Create Directory + +When asked to create a folder: + +```bash +# Create single directory +mkdir directory_name + +# Create nested directories +mkdir -p path/to/nested/directories + +# Windows +mkdir path\to\nested\directories +``` + +### Delete File or Directory + +When asked to delete: + +```bash +# Delete a file +rm filename.txt + +# Delete empty directory +rmdir directory_name + +# Delete directory and contents +rm -rf directory_name + +# Windows +del filename.txt +rmdir /s /q directory_name +``` + + **Warning**: Deletion is permanent. Always confirm before deleting. + +### Copy File or Directory + +When asked to copy: + +```bash +# Copy file +cp source.txt destination.txt + +# Copy directory recursively +cp -r source_dir/ destination_dir/ + +# Windows +copy source.txt destination.txt +xcopy /E /I source_dir destination_dir +``` + +### Move or Rename + +When asked to move or rename: + +```bash +# Move file +mv source.txt /new/location/source.txt + +# Rename file +mv oldname.txt newname.txt + +# Windows +move source.txt destination.txt +ren oldname.txt newname.txt +``` + +### Search Files + +When asked to find files: + +```bash +# Find by name pattern +find /path -name "*.py" +find /path -iname "*.PY" # case-insensitive + +# Find by content (grep) +grep -r "search_term" /path +grep -rl "search_term" /path # filenames only + +# Windows PowerShell +Get-ChildItem -Path C:\path -Filter *.py -Recurse +Select-String -Path C:\path\*.py -Pattern "search_term" +``` + +### Get File Information + +When asked about file details: + +```bash +# File metadata (Unix) +ls -la filename.txt +stat filename.txt + +# File size only +du -h filename.txt + +# Windows +dir filename.txt +``` + +## JSON Output Format + +All operations should return structured results: + +```json +{ + "success": true, + "operation": "list", + "path": "/home/user/project", + "data": { + "files": ["main.py", "config.json", "README.md"], + "directories": ["src", "tests", "docs"], + "total_count": 6 + }, + "timestamp": "2026-03-21T10:30:00Z" +} +``` + +## Safety Rules + +1. **Always validate paths**: Reject paths containing `..` that escape the working directory +2. **Confirm destructive operations**: Ask before delete, move, or overwrite +3. **Handle encoding**: Default to UTF-8, detect and handle other encodings +4. **Large file warning**: Alert for files > 10MB +5. **Binary file detection**: Cannot read binary files as text + +## Protected Directories + +Never allow operations on: +- System directories: `/etc`, `/root`, `C:\Windows`, `C:\Program Files` +- Hidden files starting with `.` (unless explicitly requested) +- Files with sensitive names: `.env`, `credentials`, `secrets` + +## Error Handling + +| Error | Response | +|-------|----------| +| File not found | Suggest similar filenames or check path | +| Permission denied | Explain required permissions | +| Disk full | Warn user and suggest cleanup | +| Invalid path | Show correct path format | + +## Examples + +### Example 1: List Project Files + +User: "Show me the project structure" + +```bash +find . -type f -name "*.py" | head -20 +tree -L 2 -I '__pycache__|*.pyc' +``` + +### Example 2: Search and Replace + +User: "Replace 'old_func' with 'new_func' in all Python files" + +```bash +# Find and preview +grep -r "old_func" --include="*.py" . + +# Replace (with backup) +find . -name "*.py" -exec sed -i.bak 's/old_func/new_func/g' {} \; +``` + +### Example 3: Safe Delete + +User: "Delete the temp folder" + +Before executing: +1. Check if path exists +2. List contents to show what will be deleted +3. Ask for confirmation +4. Execute if confirmed + +## Cross-Platform Notes + +| Operation | Unix | Windows | +|-----------|------|---------| +| List | `ls -la` | `dir` | +| Copy | `cp` | `copy` | +| Move | `mv` | `move` | +| Delete | `rm -rf` | `rmdir /s /q` | +| Find | `find` | `Get-ChildItem` | +| Grep | `grep` | `Select-String` | + +Always detect the OS and use appropriate commands. \ No newline at end of file diff --git a/skills/file-manager/scripts/file_ops.py b/skills/file-manager/scripts/file_ops.py new file mode 100644 index 0000000..8c8c74d --- /dev/null +++ b/skills/file-manager/scripts/file_ops.py @@ -0,0 +1,671 @@ +#!/usr/bin/env python3 +""" +File Operations Script for file-manager skill +Provides file system operations as JSON output +""" + +import os +import sys +import json +import shutil +import argparse +from datetime import datetime +from pathlib import Path +from typing import Optional, Dict, Any, List + + +def json_response(success: bool, operation: str, data: Any = None, error: str = None) -> str: + """Generate JSON response""" + return json.dumps({ + "success": success, + "operation": operation, + "data": data, + "error": error, + "timestamp": datetime.now().isoformat() + }, ensure_ascii=False, indent=2) + + +def list_directory(path: str, recursive: bool = False, pattern: str = None) -> str: + """List directory contents""" + try: + path = os.path.abspath(path) + if not os.path.exists(path): + return json_response(False, "list", error=f"Path not found: {path}") + + if not os.path.isdir(path): + return json_response(False, "list", error=f"Not a directory: {path}") + + files = [] + directories = [] + + if recursive: + for root, dirs, filenames in os.walk(path): + for d in dirs: + rel_path = os.path.relpath(os.path.join(root, d), path) + if pattern is None or Path(d).match(pattern): + directories.append(rel_path) + for f in filenames: + rel_path = os.path.relpath(os.path.join(root, f), path) + if pattern is None or Path(f).match(pattern): + files.append(rel_path) + else: + for item in os.listdir(path): + full_path = os.path.join(path, item) + if os.path.isdir(full_path): + if pattern is None or Path(item).match(pattern): + directories.append(item) + else: + if pattern is None or Path(item).match(pattern): + files.append(item) + + return json_response(True, "list", { + "path": path, + "files": sorted(files), + "directories": sorted(directories), + "file_count": len(files), + "dir_count": len(directories), + "total_count": len(files) + len(directories) + }) + except Exception as e: + return json_response(False, "list", error=str(e)) + + +def read_file(file_path: str, encoding: str = "utf-8", lines: int = None) -> str: + """Read file content""" + try: + file_path = os.path.abspath(file_path) + if not os.path.exists(file_path): + return json_response(False, "read", error=f"File not found: {file_path}") + + if not os.path.isfile(file_path): + return json_response(False, "read", error=f"Not a file: {file_path}") + + file_size = os.path.getsize(file_path) + + with open(file_path, 'r', encoding=encoding) as f: + if lines: + content_lines = [] + for i, line in enumerate(f): + if i >= lines: + break + content_lines.append(line.rstrip('\n\r')) + content = '\n'.join(content_lines) + with open(file_path, 'r', encoding=encoding) as f2: + total_lines = sum(1 for _ in f2) + else: + content = f.read() + total_lines = content.count('\n') + 1 + + return json_response(True, "read", { + "path": file_path, + "content": content, + "size": file_size, + "lines": total_lines, + "displayed_lines": lines if lines else total_lines + }) + except UnicodeDecodeError: + return json_response(False, "read", error="Cannot decode file (binary or wrong encoding)") + except Exception as e: + return json_response(False, "read", error=str(e)) + + +def write_file(file_path: str, content: str, append: bool = False) -> str: + """Write or append to file""" + try: + file_path = os.path.abspath(file_path) + + # Create parent directory if needed + parent = os.path.dirname(file_path) + if parent and not os.path.exists(parent): + os.makedirs(parent, exist_ok=True) + + mode = 'a' if append else 'w' + with open(file_path, mode, encoding='utf-8') as f: + f.write(content) + + return json_response(True, "write" if not append else "append", { + "path": file_path, + "size": len(content.encode('utf-8')), + "appended": append + }) + except Exception as e: + return json_response(False, "write", error=str(e)) + + +def copy_path(source: str, destination: str) -> str: + """Copy file or directory""" + try: + source = os.path.abspath(source) + destination = os.path.abspath(destination) + + if not os.path.exists(source): + return json_response(False, "copy", error=f"Source not found: {source}") + + # Create parent directory for destination + parent = os.path.dirname(destination) + if parent and not os.path.exists(parent): + os.makedirs(parent, exist_ok=True) + + if os.path.isfile(source): + shutil.copy2(source, destination) + else: + shutil.copytree(source, destination, dirs_exist_ok=True) + + return json_response(True, "copy", { + "source": source, + "destination": destination, + "type": "file" if os.path.isfile(source) else "directory" + }) + except Exception as e: + return json_response(False, "copy", error=str(e)) + + +def move_path(source: str, destination: str) -> str: + """Move or rename file or directory""" + try: + source = os.path.abspath(source) + destination = os.path.abspath(destination) + + if not os.path.exists(source): + return json_response(False, "move", error=f"Source not found: {source}") + + # Create parent directory for destination + parent = os.path.dirname(destination) + if parent and not os.path.exists(parent): + os.makedirs(parent, exist_ok=True) + + shutil.move(source, destination) + + return json_response(True, "move", { + "source": source, + "destination": destination + }) + except Exception as e: + return json_response(False, "move", error=str(e)) + + +def delete_path(path: str, recursive: bool = False) -> str: + """Delete file or directory""" + try: + path = os.path.abspath(path) + + if not os.path.exists(path): + return json_response(False, "delete", error=f"Path not found: {path}") + + if os.path.isfile(path): + os.remove(path) + item_type = "file" + elif os.path.isdir(path): + if recursive: + shutil.rmtree(path) + else: + os.rmdir(path) # Only works for empty directories + item_type = "directory" + + return json_response(True, "delete", { + "path": path, + "type": item_type + }) + except OSError as e: + if "not empty" in str(e).lower(): + return json_response(False, "delete", error="Directory not empty. Use --recursive to delete.") + return json_response(False, "delete", error=str(e)) + except Exception as e: + return json_response(False, "delete", error=str(e)) + + +def search_files(directory: str, pattern: str = None, content: str = None) -> str: + """Search files by name pattern or content""" + try: + directory = os.path.abspath(directory) + if not os.path.exists(directory): + return json_response(False, "search", error=f"Directory not found: {directory}") + + results = [] + + for root, dirs, files in os.walk(directory): + for filename in files: + file_path = os.path.join(root, filename) + rel_path = os.path.relpath(file_path, directory) + + # Pattern match + if pattern and not Path(filename).match(pattern): + continue + + # Content search + if content: + try: + with open(file_path, 'r', encoding='utf-8') as f: + file_content = f.read() + if content not in file_content: + continue + # Find matching lines + matches = [] + for i, line in enumerate(file_content.split('\n'), 1): + if content in line: + matches.append({"line": i, "text": line.strip()[:100]}) + if matches: + results.append({ + "path": rel_path, + "matches": matches[:5] # Limit matches per file + }) + except (UnicodeDecodeError, IOError): + continue + else: + results.append({"path": rel_path}) + + return json_response(True, "search", { + "directory": directory, + "pattern": pattern, + "content_search": content, + "results": results[:100], # Limit results + "total": len(results) + }) + except Exception as e: + return json_response(False, "search", error=str(e)) + + +def get_info(path: str) -> str: + """Get file/directory information""" + try: + path = os.path.abspath(path) + if not os.path.exists(path): + return json_response(False, "info", error=f"Path not found: {path}") + + stat_info = os.stat(path) + + info = { + "path": path, + "name": os.path.basename(path), + "type": "directory" if os.path.isdir(path) else "file", + "size": stat_info.st_size, + "created": datetime.fromtimestamp(stat_info.st_ctime).isoformat(), + "modified": datetime.fromtimestamp(stat_info.st_mtime).isoformat(), + "accessed": datetime.fromtimestamp(stat_info.st_atime).isoformat(), + "permissions": oct(stat_info.st_mode)[-3:] + } + + if os.path.isfile(path): + info["extension"] = os.path.splitext(path)[1] + # Try to detect if text file + try: + with open(path, 'r', encoding='utf-8') as f: + f.read(1024) + info["encoding"] = "utf-8" + except UnicodeDecodeError: + info["encoding"] = "binary" + + return json_response(True, "info", info) + except Exception as e: + return json_response(False, "info", error=str(e)) + + +def modify_line(file_path: str, line_number: int, new_content: str) -> str: + """Modify a specific line in a file""" + try: + file_path = os.path.abspath(file_path) + + if not os.path.exists(file_path): + return json_response(False, "modify_line", error=f"File not found: {file_path}") + + if not os.path.isfile(file_path): + return json_response(False, "modify_line", error=f"Not a file: {file_path}") + + if line_number < 1: + return json_response(False, "modify_line", error="Line number must be >= 1") + + # Read all lines + with open(file_path, 'r', encoding='utf-8') as f: + lines = f.readlines() + + total_lines = len(lines) + + if line_number > total_lines: + return json_response(False, "modify_line", + error=f"File has only {total_lines} lines, cannot modify line {line_number}") + + # Get old content for reporting + old_content = lines[line_number - 1].rstrip('\n\r') + + # Modify the line (preserve newline if existed) + has_newline = lines[line_number - 1].endswith('\n') + lines[line_number - 1] = new_content + ('\n' if has_newline else '') + + # Write back + with open(file_path, 'w', encoding='utf-8') as f: + f.writelines(lines) + + return json_response(True, "modify_line", { + "path": file_path, + "line_number": line_number, + "old_content": old_content, + "new_content": new_content, + "total_lines": total_lines + }) + except UnicodeDecodeError: + return json_response(False, "modify_line", error="Cannot modify binary file") + except Exception as e: + return json_response(False, "modify_line", error=str(e)) + + +def insert_line(file_path: str, line_number: int, content: str) -> str: + """Insert a new line at specified position""" + try: + file_path = os.path.abspath(file_path) + + if not os.path.exists(file_path): + return json_response(False, "insert_line", error=f"File not found: {file_path}") + + if not os.path.isfile(file_path): + return json_response(False, "insert_line", error=f"Not a file: {file_path}") + + if line_number < 1: + return json_response(False, "insert_line", error="Line number must be >= 1") + + # Read all lines + with open(file_path, 'r', encoding='utf-8') as f: + lines = f.readlines() + + total_lines = len(lines) + + # Insert at position (can be after last line) + insert_pos = min(line_number - 1, total_lines) + lines.insert(insert_pos, content + '\n') + + # Write back + with open(file_path, 'w', encoding='utf-8') as f: + f.writelines(lines) + + return json_response(True, "insert_line", { + "path": file_path, + "line_number": line_number, + "inserted_content": content, + "total_lines": len(lines) + }) + except Exception as e: + return json_response(False, "insert_line", error=str(e)) + + +def delete_line(file_path: str, line_number: int) -> str: + """Delete a specific line from a file""" + try: + file_path = os.path.abspath(file_path) + + if not os.path.exists(file_path): + return json_response(False, "delete_line", error=f"File not found: {file_path}") + + if not os.path.isfile(file_path): + return json_response(False, "delete_line", error=f"Not a file: {file_path}") + + if line_number < 1: + return json_response(False, "delete_line", error="Line number must be >= 1") + + # Read all lines + with open(file_path, 'r', encoding='utf-8') as f: + lines = f.readlines() + + total_lines = len(lines) + + if line_number > total_lines: + return json_response(False, "delete_line", + error=f"File has only {total_lines} lines, cannot delete line {line_number}") + + # Get deleted content + deleted_content = lines[line_number - 1].rstrip('\n\r') + + # Remove the line + del lines[line_number - 1] + + # Write back + with open(file_path, 'w', encoding='utf-8') as f: + f.writelines(lines) + + return json_response(True, "delete_line", { + "path": file_path, + "line_number": line_number, + "deleted_content": deleted_content, + "total_lines": len(lines) + }) + except Exception as e: + return json_response(False, "delete_line", error=str(e)) + + +def modify_lines(file_path: str, modifications: Dict[int, str]) -> str: + """ + Modify multiple lines at once + + Args: + file_path: Path to the file + modifications: Dict mapping line numbers (1-based) to new content + Example: {2: "new line 2", 5: "new line 5"} + """ + try: + file_path = os.path.abspath(file_path) + + if not os.path.exists(file_path): + return json_response(False, "modify_lines", error=f"File not found: {file_path}") + + if not os.path.isfile(file_path): + return json_response(False, "modify_lines", error=f"Not a file: {file_path}") + + # Read all lines + with open(file_path, 'r', encoding='utf-8') as f: + lines = f.readlines() + + total_lines = len(lines) + results = [] + + # Sort modifications by line number (descending to avoid index shift issues) + for line_number in sorted(modifications.keys()): + if line_number < 1: + results.append({"line": line_number, "success": False, "error": "Line number must be >= 1"}) + continue + + if line_number > total_lines: + results.append({"line": line_number, "success": False, + "error": f"File has only {total_lines} lines"}) + continue + + # Get old content + old_content = lines[line_number - 1].rstrip('\n\r') + new_content = modifications[line_number] + + # Modify the line + has_newline = lines[line_number - 1].endswith('\n') + lines[line_number - 1] = new_content + ('\n' if has_newline else '') + + results.append({ + "line": line_number, + "success": True, + "old_content": old_content, + "new_content": new_content + }) + + # Write back + with open(file_path, 'w', encoding='utf-8') as f: + f.writelines(lines) + + return json_response(True, "modify_lines", { + "path": file_path, + "total_lines": total_lines, + "modifications_count": len(modifications), + "results": results + }) + except Exception as e: + return json_response(False, "modify_lines", error=str(e)) + + +def replace_text(file_path: str, old_text: str, new_text: str, start_line: int = None, end_line: int = None) -> str: + """ + Replace all occurrences of text in a file (optionally within a line range) + + Args: + file_path: Path to the file + old_text: Text to find and replace + new_text: Replacement text + start_line: Optional start line (1-based, inclusive) + end_line: Optional end line (1-based, inclusive) + """ + try: + file_path = os.path.abspath(file_path) + + if not os.path.exists(file_path): + return json_response(False, "replace_text", error=f"File not found: {file_path}") + + if not os.path.isfile(file_path): + return json_response(False, "replace_text", error=f"Not a file: {file_path}") + + # Read all lines + with open(file_path, 'r', encoding='utf-8') as f: + lines = f.readlines() + + total_lines = len(lines) + replacements = [] + + # Determine range + start = max(0, (start_line or 1) - 1) + end = min(total_lines, end_line or total_lines) + + for i in range(start, end): + line = lines[i] + if old_text in line: + count = line.count(old_text) + lines[i] = line.replace(old_text, new_text) + replacements.append({ + "line": i + 1, + "count": count, + "old_line": line.rstrip('\n\r'), + "new_line": lines[i].rstrip('\n\r') + }) + + # Write back + with open(file_path, 'w', encoding='utf-8') as f: + f.writelines(lines) + + return json_response(True, "replace_text", { + "path": file_path, + "old_text": old_text, + "new_text": new_text, + "line_range": [start + 1, end] if start_line or end_line else None, + "total_replacements": sum(r["count"] for r in replacements), + "lines_modified": len(replacements), + "details": replacements + }) + except Exception as e: + return json_response(False, "replace_text", error=str(e)) + + +def main(): + parser = argparse.ArgumentParser(description="File operations for file-manager skill") + subparsers = parser.add_subparsers(dest="operation", help="Operation to perform") + + # List + list_parser = subparsers.add_parser("list", help="List directory contents") + list_parser.add_argument("path", help="Directory path") + list_parser.add_argument("-r", "--recursive", action="store_true", help="Recursive listing") + list_parser.add_argument("-p", "--pattern", help="File pattern (e.g., *.py)") + + # Read + read_parser = subparsers.add_parser("read", help="Read file content") + read_parser.add_argument("path", help="File path") + read_parser.add_argument("-e", "--encoding", default="utf-8", help="File encoding") + read_parser.add_argument("-n", "--lines", type=int, help="Number of lines to read") + + # Write + write_parser = subparsers.add_parser("write", help="Write to file") + write_parser.add_argument("path", help="File path") + write_parser.add_argument("-c", "--content", required=True, help="Content to write") + write_parser.add_argument("-a", "--append", action="store_true", help="Append to file") + + # Copy + copy_parser = subparsers.add_parser("copy", help="Copy file or directory") + copy_parser.add_argument("source", help="Source path") + copy_parser.add_argument("destination", help="Destination path") + + # Move + move_parser = subparsers.add_parser("move", help="Move file or directory") + move_parser.add_argument("source", help="Source path") + move_parser.add_argument("destination", help="Destination path") + + # Delete + delete_parser = subparsers.add_parser("delete", help="Delete file or directory") + delete_parser.add_argument("path", help="Path to delete") + delete_parser.add_argument("-r", "--recursive", action="store_true", help="Recursive delete") + + # Search + search_parser = subparsers.add_parser("search", help="Search files") + search_parser.add_argument("directory", help="Directory to search") + search_parser.add_argument("-p", "--pattern", help="File pattern") + search_parser.add_argument("-c", "--content", help="Content to search for") + + # Info + info_parser = subparsers.add_parser("info", help="Get file info") + info_parser.add_argument("path", help="File or directory path") + + # Modify line + modify_parser = subparsers.add_parser("modify-line", help="Modify a specific line") + modify_parser.add_argument("path", help="File path") + modify_parser.add_argument("line", type=int, help="Line number (1-based)") + modify_parser.add_argument("content", help="New line content") + + # Insert line + insert_parser = subparsers.add_parser("insert-line", help="Insert a new line") + insert_parser.add_argument("path", help="File path") + insert_parser.add_argument("line", type=int, help="Line number to insert at (1-based)") + insert_parser.add_argument("content", help="Line content to insert") + + # Delete line + del_line_parser = subparsers.add_parser("delete-line", help="Delete a specific line") + del_line_parser.add_argument("path", help="File path") + del_line_parser.add_argument("line", type=int, help="Line number to delete (1-based)") + + # Modify multiple lines (JSON format) + multi_parser = subparsers.add_parser("modify-lines", help="Modify multiple lines at once") + multi_parser.add_argument("path", help="File path") + multi_parser.add_argument("-m", "--modifications", required=True, + help='JSON dict of line numbers to content, e.g. \'{"2": "new line 2", "5": "new line 5"}\'') + + # Replace text + replace_parser = subparsers.add_parser("replace", help="Replace text in file") + replace_parser.add_argument("path", help="File path") + replace_parser.add_argument("old", help="Text to find and replace") + replace_parser.add_argument("new", help="Replacement text") + replace_parser.add_argument("--start", type=int, help="Start line (optional)") + replace_parser.add_argument("--end", type=int, help="End line (optional)") + + args = parser.parse_args() + + if args.operation == "list": + print(list_directory(args.path, args.recursive, args.pattern)) + elif args.operation == "read": + print(read_file(args.path, args.encoding, args.lines)) + elif args.operation == "write": + print(write_file(args.path, args.content, args.append)) + elif args.operation == "copy": + print(copy_path(args.source, args.destination)) + elif args.operation == "move": + print(move_path(args.source, args.destination)) + elif args.operation == "delete": + print(delete_path(args.path, args.recursive)) + elif args.operation == "search": + print(search_files(args.directory, args.pattern, args.content)) + elif args.operation == "info": + print(get_info(args.path)) + elif args.operation == "modify-line": + print(modify_line(args.path, args.line, args.content)) + elif args.operation == "insert-line": + print(insert_line(args.path, args.line, args.content)) + elif args.operation == "delete-line": + print(delete_line(args.path, args.line)) + elif args.operation == "modify-lines": + mods = json.loads(args.modifications) + mods_int = {int(k): v for k, v in mods.items()} + print(modify_lines(args.path, mods_int)) + elif args.operation == "replace": + print(replace_text(args.path, args.old, args.new, args.start, args.end)) + else: + parser.print_help() + + +if __name__ == "__main__": + main() diff --git a/unified_tool_manager.py b/unified_tool_manager.py new file mode 100644 index 0000000..289d7af --- /dev/null +++ b/unified_tool_manager.py @@ -0,0 +1,671 @@ +""" +统一工具管理器 - 协调 Liugin、Skill 和 MCP 三套协议 +自动判断并路由到正确的处理器 +""" + +import os +import json +import logging +import threading +from typing import Dict, List, Any, Optional, Union, Callable +from colorama import Fore, Style +from xcli_core.tool_result import ToolResult, ErrorCode + +logger = logging.getLogger(__name__) + + +class UnifiedToolManager: + """ + 统一工具管理器 + + 协调三种协议: + 1. Liugin 协议 (plugins/) - 小狸自有协议 + 2. Skill 协议 (skills/) - Agent Skills 开源协议 + 3. MCP 协议 - Model Context Protocol (Anthropic/OpenAI 标准) + + 路由策略: + - 优先使用 Skill 协议（如果存在同名技能） + - 回退到 Liugin 协议 + - 支持强制指定协议 + - MCP 格式调用统一入口 + """ + + def __init__(self, cli_instance=None): + self.cli = cli_instance + self._lock = threading.RLock() + + # 两个独立的加载器 + self._liugin_manager = None + self._skill_loader = None + + # 统一的工具注册表 + self._tools: Dict[str, Dict[str, Any]] = {} + + # 协议映射: tool_name -> protocol_type + self._protocol_map: Dict[str, str] = {} + + # MCP 工具定义缓存 + self._mcp_tools_cache: Optional[List[Dict]] = None + + def initialize(self, plugins_dir: str = "plugins", skills_dir: str = "skills") -> None: + """初始化并加载所有工具""" + self._plugins_dir = plugins_dir + self._skills_dir = skills_dir + self._load_plugins(plugins_dir) + self._load_skills(skills_dir) + self._build_mcp_cache() + + print(f"{Fore.GREEN}[统一工具管理器] 加载完成: {len(self._tools)} 个工具{Style.RESET_ALL}") + print(f" - Liugin 协议: {sum(1 for p in self._protocol_map.values() if p == 'liugin')}") + print(f" - Skill 协议: {sum(1 for p in self._protocol_map.values() if p == 'skill')}") + + def shutdown(self) -> None: + """关闭管理器，清理所有插件实例""" + with self._lock: + for name, tool in self._tools.items(): + instance = tool.get('instance') + if instance and hasattr(instance, 'cleanup'): + try: + instance.cleanup() + except Exception: + pass + self._tools.clear() + self._protocol_map.clear() + self._mcp_tools_cache = None + + def _load_plugins(self, plugins_dir: str) -> None: + """加载 Liugin 协议工具""" + import importlib.util + + if not os.path.exists(plugins_dir): + return + + enabled_plugins = self._get_enabled_plugins(plugins_dir) + + for filename in os.listdir(plugins_dir): + if not filename.endswith('.py') or filename == '__init__.py': + continue + + plugin_name = filename[:-3] + + if enabled_plugins is not None and plugin_name.lower() not in enabled_plugins: + continue + + plugin_path = os.path.join(plugins_dir, filename) + + try: + spec = importlib.util.spec_from_file_location(plugin_name, plugin_path) + module = importlib.util.module_from_spec(spec) + spec.loader.exec_module(module) + + plugin_class = None + if hasattr(module, 'Liugin'): + plugin_class = module.Liugin + elif hasattr(module, 'Plugin'): + plugin_class = module.Plugin + + if plugin_class: + plugin_instance = plugin_class() + + if hasattr(plugin_instance, 'set_cli') and self.cli: + plugin_instance.set_cli(self.cli) + + tool_info = plugin_instance.get_tool_info() + tool_name = tool_info.get('name', plugin_name) + + mcp_definition = None + if hasattr(plugin_instance, 'get_mcp_definition'): + mcp_definition = plugin_instance.get_mcp_definition() + + self._tools[tool_name] = { + 'name': tool_name, + 'description': tool_info.get('description', ''), + 'keywords': tool_info.get('keywords', []), + 'usage': tool_info.get('usage', ''), + 'handler': plugin_instance.handle, + 'protocol': 'liugin', + 'instance': plugin_instance, + 'mcp_definition': mcp_definition + } + self._protocol_map[tool_name] = 'liugin' + + except Exception as e: + print(f"{Fore.RED}加载 Liugin '{plugin_name}' 失败: {e}{Style.RESET_ALL}") + + def _load_skills(self, skills_dir: str) -> None: + """加载 Skill 协议工具 (支持 Markdown 和 Python 两种格式)""" + if not os.path.exists(skills_dir): + print(f"{Fore.YELLOW}Skills 目录不存在: {skills_dir}{Style.RESET_ALL}") + return + + try: + from skills.base import SkillLoader, MarkdownSkill, Skill + + self._skill_loader = SkillLoader(skills_dir) + + discovered = self._skill_loader.discover_skills(skills_dir) + print(f"{Fore.CYAN}发现 {len(discovered)} 个技能: {[s['name'] for s in discovered]}{Style.RESET_ALL}") + + self._skill_loader.load_all_skills(skills_dir) + + loaded_count = len(self._skill_loader.skills) + if loaded_count == 0: + print(f"{Fore.YELLOW}未加载任何 Skill 技能{Style.RESET_ALL}") + return + + for skill_name, skill in self._skill_loader.skills.items(): + if hasattr(skill, 'set_cli') and self.cli: + skill.set_cli(self.cli) + + tool_def = skill.get_tool_definition() + func_def = tool_def.get('function', {}) + + if skill_name in self._tools: + old_protocol = self._protocol_map[skill_name] + print(f"{Fore.YELLOW}工具 '{skill_name}' 已存在({old_protocol})，使用 Skill 协议覆盖{Style.RESET_ALL}") + + is_markdown = isinstance(skill, MarkdownSkill) + skill_format = "markdown" if is_markdown else "python" + + self._tools[skill_name] = { + 'name': skill_name, + 'description': func_def.get('description', ''), + 'keywords': getattr(skill, 'tags', []), + 'usage': getattr(skill, 'instructions', '')[:500] if is_markdown else getattr(skill, 'usage', ''), + 'handler': self._create_skill_handler(skill), + 'protocol': 'skill', + 'format': skill_format, + 'instance': skill, + 'tool_definition': tool_def, + 'anthropic_definition': skill.get_anthropic_tool_definition(), + 'mcp_definition': tool_def + } + self._protocol_map[skill_name] = 'skill' + + print(f"{Fore.GREEN}已加载 Skill ({skill_format}): {skill_name}{Style.RESET_ALL}") + + except ImportError as e: + print(f"{Fore.YELLOW}Skill 协议模块未找到: {e}{Style.RESET_ALL}") + except Exception as e: + print(f"{Fore.RED}加载 Skills 失败: {e}{Style.RESET_ALL}") + + def _create_skill_handler(self, skill) -> callable: + """为 Skill 创建兼容 Plugin 的 handler""" + from skills.base import MarkdownSkill, Skill + + def handler(args: str): + """Skill handler - 返回 ToolResult""" + kwargs = {} + + args = args.strip() + if args.startswith('{'): + try: + kwargs = json.loads(args) + except json.JSONDecodeError: + kwargs = {'operation': args} + elif '=' in args: + for part in args.split(): + if '=' in part: + k, v = part.split('=', 1) + kwargs[k.strip()] = v.strip() + else: + kwargs.setdefault('operation', part) + else: + kwargs = {'operation': args} + + if isinstance(skill, MarkdownSkill): + return ToolResult.ok(f"[Skill: {skill.name}]\n{skill.instructions}") + + if hasattr(skill, 'run'): + result = skill.run(**kwargs) + if result.success: + return ToolResult.ok(result.message or str(result.data)) + else: + return ToolResult.fail(str(result.error), ErrorCode.EXEC_FAILED) + + return ToolResult.fail(f"未知的技能类型: {type(skill)}", ErrorCode.NOT_IMPLEMENTED) + + return handler + + def _get_enabled_plugins(self, plugins_dir: str) -> Optional[List[str]]: + """获取启用的插件列表""" + enabled_env = os.environ.get("XIAOLI_ENABLED_PLUGINS") + if enabled_env is not None: + if enabled_env == "": + return [] + return [p.lower() for p in enabled_env.split(",")] + + config_file = os.path.join(os.path.dirname(plugins_dir), "plugins_config.py") + if os.path.exists(config_file): + try: + with open(config_file, 'r', encoding='utf-8') as f: + content = f.read() + + if "# 不启用任何插件" in content: + return [] + + enabled = [] + for line in content.split('\n'): + if line.startswith('ENABLE_') and '= True' in line: + name = line.split('=')[0].replace('ENABLE_', '').strip().lower() + enabled.append(name) + return enabled + except Exception: + pass + + return None + + def _build_mcp_cache(self) -> None: + """构建 MCP 工具定义缓存（线程安全）""" + with self._lock: + self._mcp_tools_cache = [] + for tool in self._tools.values(): + mcp_def = tool.get('mcp_definition') + if mcp_def: + normalized = self._normalize_mcp_definition(mcp_def) + self._mcp_tools_cache.append(normalized) + else: + self._mcp_tools_cache.append(self._generate_mcp_definition(tool)) + + def _normalize_mcp_definition(self, mcp_def: Dict[str, Any]) -> Dict[str, Any]: + """标准化 MCP 工具定义""" + if 'name' in mcp_def and ('inputSchema' in mcp_def or 'description' in mcp_def): + return mcp_def + + if mcp_def.get('type') == 'function' and 'function' in mcp_def: + func = mcp_def['function'] + return { + "name": func.get('name', ''), + "description": func.get('description', ''), + "inputSchema": func.get('parameters', {"type": "object", "properties": {}}) + } + + return mcp_def + + def _generate_mcp_definition(self, tool: Dict[str, Any]) -> Dict[str, Any]: + """为 Plugin 生成符合 MCP 标准的工具定义""" + return { + "name": tool['name'], + "description": tool.get('description', ''), + "inputSchema": { + "type": "object", + "properties": { + "args": { + "type": "string", + "description": f"命令参数。用法:\\n{tool.get('usage', '')[:1000]}" + } + }, + "required": ["args"] + } + } + + # ==================== 公共 API ==================== + + @property + def tools(self) -> List[Dict[str, Any]]: + """获取所有工具列表（兼容 LiuginManager 接口）""" + return list(self._tools.values()) + + def get_tool(self, name: str) -> Optional[Dict[str, Any]]: + """获取指定工具""" + return self._tools.get(name) + + def get_protocol(self, name: str) -> Optional[str]: + """获取工具使用的协议""" + return self._protocol_map.get(name) + + def execute(self, tool_name: str, args: str = "", **kwargs) -> ToolResult: + """执行工具调用，返回 ToolResult""" + with self._lock: + tool = self._tools.get(tool_name) + + if not tool: + return ToolResult.fail(f"未找到工具: {tool_name}", ErrorCode.NOT_FOUND, tool_name=tool_name) + + try: + handler = tool['handler'] + protocol = tool['protocol'] + instance = tool.get('instance') + + if protocol == 'skill' and kwargs: + skill = tool['instance'] + result = skill.run(**kwargs) + if result.success: + return ToolResult.ok(result.message or str(result.data), tool_name=tool_name) + else: + return ToolResult.fail(str(result.error), ErrorCode.EXEC_FAILED, tool_name=tool_name) + + elif protocol == 'liugin' and kwargs and not args: + if instance and hasattr(instance, 'convert_mcp_args'): + args = instance.convert_mcp_args(kwargs) + else: + args = self._convert_mcp_args_to_plugin_args(tool_name, kwargs, instance) + + result = handler(args) + # 兼容：handler 可能返回 ToolResult 或字符串 + if isinstance(result, ToolResult): + result.tool_name = tool_name + return result + return ToolResult.ok(result if result is not None else "执行完成", tool_name=tool_name) + + except Exception as e: + logger.exception(f"工具 {tool_name} 执行异常") + return ToolResult.fail(str(e), ErrorCode.INTERNAL_ERROR, tool_name=tool_name) + + def execute_dict(self, tool_name: str, args: str = "", **kwargs) -> Dict[str, Any]: + """执行工具调用，返回 dict（兼容旧接口）""" + return self.execute(tool_name, args, **kwargs).to_dict() + + # ==================== MCP 协议支持 ==================== + + def get_mcp_tools(self) -> List[Dict[str, Any]]: + """获取 MCP 格式的工具定义列表""" + with self._lock: + if self._mcp_tools_cache is None: + self._build_mcp_cache() + return self._mcp_tools_cache.copy() + + def mcp_call(self, tool_name: str, arguments: Dict[str, Any]) -> Dict[str, Any]: + """MCP 格式的工具调用入口""" + tool = self._tools.get(tool_name) + + if not tool: + return ToolResult.fail(f"未找到工具: {tool_name}", ErrorCode.NOT_FOUND, tool_name=tool_name).to_mcp() + + try: + protocol = tool['protocol'] + instance = tool.get('instance') + + if protocol == 'liugin': + args = self._convert_mcp_args_to_plugin_args(tool_name, arguments, instance) + result = tool['handler'](args) + # 兼容：handler 可能返回 ToolResult 或字符串 + if isinstance(result, ToolResult): + result.tool_name = tool_name + return result.to_mcp() + return ToolResult.ok(result or "执行完成", tool_name=tool_name).to_mcp() + + elif protocol == 'skill': + from skills.base import MarkdownSkill + + if isinstance(instance, MarkdownSkill): + return ToolResult.ok(f"[Skill: {instance.name}]\n{instance.instructions}", tool_name=tool_name).to_mcp() + + if hasattr(instance, 'run'): + result = instance.run(**arguments) + if result.success: + return ToolResult.ok(result.message or str(result.data), tool_name=tool_name).to_mcp() + else: + return ToolResult.fail(str(result.error), ErrorCode.EXEC_FAILED, tool_name=tool_name).to_mcp() + + return ToolResult.fail(f"未知协议类型: {protocol}", ErrorCode.INTERNAL_ERROR, tool_name=tool_name).to_mcp() + + except Exception as e: + logger.exception(f"MCP 调用 {tool_name} 异常") + return ToolResult.fail(str(e), ErrorCode.INTERNAL_ERROR, tool_name=tool_name).to_mcp() + + def _convert_mcp_args_to_plugin_args(self, tool_name: str, arguments: Dict[str, Any], + instance: Any) -> str: + """将 MCP 结构化参数转换为 Plugin 的 args 字符串""" + if instance and hasattr(instance, 'convert_mcp_args'): + return instance.convert_mcp_args(arguments) + + if 'args' in arguments: + return arguments['args'] + + parts = [] + + if 'operation' in arguments: + parts.append(arguments['operation']) + elif 'action' in arguments: + parts.append(arguments['action']) + + for key, value in arguments.items(): + if key in ('operation', 'action'): + continue + + if isinstance(value, bool): + if value: + parts.append(f"-{key}") + elif isinstance(value, (list, tuple)): + for v in value: + parts.append(f"--{key}") + parts.append(self._quote_if_needed(str(v))) + else: + parts.append(f"--{key}") + parts.append(self._quote_if_needed(str(value))) + + return ' '.join(parts) + + def _quote_if_needed(self, s: str) -> str: + if ' ' in s or '"' in s: + return f'"{s}"' + return s + + def _mcp_success(self, text: str) -> Dict[str, Any]: + """MCP 成功响应（兼容旧接口，推荐用 ToolResult.ok().to_mcp()）""" + return ToolResult.ok(text).to_mcp() + + def _mcp_error(self, error_msg: str) -> Dict[str, Any]: + """MCP 错误响应（兼容旧接口，推荐用 ToolResult.fail().to_mcp()）""" + return ToolResult.fail(error_msg).to_mcp() + + # ==================== 兼容性 API ==================== + + def get_openai_tools(self) -> List[Dict[str, Any]]: + """获取 OpenAI Function Calling 格式的工具定义""" + tools = [] + for mcp_def in self.get_mcp_tools(): + tools.append({ + "type": "function", + "function": { + "name": mcp_def.get("name", ""), + "description": mcp_def.get("description", ""), + "parameters": mcp_def.get("inputSchema", {"type": "object", "properties": {}}) + } + }) + return tools + + def get_anthropic_tools(self) -> List[Dict[str, Any]]: + """获取 Anthropic Tool Use 格式的工具定义""" + tools = [] + for mcp_def in self.get_mcp_tools(): + tools.append({ + "name": mcp_def.get("name", ""), + "description": mcp_def.get("description", ""), + "input_schema": mcp_def.get("inputSchema", {"type": "object", "properties": {}}) + }) + return tools + + def search_tools(self, query: str, limit: int = 5) -> List[Dict[str, Any]]: + """搜索工具""" + query_lower = query.lower() + query_normalized = query_lower.replace('-', '').replace('_', '').replace(' ', '') + matches = [] + + for tool in self._tools.values(): + score = self._score_tool_match(tool, query_lower, query_normalized) + if score > 0: + matches.append({ + 'name': tool['name'], + 'description': tool['description'], + 'usage': tool.get('usage', ''), + 'keywords': [kw.lower() for kw in tool.get('keywords', [])], + 'protocol': tool['protocol'], + 'instance': tool.get('instance'), + 'score': score + }) + + matches.sort(key=lambda x: x['score'], reverse=True) + return matches[:limit] + + def _score_tool_match(self, tool: Dict, query_lower: str, query_normalized: str) -> int: + """计算工具匹配分数""" + score = 0 + name = tool.get('name', '').lower() + name_normalized = name.replace('-', '').replace('_', '') + desc = tool.get('description', '').lower() + keywords = [kw.lower() for kw in tool.get('keywords', [])] + + if query_lower == name or query_normalized == name_normalized: + score += 100 + elif query_normalized in name_normalized or query_lower in name: + score += 50 + if query_lower in desc: + score += 30 + for kw in keywords: + kw_normalized = kw.replace('-', '').replace('_', '') + if query_lower in kw or query_normalized in kw_normalized: + score += 20 + break + return score + + def register_tool(self, name: str, handler: callable, description: str = "", + protocol: str = "custom", mcp_definition: Dict = None, **kwargs) -> None: + """动态注册工具""" + with self._lock: + self._tools[name] = { + 'name': name, + 'description': description, + 'handler': handler, + 'protocol': protocol, + 'mcp_definition': mcp_definition, + **kwargs + } + self._protocol_map[name] = protocol + + if self._mcp_tools_cache is not None: + if mcp_definition: + self._mcp_tools_cache.append(mcp_definition) + else: + self._mcp_tools_cache.append(self._generate_mcp_definition(self._tools[name])) + + def unregister_tool(self, name: str) -> bool: + """注销工具""" + with self._lock: + if name in self._tools: + instance = self._tools[name].get('instance') + if instance and hasattr(instance, 'cleanup'): + try: + instance.cleanup() + except Exception: + pass + del self._tools[name] + del self._protocol_map[name] + self._build_mcp_cache() + return True + return False + + def get_all_tools_info(self) -> List[Dict[str, Any]]: + """获取所有工具的简要信息，用于系统提示词""" + result = [] + for tool in self._tools.values(): + result.append({ + 'name': tool['name'], + 'description': tool.get('description', ''), + 'keywords': tool.get('keywords', []), + 'protocol': tool.get('protocol', ''), + }) + return result + + def get_tool_by_name(self, name: str) -> Optional[Dict[str, Any]]: + """根据名称获取工具（兼容 LiuginManager 接口）""" + return self._tools.get(name) + + def get_skills_system_prompt(self) -> str: + """获取所有技能的系统提示词""" + skill_prompts = [] + + for name, tool in self._tools.items(): + if tool['protocol'] == 'skill': + instance = tool.get('instance') + if instance: + instructions = getattr(instance, 'instructions', '') + scripts_dir = getattr(instance, 'scripts_dir', '') + + prompt_parts = [f"## 技能: {name}"] + prompt_parts.append(f"描述: {tool['description']}") + + if instructions: + prompt_parts.append(f"\n{instructions}") + + if scripts_dir: + prompt_parts.append(f"\n脚本目录: {scripts_dir}") + + skill_prompts.append('\n'.join(prompt_parts)) + + if skill_prompts: + header = "# 已加载的 Agent Skills\n以下技能可用于执行特定任务，调用方式与工具相同：\n" + return header + '\n\n---\n\n'.join(skill_prompts) + + return "" + + def get_tools_prompt(self) -> str: + """获取工具使用提示词（兼容旧接口）""" + prompts = [] + + plugin_tools = [t for t in self._tools.values() if t['protocol'] == 'liugin'] + if plugin_tools: + prompts.append("## Liugin 工具") + for tool in plugin_tools: + usage = tool.get('usage', '') + if usage: + prompts.append(f"### {tool['name']}\n{usage}\n") + + skills_prompt = self.get_skills_system_prompt() + if skills_prompt: + prompts.append(skills_prompt) + + return '\n\n'.join(prompts) + + # ==================== MCP Server 模式支持 ==================== + + def get_mcp_server_info(self) -> Dict[str, Any]: + """获取 MCP Server 信息""" + return { + "name": "xiaoli-tool-server", + "version": "1.0.0", + "protocolVersion": "2024-11-05", + "capabilities": {"tools": {"listChanged": True}} + } + + def handle_mcp_request(self, request: Dict[str, Any]) -> Dict[str, Any]: + """处理 MCP 协议请求""" + method = request.get('method', '') + params = request.get('params', {}) + req_id = request.get('id') + + result = None + error = None + + try: + if method == 'tools/list': + result = {"tools": self.get_mcp_tools()} + + elif method == 'tools/call': + tool_name = params.get('name') + arguments = params.get('arguments', {}) + if not tool_name: + error = {"code": -32602, "message": "Missing tool name"} + else: + result = self.mcp_call(tool_name, arguments) + + elif method == 'initialize': + result = self.get_mcp_server_info() + + elif method == 'ping': + result = {} + + else: + error = {"code": -32601, "message": f"Method not found: {method}"} + + except Exception as e: + error = {"code": -32603, "message": str(e)} + + response = {"jsonrpc": "2.0", "id": req_id} + if error: + response["error"] = error + else: + response["result"] = result + + return response diff --git a/xcli_core/__init__.py b/xcli_core/__init__.py new file mode 100644 index 0000000..89061ea --- /dev/null +++ b/xcli_core/__init__.py @@ -0,0 +1 @@ +"""xcli_core - 兼容层（旧插件依赖）""" diff --git a/xcli_core/config.py b/xcli_core/config.py new file mode 100644 index 0000000..4eff300 --- /dev/null +++ b/xcli_core/config.py @@ -0,0 +1,108 @@ +import os +import json +import logging +from colorama import Fore, Style + +# 配置文件路径 +CONFIG_FILE = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "config.json") + + +def load_config(): + """加载配置文件""" + try: + with open(CONFIG_FILE, 'r', encoding='utf-8') as f: + return json.load(f) + except FileNotFoundError: + return {"api": {"engines": {}}, "system": {}, "plugins": {}} + except json.JSONDecodeError: + return {"api": {"engines": {}}, "system": {}, "plugins": {}} + + +def save_config(config): + """保存配置文件""" + try: + with open(CONFIG_FILE, 'w', encoding='utf-8') as f: + json.dump(config, f, ensure_ascii=False, indent=2) + except Exception as e: + print(f"保存配置失败: {e}") + + +def get_system_config(key, default=None): + """获取系统配置""" + config = load_config() + return config.get("system", {}).get(key, default) + + +def set_system_config(key, value): + """设置系统配置""" + config = load_config() + if "system" not in config: + config["system"] = {} + config["system"][key] = value + save_config(config) + + +# ── 引擎配置档案管理 ── +# 存储结构: config["engine_profiles"][engine_name] = [ {name, base_url, api_key, model}, ... ] + +def get_profiles(engine_name): + """获取指定引擎的所有配置档案""" + config = load_config() + return config.get("engine_profiles", {}).get(engine_name, []) + + +def save_profile(engine_name, profile): + """保存/更新一个配置档案（按 name 去重，已存在则覆盖）""" + config = load_config() + if "engine_profiles" not in config: + config["engine_profiles"] = {} + profiles = config["engine_profiles"].setdefault(engine_name, []) + # 按 name 去重 + for i, p in enumerate(profiles): + if p.get("name") == profile.get("name"): + profiles[i] = profile + break + else: + profiles.append(profile) + config["engine_profiles"][engine_name] = profiles + save_config(config) + + +def delete_profile(engine_name, profile_name): + """删除指定引擎的一个配置档案""" + config = load_config() + profiles = config.get("engine_profiles", {}).get(engine_name, []) + profiles = [p for p in profiles if p.get("name") != profile_name] + if "engine_profiles" not in config: + config["engine_profiles"] = {} + config["engine_profiles"][engine_name] = profiles + save_config(config) + + +def apply_profile(engine_name, profile): + """将档案应用到 config.json 的 api.engines 节点（下次启动或重载时生效）""" + config = load_config() + if "api" not in config: + config["api"] = {} + if "engines" not in config["api"]: + config["api"]["engines"] = {} + engine_cfg = config["api"]["engines"].setdefault(engine_name, {}) + if "base_url" in profile: + engine_cfg["base_url"] = profile["base_url"] + if "api_key" in profile: + engine_cfg["api_key"] = profile["api_key"] + if "model" in profile: + engine_cfg["model"] = profile["model"] + save_config(config) + + +# 配置日志 +logging.basicConfig( + level=logging.INFO, + format='%(asctime)s - %(name)s - %(levelname)s - %(message)s', + handlers=[ + logging.FileHandler('xiaoli_cli.log', encoding='utf-8'), + logging.StreamHandler() # 同时输出到控制台 + ] +) +logger = logging.getLogger(__name__) diff --git a/xcli_core/constants.py b/xcli_core/constants.py new file mode 100644 index 0000000..4216d40 --- /dev/null +++ b/xcli_core/constants.py @@ -0,0 +1,87 @@ +# 常量定义 +WEB_SERVER_DEFAULT_PORT = 8080 +MAX_FILE_SIZE = 52428800 # 50MB +MAX_VIDEO_DURATION = 10000 # 10秒 +VIDEO_FRAME_DELAY = 0.04 # 40毫秒 +LOVE_FILE_PATH = "love.txt" +DEFAULT_MAX_HISTORY = 999999 # 无限制对话历史 + +import os +import sys +import importlib.util +import json +import re +import shutil +import time +import threading +from concurrent.futures import ThreadPoolExecutor, as_completed +from colorama import init, Fore, Style +from http.server import HTTPServer, BaseHTTPRequestHandler +from urllib.parse import urlparse, parse_qs +import socket +import webbrowser +from datetime import datetime +import logging +import asyncio +from typing import Optional +from io import StringIO + +# ── 第三方依赖（全部 try/except 保护） ── + +try: + import requests + REQUESTS_AVAILABLE = True +except ImportError: + requests = None + REQUESTS_AVAILABLE = False + +try: + from openai import OpenAI + OPENAI_AVAILABLE = True +except ImportError: + OpenAI = None + OPENAI_AVAILABLE = False + +try: + import numpy as np + NUMPY_AVAILABLE = True +except ImportError: + np = None + NUMPY_AVAILABLE = False + +# tkinter 仅在视频播放功能中使用，服务器环境可能不可用 +try: + import tkinter as tk + from tkinter import ttk + TKINTER_AVAILABLE = True +except ImportError: + TKINTER_AVAILABLE = False + +# cv2 仅在视频播放功能中使用 +try: + import cv2 + CV2_AVAILABLE = True +except ImportError: + CV2_AVAILABLE = False + +# 图像显示相关（可选） +try: + from PIL import Image + PIL_AVAILABLE = True +except ImportError: + PIL_AVAILABLE = False + +try: + from ascii_magic import AsciiArt + ASCII_MAGIC_AVAILABLE = True +except ImportError: + ASCII_MAGIC_AVAILABLE = False + +# 统一工具管理器 - 支持 Liugin 和 Skill 双协议 +try: + from unified_tool_manager import UnifiedToolManager + UNIFIED_TOOL_MANAGER_AVAILABLE = True +except ImportError: + UNIFIED_TOOL_MANAGER_AVAILABLE = False + +# TUI 模式已移除，全面使用 CLI 模式 diff --git a/xcli_core/memory.py b/xcli_core/memory.py new file mode 100644 index 0000000..cc16801 --- /dev/null +++ b/xcli_core/memory.py @@ -0,0 +1,800 @@ +""" +持久化记忆系统 +- MEMORY.md: 长期记忆（AI 自己维护的精华） +- memory/YYYY-MM-DD.md: 每日日记/日志 +- chat_history/: 自动保存的聊天记录 +- 支持关键词检索、上下文压缩、AI 写日记 +""" +import os +import re +import json +import time +import glob +from datetime import datetime, timedelta +from typing import List, Dict, Optional, Tuple + + +class MemoryManager: + """持久化记忆管理器""" + + # 记忆模式常量 + MODE_COMPANION = "companion" # 陪伴模式（长期记忆） + MODE_WORK = "work" # 工作模式（短期记忆） + + def __init__(self, project_dir: str): + self.project_dir = project_dir + self.memory_dir = os.path.join(project_dir, "memory") + self.memory_file = os.path.join(project_dir, "MEMORY.md") + self.chat_dir = os.path.join(project_dir, "chat_history") + self.config_file = os.path.join(project_dir, "config.json") + self.compress_threshold = 50 # 超过 50 条消息触发压缩 + self._ensure_dirs() + self._memory_mode = self._load_memory_mode() + + def _load_memory_mode(self) -> str: + """加载记忆模式配置""" + try: + if os.path.exists(self.config_file): + with open(self.config_file, 'r', encoding='utf-8') as f: + config = json.load(f) + return config.get("system", {}).get("memory_mode", "") + except Exception: + pass + return "" + + def _save_memory_mode(self, mode: str): + """保存记忆模式配置""" + try: + config = {} + if os.path.exists(self.config_file): + with open(self.config_file, 'r', encoding='utf-8') as f: + config = json.load(f) + if "system" not in config: + config["system"] = {} + config["system"]["memory_mode"] = mode + with open(self.config_file, 'w', encoding='utf-8') as f: + json.dump(config, f, ensure_ascii=False, indent=2) + self._memory_mode = mode + except Exception as e: + print(f"保存记忆模式配置失败: {e}") + + def get_memory_mode(self) -> str: + """获取当前记忆模式""" + return self._memory_mode + + def is_mode_selected(self) -> bool: + """检查是否已选择记忆模式""" + return self._memory_mode in [self.MODE_COMPANION, self.MODE_WORK] + + def select_mode(self, mode: str) -> bool: + """选择记忆模式（只能选择一次）""" + if self.is_mode_selected(): + return False # 已经选择过，不能更改 + if mode not in [self.MODE_COMPANION, self.MODE_WORK]: + return False # 无效的模式 + self._save_memory_mode(mode) + return True + + def get_mode_description(self) -> str: + """获取当前模式的描述""" + if self._memory_mode == self.MODE_COMPANION: + return "陪伴模式（长期记忆）：拥有成熟的记忆功能，记住用户的偏好、习惯、历史对话等" + elif self._memory_mode == self.MODE_WORK: + return "工作模式（短期记忆）：每次对话是独立的短期记忆，可通过指令手动存储聊天记录" + return "未选择模式" + + def _ensure_dirs(self): + """确保目录存在""" + os.makedirs(self.memory_dir, exist_ok=True) + os.makedirs(self.chat_dir, exist_ok=True) + + # ══════════════════════════════════════════════ + # MEMORY.md — 长期记忆 + # ══════════════════════════════════════════════ + + def load_memory(self) -> str: + """读取 MEMORY.md 内容""" + if os.path.exists(self.memory_file): + try: + with open(self.memory_file, 'r', encoding='utf-8') as f: + return f.read() + except Exception: + return "" + return "" + + def save_memory(self, content: str): + """保存 MEMORY.md""" + with open(self.memory_file, 'w', encoding='utf-8') as f: + f.write(content) + + def append_memory(self, section: str, content: str): + """向 MEMORY.md 的指定 section 追加内容""" + existing = self.load_memory() + marker = f"## {section}" + if marker in existing: + # 在该 section 末尾追加 + parts = existing.split(marker, 1) + after = parts[1] + # 找到下一个 ## 或文件末尾 + next_section = after.find("\n## ") + if next_section == -1: + new_content = parts[0] + marker + after.rstrip() + "\n" + content + "\n" + else: + new_content = (parts[0] + marker + after[:next_section].rstrip() + + "\n" + content + "\n" + after[next_section:]) + self.save_memory(new_content) + else: + # 新增 section + new_content = existing.rstrip() + f"\n\n{marker}\n{content}\n" + self.save_memory(new_content) + + def list_memory_sections(self) -> list: + """列出 MEMORY.md 中所有的 section 标题""" + content = self.load_memory() + if not content: + return [] + sections = [] + for line in content.split("\n"): + line = line.strip() + if line.startswith("## "): + sections.append(line[3:].strip()) + return sections + + def read_memory_section(self, section: str) -> str: + """读取 MEMORY.md 中指定 section 的内容""" + content = self.load_memory() + if not content: + return "" + marker = f"## {section}" + if marker not in content: + return "" + parts = content.split(marker, 1) + after = parts[1] + next_section = after.find("\n## ") + if next_section == -1: + return after.strip() + return after[:next_section].strip() + + def write_memory_section(self, section: str, content: str): + """写入/覆盖 MEMORY.md 中指定 section（如不存在则新建）""" + existing = self.load_memory() + marker = f"## {section}" + if marker in existing: + # 替换该 section 的内容 + parts = existing.split(marker, 1) + after = parts[1] + next_section = after.find("\n## ") + if next_section == -1: + new_content = parts[0] + marker + "\n" + content + "\n" + else: + new_content = (parts[0] + marker + "\n" + content + "\n" + after[next_section:]) + self.save_memory(new_content) + else: + # 新增 section + new_content = existing.rstrip() + f"\n\n{marker}\n{content}\n" + self.save_memory(new_content) + + def delete_memory_section(self, section: str) -> bool: + """删除 MEMORY.md 中指定的 section""" + existing = self.load_memory() + if not existing: + return False + marker = f"## {section}" + if marker not in existing: + return False + parts = existing.split(marker, 1) + after = parts[1] + next_section = after.find("\n## ") + if next_section == -1: + new_content = parts[0].rstrip() + "\n" + else: + new_content = parts[0] + after[next_section:] + self.save_memory(new_content) + return True + + # ══════════════════════════════════════════════ + # 每日日记 — memory/YYYY-MM-DD.md + # ══════════════════════════════════════════════ + + def _today_file(self) -> str: + """今天的日记文件路径""" + return os.path.join(self.memory_dir, f"{datetime.now().strftime('%Y-%m-%d')}.md") + + def load_today(self) -> str: + """读取今天的日记""" + path = self._today_file() + if os.path.exists(path): + try: + with open(path, 'r', encoding='utf-8') as f: + return f.read() + except Exception: + return "" + return "" + + def write_diary(self, content: str, tag: str = ""): + """写日记条目""" + path = self._today_file() + now = datetime.now().strftime("%H:%M") + tag_str = f" [{tag}]" if tag else "" + entry = f"\n### {now}{tag_str}\n{content}\n" + + existing = "" + if os.path.exists(path): + try: + with open(path, 'r', encoding='utf-8') as f: + existing = f.read() + except Exception: + pass + + if not existing: + date_str = datetime.now().strftime("%Y-%m-%d") + existing = f"# {date_str} 开发日志\n" + + with open(path, 'a', encoding='utf-8') as f: + f.write(entry) + + def write_ai_diary(self, content: str): + """AI 写日记（自动标记为 AI 观察）""" + self.write_diary(content, tag="AI观察") + + def list_diary_files(self) -> List[str]: + """列出所有日记文件""" + files = glob.glob(os.path.join(self.memory_dir, "*.md")) + files.sort(reverse=True) + return [os.path.basename(f) for f in files] + + def load_diary(self, date_str: str) -> str: + """读取指定日期的日记""" + path = os.path.join(self.memory_dir, f"{date_str}.md") + if os.path.exists(path): + try: + with open(path, 'r', encoding='utf-8') as f: + return f.read() + except Exception: + return "" + return "" + + # ══════════════════════════════════════════════ + # 聊天记录 — 自动保存 + # ══════════════════════════════════════════════ + + # ══════════════════════════════════════════════ + # 聊天记录 — 单文件 JSON 存储 + # ══════════════════════════════════════════════ + + CHAT_STORE_FILE = "chats.json" # 单文件存储 + + def _chat_store_path(self) -> str: + """聊天记录单文件路径""" + return os.path.join(self.chat_dir, self.CHAT_STORE_FILE) + + def _load_chat_store(self) -> dict: + """加载聊天记录存储""" + path = self._chat_store_path() + try: + if os.path.exists(path): + with open(path, 'r', encoding='utf-8') as f: + return json.load(f) + except Exception: + pass + return {"chats": []} + + def _save_chat_store(self, store: dict): + """保存聊天记录存储""" + path = self._chat_store_path() + try: + with open(path, 'w', encoding='utf-8') as f: + json.dump(store, f, ensure_ascii=False, indent=2, default=str) + except Exception: + pass + + def auto_save_chat(self, conversation: list, label: str = ""): + """保存聊天记录到单文件存储""" + if not conversation: + return + store = self._load_chat_store() + now = datetime.now() + chat_name = label or now.strftime("%Y-%m-%d %H:%M:%S") + + chat_entry = { + "name": chat_name, + "timestamp": now.strftime("%Y-%m-%d %H:%M:%S"), + "label": label, + "message_count": len(conversation), + "conversation": conversation + } + + # 按名称去重：如果同名已存在则覆盖 + chats = store.get("chats", []) + for i, c in enumerate(chats): + if c.get("name") == chat_name: + chats[i] = chat_entry + break + else: + chats.append(chat_entry) + + store["chats"] = chats + self._save_chat_store(store) + + def list_chats(self, limit: int = 20) -> List[Dict]: + """列出最近的聊天记录""" + store = self._load_chat_store() + chats = store.get("chats", []) + # 按时间倒序 + chats_sorted = sorted(chats, key=lambda c: c.get("timestamp", ""), reverse=True) + results = [] + for c in chats_sorted[:limit]: + results.append({ + "name": c.get("name", ""), + "time": c.get("timestamp", ""), + "size_kb": round(len(json.dumps(c, ensure_ascii=False)) / 1024, 1), + }) + return results + + def load_chat(self, name: str) -> Optional[list]: + """加载指定的聊天记录（按名称查找）""" + store = self._load_chat_store() + for c in store.get("chats", []): + if c.get("name") == name: + return c.get("conversation", []) + return None + + def delete_chat(self, name: str) -> bool: + """删除指定的聊天记录""" + store = self._load_chat_store() + chats = store.get("chats", []) + new_chats = [c for c in chats if c.get("name") != name] + if len(new_chats) == len(chats): + return False + store["chats"] = new_chats + self._save_chat_store(store) + return True + + def search_chats(self, keyword: str, limit: int = 10) -> List[Dict]: + """在聊天记录中搜索关键词""" + keyword_lower = keyword.lower() + store = self._load_chat_store() + results = [] + for c in store.get("chats", []): + for msg in c.get("conversation", []): + content = msg.get("content", "") + if isinstance(content, str) and keyword_lower in content.lower(): + results.append({ + "name": c.get("name", ""), + "time": c.get("timestamp", ""), + "snippet": content[:120], + "role": msg.get("role", ""), + }) + break # 每条记录只匹配一次 + if len(results) >= limit: + break + return results + + # ══════════════════════════════════════════════ + # 关键词检索 — 全局记忆搜索 + # ══════════════════════════════════════════════ + + def search_memory(self, keyword: str, limit: int = 20) -> List[Dict]: + """ + 在所有记忆文件中搜索关键词 + 搜索范围: MEMORY.md + memory/*.md + chat_history/*.json + """ + keyword_lower = keyword.lower() + results = [] + + # 搜索 MEMORY.md + if os.path.exists(self.memory_file): + results.extend(self._search_file( + self.memory_file, keyword_lower, "MEMORY.md", limit - len(results) + )) + + # 搜索日记文件 + for md_file in sorted(glob.glob(os.path.join(self.memory_dir, "*.md")), reverse=True): + if len(results) >= limit: + break + name = f"memory/{os.path.basename(md_file)}" + results.extend(self._search_file( + md_file, keyword_lower, name, limit - len(results) + )) + + # 搜索聊天记录（单文件存储） + store = self._load_chat_store() + for c in store.get("chats", []): + if len(results) >= limit: + break + name = f"chat/{c.get('name', '')}" + for msg in c.get("conversation", []): + content = msg.get("content", "") + if isinstance(content, str) and keyword_lower in content.lower(): + results.append({ + "source": name, + "line": 0, + "snippet": content[:120], + }) + break + + return results[:limit] + + def _search_file(self, path: str, keyword: str, source: str, limit: int) -> List[Dict]: + """在单个文件中搜索""" + results = [] + try: + with open(path, 'r', encoding='utf-8') as f: + lines = f.readlines() + for i, line in enumerate(lines): + if keyword in line.lower(): + snippet = line.strip()[:120] + results.append({ + "source": source, + "line": i + 1, + "snippet": snippet, + }) + if len(results) >= limit: + break + except Exception: + pass + return results + + def _search_json_file(self, path: str, keyword: str, source: str, limit: int) -> List[Dict]: + """在 JSON 聊天记录中搜索""" + results = [] + try: + with open(path, 'r', encoding='utf-8') as f: + data = json.load(f) + for msg in data.get("conversation", []): + content = msg.get("content", "") + if isinstance(content, str) and keyword in content.lower(): + results.append({ + "source": source, + "role": msg.get("role", ""), + "snippet": content[:120], + }) + if len(results) >= limit: + break + except Exception: + pass + return results + + # ══════════════════════════════════════════════ + # 上下文压缩 + # ══════════════════════════════════════════════ + + def should_compress(self, conversation: list) -> bool: + """判断是否需要压缩上下文""" + return len(conversation) > self.compress_threshold + + def compress_context(self, conversation: list, engine=None) -> list: + """ + 压缩对话历史 + 策略: 保留最近 10 条 + 用 AI 总结前面的内容 + """ + if len(conversation) <= 10: + return conversation + + keep_recent = 10 + to_compress = conversation[:-keep_recent] + recent = conversation[-keep_recent:] + + # 尝试用 AI 生成摘要 + summary = self._ai_summarize(to_compress, engine) + + # 构建压缩后的历史 + compressed = [{ + "role": "system", + "content": f"[上下文压缩] 以下是之前 {len(to_compress)} 条对话的摘要:\n{summary}" + }] + compressed.extend(recent) + return compressed + + def _ai_summarize(self, messages: list, engine=None) -> str: + """用 AI 生成对话摘要""" + if not engine: + return self._simple_summarize(messages) + + # 构建摘要请求 + conversation_text = "" + for msg in messages: + role = msg.get("role", "unknown") + content = msg.get("content", "") + if isinstance(content, str): + conversation_text += f"[{role}]: {content[:200]}\n" + + prompt = ( + "请用简洁的中文总结以下对话的关键信息（工具调用、代码修改、重要决策）。" + "控制在 200 字以内。\n\n" + f"{conversation_text}" + ) + + try: + summary = engine.generate_response( + prompt, + system_prompt="你是摘要生成器。只输出摘要，不要多余内容。" + ) + if summary and len(summary) > 10: + return summary + except Exception: + pass + + return self._simple_summarize(messages) + + def _simple_summarize(self, messages: list) -> str: + """简单摘要（不依赖 AI）""" + topics = [] + tool_calls = [] + for msg in messages: + content = msg.get("content", "") + role = msg.get("role", "") + if role == "user" and isinstance(content, str): + # 提取用户请求 + if len(content) < 100: + topics.append(content) + else: + topics.append(content[:50] + "...") + if role == "assistant" and isinstance(content, str): + # 提取工具调用 + if '"action": "use_tool"' in content or '"tool":' in content: + try: + # 尝试解析工具名 + for part in content.split('"tool":'): + if len(part) > 2: + tool_name = part.split('"')[1] if '"' in part else "" + if tool_name and tool_name not in tool_calls: + tool_calls.append(tool_name) + except Exception: + pass + + summary_parts = [] + if topics: + summary_parts.append(f"讨论了 {len(topics)} 个话题: {'; '.join(topics[:5])}") + if tool_calls: + summary_parts.append(f"使用了工具: {', '.join(tool_calls[:8])}") + summary_parts.append(f"共 {len(messages)} 条对话") + + return "。".join(summary_parts) + + # ══════════════════════════════════════════════ + # 构建记忆上下文（注入系统提示词） + # ══════════════════════════════════════════════ + + def build_memory_context(self) -> str: + """构建记忆上下文，用于注入系统提示词""" + parts = [] + + # 加载 MEMORY.md + memory = self.load_memory() + if memory: + parts.append(f"【长期记忆 MEMORY.md】\n{memory[:2000]}") + + # 加载今天的日记 + today = self.load_today() + if today: + parts.append(f"【今日日志】\n{today[:1000]}") + + if not parts: + return "" + + return ( + "\n\n---\n" + "以下是你的持久化记忆，帮助你了解之前的工作和上下文:\n\n" + + "\n\n".join(parts) + + "\n---\n" + ) + + # ══════════════════════════════════════════════ + # 工具接口（供 AI 调用） + # ══════════════════════════════════════════════ + + def handle_tool(self, args: str) -> str: + """处理 memory 工具调用""" + if not args or not args.strip(): + return self._tool_help() + + parts = args.strip().split(None, 1) + action = parts[0].lower() + rest = parts[1].strip() if len(parts) > 1 else "" + + if action == "write": + if not rest: + return "用法: memory write <内容>" + self.write_diary(rest) + return f"日记已写入 {datetime.now().strftime('%Y-%m-%d')}" + + elif action == "diary": + if not rest: + return "用法: memory diary " + self.write_ai_diary(rest) + return f"AI 日记已写入" + + elif action == "remember": + if not rest: + return "用法: memory remember <要记住的内容>" + self.append_memory("备忘", f"- {rest}") + return f"已记录到 MEMORY.md" + + elif action == "search": + if not rest: + return "用法: memory search <关键词>" + results = self.search_memory(rest) + if not results: + return f"未找到与 '{rest}' 相关的记忆" + lines = [f"搜索 '{rest}' 的结果:"] + for r in results: + source = r.get("source", "") + snippet = r.get("snippet", "") + role = r.get("role", "") + prefix = f"[{role}] " if role else "" + lines.append(f" 📄 {source}: {prefix}{snippet}") + return "\n".join(lines) + + elif action == "context": + ctx = self.build_memory_context() + return ctx if ctx else "当前没有记忆上下文" + + elif action == "diary_list": + files = self.list_diary_files() + if not files: + return "还没有日记文件" + return "日记文件:\n" + "\n".join(f" 📅 {f}" for f in files[:20]) + + elif action == "diary_read": + if not rest: + return "用法: memory diary_read <日期，如 2026-04-27>" + content = self.load_diary(rest) + return content if content else f"没有找到 {rest} 的日记" + + elif action == "chat_list": + chats = self.list_chats() + if not chats: + return "没有保存的聊天记录" + lines = ["最近的聊天记录:"] + for c in chats: + lines.append(f" 💬 {c['name']} ({c['time']}, {c['size_kb']}KB)") + return "\n".join(lines) + + elif action == "chat_search": + if not rest: + return "用法: memory chat_search <关键词>" + results = self.search_chats(rest) + if not results: + return f"未在聊天记录中找到 '{rest}'" + lines = [f"聊天记录搜索 '{rest}':"] + for r in results: + lines.append(f" 💬 {r['file']} [{r['role']}]: {r['snippet']}") + return "\n".join(lines) + + else: + return f"未知操作: {action}\n" + self._tool_help() + + def _tool_help(self) -> str: + return """memory 工具用法: + memory write <内容> - 写日记 + memory diary <内容> - AI 写观察日记 + memory remember <内容> - 记录到长期记忆 (MEMORY.md) + memory search <关键词> - 搜索所有记忆 + memory context - 查看当前记忆上下文 + memory diary_list - 列出所有日记 + memory diary_read <日期> - 读取指定日期日记 + memory chat_list - 列出聊天记录 + memory chat_search <关键词> - 在聊天记录中搜索""" + + +# ══════════════════════════════════════════════ +# 记忆插件（注册到插件系统） +# ══════════════════════════════════════════════ + + def save_conversation_by_mode(self, conversation: list, label: str = ""): + """根据模式保存对话""" + if self._memory_mode == self.MODE_COMPANION: + # 陪伴模式：自动保存到长期记忆 + self.auto_save_chat(conversation, label) + # 提取关键信息保存到MEMORY.md + self._extract_and_save_key_info(conversation) + elif self._memory_mode == self.MODE_WORK: + # 工作模式：自动保存聊天记录 + self.auto_save_chat(conversation, label) + + + def _extract_and_save_key_info(self, conversation: list): + """从对话中提取关键信息保存到MEMORY.md（陪伴模式专用）""" + # 这里可以添加AI提取关键信息的逻辑 + # 暂时简单实现：保存最后一条助手消息 + for msg in reversed(conversation): + if msg.get("role") == "assistant": + content = msg.get("content", "") + if content and len(content) > 20: + self.append_memory("对话记录", f"- {content[:200]}") + break + + + def load_context_by_mode(self, conversation: list) -> list: + """根据模式加载上下文""" + if self._memory_mode == self.MODE_COMPANION: + # 陪伴模式：加载长期记忆作为上下文 + memory_content = self.load_memory() + if memory_content: + context_msg = {"role": "system", "content": f"长期记忆：{memory_content}"} + return [context_msg] + conversation + return conversation + elif self._memory_mode == self.MODE_WORK: + # 工作模式：只返回当前对话 + return conversation + return conversation + +class Liugin: + """记忆系统插件 — AI 可读写记忆、搜索历史""" + + def __init__(self): + self.cli = None + self.memory = None + self.usage = """记忆系统工具使用方法： + +JSON格式示例： +{"action": "use_tool", "tool": "memory", "args": "write 今天完成了v5.2的开发"} - 写日记 +{"action": "use_tool", "tool": "memory", "args": "diary 用户偏好使用中文交流"} - AI观察日记 +{"action": "use_tool", "tool": "memory", "args": "remember 项目使用MIT协议"} - 记到长期记忆 +{"action": "use_tool", "tool": "memory", "args": "search 定时任务"} - 搜索所有记忆 +{"action": "use_tool", "tool": "memory", "args": "context"} - 查看记忆上下文 +{"action": "use_tool", "tool": "memory", "args": "diary_list"} - 列出日记 +{"action": "use_tool", "tool": "memory", "args": "diary_read 2026-04-27"} - 读日记 +{"action": "use_tool", "tool": "memory", "args": "chat_list"} - 列出聊天记录 +{"action": "use_tool", "tool": "memory", "args": "chat_search 关键词"} - 搜聊天记录 + +功能说明: +- write: 写当日日记 +- diary: AI 自己写观察日记 +- remember: 写入 MEMORY.md 长期记忆 +- search: 全局关键词搜索（日记+记忆+聊天记录） +- context: 查看当前注入的上下文 +- diary_list / diary_read: 管理日记 +- chat_list / chat_search: 管理聊天记录""" + + def set_cli(self, cli): + self.cli = cli + project_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) + self.memory = MemoryManager(project_dir) + # 挂载到 cli 实例上供其他模块使用 + cli.memory_manager = self.memory + # 注册命令 + self.cli.register_liugin_command('memory', self.command_handler) + + def command_handler(self, args): + return self.handle(args) + + def get_tool_info(self): + return { + "name": "memory", + "description": "持久化记忆系统。AI 可写日记、记录长期记忆、搜索历史记忆和聊天记录。支持关键词检索。", + "keywords": ["记忆", "memory", "日记", "diary", "搜索", "search", "历史", "history", "remember"], + "usage": self.usage + } + + def handle(self, args: str) -> str: + if not self.memory: + return "记忆系统未初始化" + return self.memory.handle_tool(args) + + def get_mcp_definition(self): + return { + "name": "memory", + "description": "持久化记忆系统", + "parameters": { + "type": "object", + "properties": { + "action": { + "type": "string", + "enum": ["write", "diary", "remember", "search", "context", + "diary_list", "diary_read", "chat_list", "chat_search"], + "description": "操作类型" + }, + "content": { + "type": "string", + "description": "内容/关键词" + } + }, + "required": ["action"] + } + } + # ══════════════════════════════════════════════ + # 模式特定的方法 + # ══════════════════════════════════════════════ + diff --git a/xcli_core/notification.py b/xcli_core/notification.py new file mode 100644 index 0000000..a521a28 --- /dev/null +++ b/xcli_core/notification.py @@ -0,0 +1,205 @@ +""" +跨平台系统通知模块 +当 AI 完成任务时，发送系统通知提醒用户 +支持 Windows / macOS / Linux +""" +import os +import sys +import subprocess +import threading +from typing import Optional + + +class NotificationManager: + """跨平台系统通知管理器""" + + def __init__(self): + self.enabled = True + self._platform = self._detect_platform() + self._last_title = "" + self._last_message = "" + self._cooldown_seconds = 2 # 防止重复通知的冷却时间 + self._last_notify_time = 0 + + @staticmethod + def _detect_platform() -> str: + """检测当前平台""" + if os.name == 'nt': + return 'windows' + elif sys.platform == 'darwin': + return 'macos' + else: + return 'linux' + + def set_enabled(self, enabled: bool): + """启用/禁用通知""" + self.enabled = enabled + + def notify(self, title: str, message: str, force: bool = False): + """ + 发送系统通知 + + Args: + title: 通知标题 + message: 通知内容 + force: 是否忽略冷却时间强制发送 + """ + if not self.enabled: + return + + # 防止重复通知 + import time + now = time.time() + if (not force and + title == self._last_title and + message == self._last_message and + now - self._last_notify_time < self._cooldown_seconds): + return + + self._last_title = title + self._last_message = message + self._last_notify_time = now + + # 在后台线程发送，不阻塞主流程 + thread = threading.Thread( + target=self._send_notification, + args=(title, message), + daemon=True + ) + thread.start() + + def notify_task_complete(self, task_summary: str = ""): + """通知任务完成的快捷方法""" + title = "小狸 Pro-CLI" + if task_summary: + # 截断过长的摘要 + if len(task_summary) > 80: + task_summary = task_summary[:77] + "..." + message = f"任务已完成: {task_summary}" + else: + message = "任务已完成 ✓" + + self.notify(title, message) + + def notify_tool_complete(self, tool_name: str, result_summary: str = ""): + """通知工具执行完成""" + title = "小狸 Pro-CLI" + if result_summary: + if len(result_summary) > 60: + result_summary = result_summary[:57] + "..." + message = f"{tool_name}: {result_summary}" + else: + message = f"{tool_name} 执行完成 ✓" + + self.notify(title, message) + + # ── 平台实现 ── + + def _send_notification(self, title: str, message: str): + """根据平台发送通知""" + try: + if self._platform == 'windows': + self._notify_windows(title, message) + elif self._platform == 'macos': + self._notify_macos(title, message) + else: + self._notify_linux(title, message) + except Exception: + # 通知失败不应影响正常流程 + pass + + def _notify_windows(self, title: str, message: str): + """Windows 通知 — 使用 PowerShell（win10toast 在 Python 3.12+ 上不兼容）""" + # 方法1: PowerShell BurntToast 模块 + try: + ps_script = f''' + [Windows.UI.Notifications.ToastNotificationManager, Windows.UI.Notifications, ContentType = WindowsRuntime] > $null + $template = [Windows.UI.Notifications.ToastNotificationManager]::GetTemplateContent([Windows.UI.Notifications.ToastTemplateType]::ToastText02) + $textNodes = $template.GetElementsByTagName("text") + $textNodes.Item(0).AppendChild($template.CreateTextNode("{title}")) > $null + $textNodes.Item(1).AppendChild($template.CreateTextNode("{message}")) > $null + $toast = [Windows.UI.Notifications.ToastNotification]::new($template) + [Windows.UI.Notifications.ToastNotificationManager]::CreateToastNotifier("{title}").Show($toast) + ''' + subprocess.run( + ["powershell", "-ExecutionPolicy", "Bypass", "-Command", ps_script], + capture_output=True, timeout=5 + ) + return + except Exception: + pass + + # 方法2: PowerShell 简单弹窗 (最后降级) + try: + escaped_msg = message.replace("'", "''") + escaped_title = title.replace("'", "''") + ps_cmd = ( + f"Add-Type -AssemblyName System.Windows.Forms; " + f"[System.Windows.Forms.MessageBox]::Show('{escaped_msg}', '{escaped_title}')" + ) + subprocess.run( + ["powershell", "-Command", ps_cmd], + capture_output=True, timeout=5 + ) + except Exception: + pass + + def _notify_macos(self, title: str, message: str): + """macOS 通知 — 使用 osascript""" + escaped_title = title.replace('"', '\\"') + escaped_message = message.replace('"', '\\"') + script = f'display notification "{escaped_message}" with title "{escaped_title}"' + subprocess.run( + ["osascript", "-e", script], + capture_output=True, timeout=5 + ) + + def _notify_linux(self, title: str, message: str): + """Linux 通知 — 优先 notify-send，降级到 D-Bus""" + # 方法1: notify-send (libnotify) + try: + subprocess.run( + ["notify-send", title, message, "-i", "dialog-information", "-t", "3000"], + capture_output=True, timeout=5 + ) + return + except FileNotFoundError: + pass + + # 方法2: D-Bus 直接调用 + try: + dbus_script = f''' +import dbus +bus = dbus.SessionBus() +notify_obj = bus.get_object('org.freedesktop.Notifications', '/org/freedesktop/Notifications') +notify_iface = dbus.Interface(notify_obj, 'org.freedesktop.Notifications') +notify_iface.Notify('xiaoli-cli', 0, 'dialog-information', '{title}', '{message}', [], {{}}, 3000) +''' + subprocess.run( + [sys.executable, "-c", dbus_script], + capture_output=True, timeout=5 + ) + except Exception: + pass + + +# ── 全局单例 ── +_notification_manager = None + + +def get_notification_manager() -> NotificationManager: + """获取全局通知管理器单例""" + global _notification_manager + if _notification_manager is None: + _notification_manager = NotificationManager() + return _notification_manager + + +def notify_task_complete(task_summary: str = ""): + """快捷函数：通知任务完成""" + get_notification_manager().notify_task_complete(task_summary) + + +def notify_tool_complete(tool_name: str, result_summary: str = ""): + """快捷函数：通知工具执行完成""" + get_notification_manager().notify_tool_complete(tool_name, result_summary) diff --git a/xcli_core/tool_result.py b/xcli_core/tool_result.py new file mode 100644 index 0000000..0d507a3 --- /dev/null +++ b/xcli_core/tool_result.py @@ -0,0 +1,119 @@ +""" +统一工具返回格式 - ToolResult + +所有插件和工具管理器使用统一的返回格式， +替代原来混乱的字符串/Dict 返回。 +""" + +from dataclasses import dataclass, field +from typing import Any, Optional + + +# 错误码常量 +class ErrorCode: + """工具错误码""" + SUCCESS = 0 + # 参数错误 (1xx) + MISSING_ARGS = 100 + INVALID_ARGS = 101 + UNSUPPORTED_OP = 102 + # 资源错误 (2xx) + NOT_FOUND = 200 + FILE_NOT_FOUND = 201 + PERMISSION_DENIED = 202 + # 执行错误 (3xx) + EXEC_FAILED = 300 + TIMEOUT = 301 + DECODE_ERROR = 302 + # 系统错误 (4xx) + INTERNAL_ERROR = 400 + NOT_IMPLEMENTED = 401 + + _NAMES = { + 0: "成功", + 100: "缺少参数", + 101: "参数无效", + 102: "不支持的操作", + 200: "未找到", + 201: "文件不存在", + 202: "权限不足", + 300: "执行失败", + 301: "超时", + 302: "解码错误", + 400: "内部错误", + 401: "未实现", + } + + @classmethod + def name(cls, code: int) -> str: + return cls._NAMES.get(code, f"未知({code})") + + +@dataclass +class ToolResult: + """统一工具返回格式""" + + success: bool + data: Any = None + error_code: int = ErrorCode.SUCCESS + error_message: str = "" + + # 可选元数据 + tool_name: str = "" + execution_time: float = 0.0 + metadata: dict = field(default_factory=dict) + + def __str__(self) -> str: + if self.success: + return str(self.data) if self.data is not None else "执行完成" + return f"[{ErrorCode.name(self.error_code)}] {self.error_message}" + + # ── 便捷构造方法 ── + + @classmethod + def ok(cls, data: Any = None, **kwargs) -> "ToolResult": + """成功""" + return cls(success=True, data=data, **kwargs) + + @classmethod + def fail(cls, message: str, code: int = ErrorCode.EXEC_FAILED, **kwargs) -> "ToolResult": + """失败""" + return cls(success=False, error_code=code, error_message=message, **kwargs) + + @classmethod + def missing(cls, what: str = "参数", **kwargs) -> "ToolResult": + """缺少参数""" + return cls.fail(f"缺少{what}", ErrorCode.MISSING_ARGS, **kwargs) + + @classmethod + def not_found(cls, what: str = "资源", **kwargs) -> "ToolResult": + """未找到""" + return cls.fail(f"{what}不存在", ErrorCode.NOT_FOUND, **kwargs) + + @classmethod + def timeout(cls, seconds: int = 0, **kwargs) -> "ToolResult": + """超时""" + msg = f"执行超时" + if seconds: + msg += f" ({seconds}秒)" + return cls.fail(msg, ErrorCode.TIMEOUT, **kwargs) + + # ── 格式转换 ── + + def to_dict(self) -> dict: + """转为普通 dict（兼容旧接口）""" + if self.success: + return {"result": self.data if self.data is not None else "执行完成"} + return {"result": str(self)} + + def to_mcp(self) -> dict: + """转为 MCP 协议格式""" + text = str(self) + return { + "content": [{"type": "text", "text": text}], + "isError": not self.success, + } + + def to_string(self) -> str: + """转为字符串（兼容旧插件 handle() 返回值）""" + return str(self)