hermes-agent-evolution 3.0.0__py3-none-any.whl

evolution/__init__.py

@@ -0,0 +1,14 @@
+"""
+Hermes Agent Evolution - AI助手自我进化系统 V1/V2/V3 融合版
+
+架构：
+  - src/evolution/ — V1 单体模块 (记忆/学习/工具/安全/协作/闭环进化)
+  - src/services/   — V2 微服务层 (事件总线/服务管理/学习服务/工具服务)
+  - src/utils/      — 共享工具 (飞书通知/进度报告)
+  
+使AI助手能够从经验中学习并持续改进自身能力。
+"""
+
+__version__ = "3.0.0"
+__author__ = "HermesAgentEvolution Team"
+__description__ = "AI助手自我进化系统 - V1/V2/V3融合版"

evolution/cli.py

@@ -0,0 +1,252 @@
+"""
+HermesAgentEvolution CLI — 命令行工具
+
+用法:
+    python3 -m src.evolution.cli check     # 环境自检
+    python3 -m src.evolution.cli setup     # 一键部署到 Hermes
+    python3 -m src.evolution.cli status    # 查看系统状态
+    python3 -m src.evolution.cli test      # 运行自测
+"""
+
+import sys
+import os
+from pathlib import Path
+
+# 确保项目根在 sys.path
+_project_root = Path(__file__).resolve().parent.parent.parent
+if str(_project_root) not in sys.path:
+    sys.path.insert(0, str(_project_root))
+
+
+def _add_src_to_path():
+    """确保 src/ 可导入"""
+    src_dir = Path(__file__).resolve().parent.parent
+    if str(src_dir) not in sys.path:
+        sys.path.insert(0, str(src_dir))
+
+
+def cmd_check() -> bool:
+    """环境自检：Python版本、模块导入、DB连接、插件部署"""
+    _add_src_to_path()
+    
+    all_ok = True
+    results = []
+    
+    def _check(name: str, ok: bool, detail: str = ""):
+        nonlocal all_ok
+        if not ok:
+            all_ok = False
+        results.append((name, ok, detail))
+    
+    # 1. Python 版本
+    vi = sys.version_info
+    _check(
+        f"Python {vi.major}.{vi.minor}.{vi.micro} ≥ 3.9",
+        vi >= (3, 9),
+        f"当前 Python {vi.major}.{vi.minor}" if vi < (3, 9) else ""
+    )
+    
+    # 2. 核心模块导入
+    core_modules = [
+        ("evolution.tools.tool_registry", "工具注册表"),
+        ("evolution.learning.observer", "学习观察器"),
+        ("evolution.memory.database", "记忆数据库"),
+        ("evolution.security.audit_logger", "安全审计"),
+        ("evolution.collaboration.agent_orchestrator", "协作编排"),
+        ("evolution.closed_loop.orchestrator", "闭环编排"),
+        ("evolution.self_monitor", "自我监控"),
+        ("evolution.db_utils", "DB工具"),
+    ]
+    
+    for mod_name, desc in core_modules:
+        try:
+            __import__(mod_name)
+            _check(f"模块 {desc}", True)
+        except ImportError as e:
+            _check(f"模块 {desc}", False, str(e))
+    
+    # 3. DB 可读写
+    try:
+        from evolution.db_utils import get_evolution_db, close_all_connections
+        conn = get_evolution_db("_cli_check.db")
+        conn.execute("CREATE TABLE IF NOT EXISTS _check (id INTEGER)")
+        conn.execute("INSERT INTO _check VALUES (1)")
+        conn.execute("DROP TABLE _check")
+        conn.commit()
+        close_all_connections()
+        _check("DB 可读写", True)
+    except Exception as e:
+        _check("DB 可读写", False, str(e))
+    
+    # 4. Hermes 插件已部署
+    plugin_dir = Path.home() / ".hermes" / "plugins" / "hermes-evolution"
+    plugin_yaml = plugin_dir / "plugin.yaml"
+    _check(
+        "Hermes 插件已部署",
+        plugin_yaml.exists(),
+        f"未找到 {plugin_yaml}" if not plugin_yaml.exists() else ""
+    )
+    
+    # 5. 数据目录
+    from evolution.db_utils import _resolve_data_dir
+    data_dir = _resolve_data_dir()
+    _check(f"数据目录: {data_dir}", data_dir.exists())
+    
+    # 输出
+    print()
+    print("🔍 HermesAgentEvolution 环境自检")
+    print("=" * 50)
+    for name, ok, detail in results:
+        icon = "✅" if ok else "❌"
+        print(f"  {icon} {name}")
+        if detail:
+            print(f"     → {detail}")
+    print("=" * 50)
+    
+    if all_ok:
+        print("  🎉 环境就绪，可以正常使用")
+    else:
+        print("  ⚠️  存在异常，请根据上述提示修复")
+    
+    return all_ok
+
+
+def cmd_setup() -> bool:
+    """一键部署：复制插件到 ~/.hermes/plugins/"""
+    _add_src_to_path()
+    
+    project_root = Path(__file__).resolve().parent.parent.parent
+    plugin_src = project_root / "hermes-plugin"
+    plugin_dst = Path.home() / ".hermes" / "plugins" / "hermes-evolution"
+    
+    if not plugin_src.exists():
+        print(f"❌ 源目录不存在: {plugin_src}")
+        return False
+    
+    print("🚀 HermesAgentEvolution 插件部署")
+    print(f"   源: {plugin_src}")
+    print(f"   目标: {plugin_dst}")
+    
+    # 复制文件
+    import shutil
+    plugin_dst.mkdir(parents=True, exist_ok=True)
+    
+    for item in plugin_src.iterdir():
+        dst = plugin_dst / item.name
+        if item.is_file():
+            shutil.copy2(item, dst)
+        elif item.is_dir():
+            if dst.exists():
+                shutil.rmtree(dst)
+            shutil.copytree(item, dst)
+    
+    print(f"   ✅ 插件已部署")
+    
+    # 提示重启
+    print()
+    print("   ⚠️  请重启 Hermes Gateway 使插件生效:")
+    print("       hermes gateway restart")
+    
+    return True
+
+
+def cmd_status() -> bool:
+    """查看系统状态"""
+    _add_src_to_path()
+    
+    print("📊 HermesAgentEvolution 系统状态")
+    print("=" * 50)
+    
+    # 版本
+    try:
+        import re
+        pyproject = _project_root / "pyproject.toml"
+        content = pyproject.read_text()
+        m = re.search(r'version\s*=\s*"([^"]+)"', content)
+        version = m.group(1) if m else "unknown"
+        print(f"  版本: v{version}")
+    except Exception:
+        print(f"  版本: 无法读取")
+    
+    # 模块统计
+    try:
+        src_dir = _project_root / "src" / "evolution"
+        py_files = list(src_dir.rglob("*.py"))
+        total_lines = 0
+        for f in py_files:
+            total_lines += len(f.read_text().splitlines())
+        print(f"  模块: {len(py_files)} 文件")
+        print(f"  代码: {total_lines} 行")
+    except Exception as e:
+        print(f"  代码统计失败: {e}")
+    
+    # 测试状态
+    import subprocess
+    result = subprocess.run(
+        [sys.executable, "-m", "pytest", "tests/", "-q", "--tb=no"],
+        cwd=_project_root,
+        capture_output=True, text=True, timeout=60
+    )
+    print(f"  测试: {result.stdout.strip().splitlines()[-1] if result.stdout else '无法运行'}")
+    
+    # DB 统计
+    try:
+        from evolution.db_utils import get_data_dir, db_get_stats
+        data_dir = get_data_dir()
+        db_files = list(data_dir.glob("*.db"))
+        print(f"  DB文件: {len(db_files)} 个 ({data_dir})")
+        for db in db_files:
+            size_kb = db.stat().st_size / 1024
+            print(f"    - {db.name}: {size_kb:.1f} KB")
+    except Exception as e:
+        print(f"  DB统计失败: {e}")
+    
+    print("=" * 50)
+    return True
+
+
+def cmd_test() -> bool:
+    """运行自测"""
+    import subprocess
+    result = subprocess.run(
+        [sys.executable, "-m", "pytest", "tests/", "-q", "--tb=line"],
+        cwd=_project_root,
+        timeout=180
+    )
+    return result.returncode == 0
+
+
+# ── CLI 入口 ────────────────────────────────────────────────────────────────────
+
+COMMANDS = {
+    "check":  (cmd_check,  "环境自检"),
+    "setup":  (cmd_setup,  "一键部署到 Hermes"),
+    "status": (cmd_status, "查看系统状态"),
+    "test":   (cmd_test,   "运行自测"),
+}
+
+
+def main():
+    """CLI 主入口"""
+    if len(sys.argv) < 2 or sys.argv[1] in ("-h", "--help", "help"):
+        print("HermesAgentEvolution CLI v3.0.0")
+        print()
+        print("用法: python3 -m src.evolution.cli <命令>")
+        print()
+        for name, (_, desc) in COMMANDS.items():
+            print(f"  {name:<10s}  {desc}")
+        sys.exit(0)
+    
+    cmd = sys.argv[1]
+    if cmd not in COMMANDS:
+        print(f"❌ 未知命令: {cmd}")
+        print(f"   可用: {', '.join(COMMANDS.keys())}")
+        sys.exit(1)
+    
+    func, _ = COMMANDS[cmd]
+    success = func()
+    sys.exit(0 if success else 1)
+
+
+if __name__ == "__main__":
+    main()

evolution/closed_loop/__init__.py

@@ -0,0 +1,18 @@
+"""
+持续进化闭环模块 — HermesAgentEvolution Iteration 5
+实现完整的 Monitor → Analyze → Plan → Execute → Verify 闭环
+"""
+
+from .daemon import EvolutionDaemon, EvolutionPhase, LoopState
+from .orchestrator import ClosedLoopOrchestrator
+from .metrics_collector import SystemMetricsCollector
+from .action_executor import ActionExecutor
+
+__all__ = [
+    'EvolutionDaemon',
+    'EvolutionPhase', 
+    'LoopState',
+    'ClosedLoopOrchestrator',
+    'SystemMetricsCollector',
+    'ActionExecutor',
+]

evolution/closed_loop/action_executor.py

@@ -0,0 +1,355 @@
+"""
+ActionExecutor — 改进动作执行器
+负责将改进计划中的动作实际执行，产生真实效果
+
+支持的动作类型:
+- strategy_switch: 切换工具选择策略
+- tool_optimization: 优化工具参数/性能
+- parameter_tuning: 调整系统参数
+- tool_creation: 创建新工具
+- tool_deprecation: 废弃低效工具
+"""
+
+import logging
+from typing import Dict, Any, List, Optional
+from datetime import datetime
+
+logger = logging.getLogger(__name__)
+
+
+class ActionExecutor:
+    """
+    改进动作执行器
+    
+    接收改进动作定义，执行实际系统变更。
+    每个动作类型有对应的执行器方法。
+    
+    用法:
+        executor = ActionExecutor(strategy_learner, tool_engine, registry)
+        result = executor.execute(action)
+    """
+    
+    def __init__(self,
+                 strategy_learner=None,
+                 tool_evolution_engine=None,
+                 tool_registry=None,
+                 tool_performance_analyzer=None,
+                 pattern_recognizer=None,
+                 config: Optional[Dict[str, Any]] = None):
+        """
+        Args:
+            strategy_learner: 工具策略学习器
+            tool_evolution_engine: 工具进化引擎
+            tool_registry: 工具注册表
+            tool_performance_analyzer: 工具性能分析器
+            pattern_recognizer: 模式识别器
+            config: 配置
+        """
+        self.strategy_learner = strategy_learner
+        self.tool_evolution_engine = tool_evolution_engine
+        self.tool_registry = tool_registry
+        self.tool_performance_analyzer = tool_performance_analyzer
+        self.pattern_recognizer = pattern_recognizer
+        self.config = config or {}
+        
+        # 执行历史
+        self.execution_history: List[Dict[str, Any]] = []
+        
+        # 安全模式 — dry_run 时不执行实际变更
+        self.dry_run = self.config.get('dry_run', False)
+        
+        logger.info(f"ActionExecutor 初始化 (dry_run={self.dry_run})")
+    
+    def execute(self, action: 'ImprovementAction') -> Dict[str, Any]:
+        """
+        执行单个改进动作
+        
+        Args:
+            action: 改进动作
+            
+        Returns:
+            {'success': bool, 'message': str, 'output': dict}
+        """
+        logger.info(f"执行动作: {action.action_type} → {action.target} [{action.priority}]")
+        
+        handlers = {
+            'strategy_switch': self._execute_strategy_switch,
+            'tool_optimization': self._execute_tool_optimization,
+            'parameter_tuning': self._execute_parameter_tuning,
+            'tool_creation': self._execute_tool_creation,
+            'tool_deprecation': self._execute_tool_deprecation,
+        }
+        
+        handler = handlers.get(action.action_type)
+        if not handler:
+            return {
+                'success': False,
+                'message': f"未知动作类型: {action.action_type}",
+                'output': {},
+            }
+        
+        try:
+            if self.dry_run:
+                result = self._simulate_action(action)
+            else:
+                result = handler(action)
+            
+            # 记录历史
+            self.execution_history.append({
+                'timestamp': datetime.now().isoformat(),
+                'action': {
+                    'type': action.action_type,
+                    'target': action.target,
+                    'priority': action.priority,
+                },
+                'result': result,
+            })
+            
+            return result
+            
+        except Exception as e:
+            logger.error(f"执行动作失败 [{action.action_type}→{action.target}]: {e}")
+            return {
+                'success': False,
+                'message': str(e),
+                'output': {},
+            }
+    
+    # ═══════════════════════════════════════════
+    # 动作执行器
+    # ═══════════════════════════════════════════
+    
+    def _execute_strategy_switch(self, action: 'ImprovementAction') -> Dict[str, Any]:
+        """
+        切换工具选择策略
+        
+        当检测到当前策略表现不佳时，切换到更优策略
+        """
+        if not self.strategy_learner:
+            return {'success': False, 'message': '策略学习器未初始化', 'output': {}}
+        
+        try:
+            current = self.strategy_learner.get_current_strategy()
+            
+            # 通过记录模拟使用来触发策略自适应（内部会根据性能自动切换）
+            # 记录一些代表性的使用数据促使策略评估
+            sample_tools = ['terminal', 'read_file', 'write_file', 'search_files']
+            for tool in sample_tools:
+                self.strategy_learner.record_tool_usage(
+                    tool_name=tool,
+                    success=True,
+                    execution_time=0.5,
+                    context={'complexity': 0.3, 'source': 'strategy_switch'}
+                )
+            
+            new_strategy = self.strategy_learner.get_current_strategy()
+            changed = new_strategy != current
+            
+            return {
+                'success': True,
+                'message': (
+                    f"策略评估完成: {current.value} → {new_strategy.value}"
+                    if changed else
+                    f"策略保持 {current.value}（无需切换）"
+                ),
+                'output': {
+                    'previous_strategy': current.value,
+                    'new_strategy': new_strategy.value,
+                    'changed': changed,
+                },
+            }
+        except Exception as e:
+            return {'success': False, 'message': f"策略切换失败: {e}", 'output': {}}
+    
+    def _execute_tool_optimization(self, action: 'ImprovementAction') -> Dict[str, Any]:
+        """
+        优化工具性能
+        
+        通过工具进化引擎优化指定工具
+        """
+        if not self.tool_evolution_engine:
+            return {'success': False, 'message': '工具进化引擎未初始化', 'output': {}}
+        
+        try:
+            tool_name = action.parameters.get('tool_name', action.target)
+            
+            # 运行工具进化周期
+            result = self.tool_evolution_engine.run_evolution_cycle()
+            
+            # 检查是否对目标工具有改进
+            tool_optimized = any(
+                opt.get('tool_name') == tool_name
+                for opt in result.get('optimizations', [])
+            )
+            
+            return {
+                'success': result.get('success', False),
+                'message': (
+                    f"工具 '{tool_name}' 进化完成"
+                    if tool_optimized else
+                    f"工具 '{tool_name}' 当前不需要优化"
+                ),
+                'output': {
+                    'tool_name': tool_name,
+                    'evolution_success': result.get('success', False),
+                    'optimizations_count': len(result.get('optimizations', [])),
+                    'deprecated_count': len(result.get('deprecated_tools', [])),
+                },
+            }
+        except Exception as e:
+            return {'success': False, 'message': f"工具优化失败: {e}", 'output': {}}
+    
+    def _execute_parameter_tuning(self, action: 'ImprovementAction') -> Dict[str, Any]:
+        """
+        调整系统参数
+        
+        根据分析结果调整系统运行参数
+        """
+        params = action.parameters
+        changes = []
+        
+        # 调整探索率（如果策略学习器支持）
+        if self.strategy_learner and 'exploration_rate' in params:
+            try:
+                new_rate = params['exploration_rate']
+                if hasattr(self.strategy_learner, 'set_exploration_rate'):
+                    self.strategy_learner.set_exploration_rate(new_rate)
+                    changes.append(f"探索率 → {new_rate}")
+            except Exception as e:
+                logger.debug(f"调整探索率失败: {e}")
+        
+        # 调整性能阈值
+        if self.tool_evolution_engine and 'min_performance_score' in params:
+            try:
+                new_threshold = params['min_performance_score']
+                if hasattr(self.tool_evolution_engine, 'config'):
+                    old = self.tool_evolution_engine.config.min_performance_score
+                    self.tool_evolution_engine.config.min_performance_score = new_threshold
+                    changes.append(f"性能阈值 {old} → {new_threshold}")
+            except Exception as e:
+                logger.debug(f"调整性能阈值失败: {e}")
+        
+        if changes:
+            return {
+                'success': True,
+                'message': f"参数已调整: {', '.join(changes)}",
+                'output': {'changes': changes},
+            }
+        else:
+            return {
+                'success': True,
+                'message': '无可调参数（参数调优暂未实现）',
+                'output': {'changes': []},
+            }
+    
+    def _execute_tool_creation(self, action: 'ImprovementAction') -> Dict[str, Any]:
+        """
+        创建新工具
+        
+        根据需求描述自动生成新工具
+        """
+        if not self.tool_evolution_engine:
+            return {'success': False, 'message': '工具进化引擎未初始化', 'output': {}}
+        
+        try:
+            requirement = action.description
+            
+            result = self.tool_evolution_engine.auto_generate_tool(requirement)
+            
+            return {
+                'success': result.success if hasattr(result, 'success') else False,
+                'message': f"工具生成: {getattr(result, 'tool_name', 'unknown')}",
+                'output': {
+                    'tool_name': getattr(result, 'tool_name', ''),
+                    'success': getattr(result, 'success', False),
+                },
+            }
+        except Exception as e:
+            return {'success': False, 'message': f"工具创建失败: {e}", 'output': {}}
+    
+    def _execute_tool_deprecation(self, action: 'ImprovementAction') -> Dict[str, Any]:
+        """
+        废弃低效工具
+        
+        将使用率低、性能差的工具标记为废弃
+        """
+        if not self.tool_registry:
+            return {'success': False, 'message': '工具注册表未初始化', 'output': {}}
+        
+        try:
+            tool_name = action.parameters.get('tool_name', action.target)
+            
+            tool = self.tool_registry.get(tool_name)
+            if not tool:
+                return {'success': False, 'message': f"工具 '{tool_name}' 不存在", 'output': {}}
+            
+            # 标记为废弃
+            from ..tools.tool_registry import ToolStatus
+            tool.status = ToolStatus.DEPRECATED
+            self.tool_registry.register(tool)
+            
+            return {
+                'success': True,
+                'message': f"工具 '{tool_name}' 已标记为废弃",
+                'output': {'tool_name': tool_name},
+            }
+        except Exception as e:
+            return {'success': False, 'message': f"工具废弃失败: {e}", 'output': {}}
+    
+    # ═══════════════════════════════════════════
+    # Dry Run 模式
+    # ═══════════════════════════════════════════
+    
+    def _simulate_action(self, action: 'ImprovementAction') -> Dict[str, Any]:
+        """模拟执行（不对系统做任何实际变更）"""
+        return {
+            'success': True,
+            'message': f"[DRY-RUN] 将执行: {action.action_type} → {action.target}",
+            'output': {
+                'simulated': True,
+                'action_type': action.action_type,
+                'target': action.target,
+                'priority': action.priority,
+                'expected_benefit': action.expected_benefit,
+                'risk': action.risk,
+            },
+        }
+    
+    # ═══════════════════════════════════════════
+    # 便捷方法
+    # ═══════════════════════════════════════════
+    
+    def execute_batch(self, actions: List['ImprovementAction']) -> List[Dict[str, Any]]:
+        """
+        批量执行动作
+        
+        Args:
+            actions: 动作列表
+            
+        Returns:
+            执行结果列表
+        """
+        results = []
+        for action in actions:
+            result = self.execute(action)
+            results.append(result)
+        return results
+    
+    def get_execution_stats(self) -> Dict[str, Any]:
+        """获取执行统计"""
+        total = len(self.execution_history)
+        if total == 0:
+            return {'total': 0}
+        
+        success_count = sum(
+            1 for r in self.execution_history
+            if r.get('result', {}).get('success', False)
+        )
+        
+        return {
+            'total_executions': total,
+            'success_count': success_count,
+            'failure_count': total - success_count,
+            'success_rate': f"{success_count/total:.1%}",
+            'last_execution': self.execution_history[-1]['timestamp'] if self.execution_history else None,
+        }