@huajiwuyan/hello 3.0.0

package/templates/codex/skills/rlm/repl.py

@@ -0,0 +1,452 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+HelloAGENTS-RLM REPL Environment
+递归语言模型REPL环境
+
+基于MIT RLM设计:
+- Python REPL环境
+- 递归自调用
+- 外部数据存储
+- 工具执行
+"""
+
+import asyncio
+import json
+import sys
+from dataclasses import dataclass, field
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Callable, Dict, List, Optional
+
+from .engine import RLMEngine, RLMMode, AgentResult
+from .context_manager import ContextManager, ContextEvent
+from .folding import ContextFolder, Trajectory, FoldingStrategy
+
+
+@dataclass
+class REPLState:
+    """REPL状态"""
+    turn: int = 0
+    answer: Dict[str, Any] = field(default_factory=lambda: {"content": "", "ready": False})
+    variables: Dict[str, Any] = field(default_factory=dict)
+    history: List[Dict[str, Any]] = field(default_factory=list)
+
+
+class RLMREPL:
+    """
+    RLM REPL环境
+
+    提供类似MIT RLM的编程环境:
+    - rlm.peek(): 查看外部数据片段
+    - rlm.store(): 存储数据
+    - rlm.fold(): 折叠子轨迹
+    - rlm.spawn_agent(): 递归调用子Agent
+    - rlm.batch(): 并行执行
+    - rlm.answer: 渐进式输出
+    """
+
+    def __init__(
+        self,
+        mode: RLMMode = RLMMode.ACTIVE,
+        working_dir: Optional[Path] = None,
+    ):
+        self.engine = RLMEngine(mode=mode)
+        self.context = ContextManager()
+        self.folder = ContextFolder()
+        self.state = REPLState()
+        self.working_dir = working_dir or Path.cwd()
+
+    # ==================== REPL核心API ====================
+
+    def peek(self, data_key: str, start: int = 0, end: int = 1000) -> str:
+        """
+        查看外部存储的数据片段
+
+        Args:
+            data_key: 数据键名 (文件路径或变量名)
+            start: 起始位置
+            end: 结束位置
+
+        Returns:
+            数据片段
+        """
+        # 首先检查变量
+        if data_key in self.state.variables:
+            data = str(self.state.variables[data_key])
+            return data[start:end]
+
+        # 尝试作为文件路径
+        file_path = self._resolve_path(data_key)
+        if file_path and file_path.exists():
+            try:
+                content = file_path.read_text(encoding='utf-8')
+                return content[start:end]
+            except Exception as e:
+                return f"[ERROR] 读取文件失败: {e}"
+
+        # 使用engine的peek
+        return self.engine.peek(data_key, start, end)
+
+    def store(self, key: str, data: Any, persist: bool = False) -> bool:
+        """
+        存储数据
+
+        Args:
+            key: 键名
+            data: 数据
+            persist: 是否持久化
+
+        Returns:
+            是否成功
+        """
+        # 存储到变量
+        self.state.variables[key] = data
+
+        # 持久化
+        if persist:
+            return self.engine.store(key, str(data), persist=True)
+
+        return True
+
+    def fold(
+        self,
+        content: str,
+        strategy: str = "balanced",
+        custom_prompt: Optional[str] = None,
+    ) -> str:
+        """
+        折叠内容生成摘要
+
+        Args:
+            content: 要折叠的内容
+            strategy: 策略 (aggressive | balanced | conservative)
+            custom_prompt: 自定义摘要提示
+
+        Returns:
+            摘要
+        """
+        strategy_map = {
+            "aggressive": FoldingStrategy.AGGRESSIVE,
+            "balanced": FoldingStrategy.BALANCED,
+            "conservative": FoldingStrategy.CONSERVATIVE,
+        }
+
+        trajectory = Trajectory(
+            trajectory_id=f"repl_fold_{self.state.turn}",
+            content=content,
+        )
+
+        result = self.folder.fold(
+            trajectory=trajectory,
+            strategy=strategy_map.get(strategy, FoldingStrategy.BALANCED),
+            custom_prompt=custom_prompt,
+        )
+
+        return result.summary
+
+    async def spawn_agent(
+        self,
+        role: str,
+        task: str,
+        context_hint: Optional[List[str]] = None,
+        timeout: int = 120,
+    ) -> AgentResult:
+        """
+        创建子Agent
+
+        Args:
+            role: 角色 (explorer | analyzer | implementer | reviewer | tester | synthesizer)
+            task: 任务描述
+            context_hint: 上下文提示
+            timeout: 超时时间
+
+        Returns:
+            Agent结果
+        """
+        # 记录到历史
+        self._record_action("spawn_agent", {
+            "role": role,
+            "task": task[:100],
+        })
+
+        result = await self.engine.spawn_agent(
+            role=role,
+            task=task,
+            context_hint=context_hint,
+            timeout=timeout,
+        )
+
+        # 记录结果
+        self._record_action("agent_result", {
+            "role": role,
+            "status": result.status,
+            "findings_count": len(result.key_findings),
+        })
+
+        return result
+
+    async def batch(self, tasks: List[Dict[str, Any]]) -> List[AgentResult]:
+        """
+        并行执行多个Agent
+
+        Args:
+            tasks: 任务列表 [{role, task, context_hint}]
+
+        Returns:
+            结果列表
+        """
+        self._record_action("batch", {"count": len(tasks)})
+
+        results = await self.engine.batch(tasks)
+
+        return results
+
+    def merge(self, results: List[AgentResult], strategy: str = "synthesize") -> str:
+        """
+        合并多个Agent结果
+
+        Args:
+            results: 结果列表
+            strategy: 合并策略 (concat | synthesize | vote)
+
+        Returns:
+            合并后的内容
+        """
+        return self.engine.merge(results, strategy=strategy)
+
+    # ==================== Answer管理 ====================
+
+    def set_answer(self, content: str, ready: bool = False):
+        """
+        设置answer (渐进式输出)
+
+        Args:
+            content: 内容
+            ready: 是否完成
+        """
+        self.state.answer["content"] = content
+        self.state.answer["ready"] = ready
+
+    def append_answer(self, content: str):
+        """追加内容到answer"""
+        self.state.answer["content"] += content
+
+    def get_answer(self) -> Dict[str, Any]:
+        """获取answer"""
+        return self.state.answer.copy()
+
+    def finalize_answer(self):
+        """标记answer完成"""
+        self.state.answer["ready"] = True
+
+    # ==================== 上下文管理 ====================
+
+    def load_context(self, key: str) -> Optional[str]:
+        """加载上下文 (从知识库)"""
+        return self.context.load_memory(key)
+
+    def save_context(self, key: str, content: str) -> bool:
+        """保存上下文 (到知识库)"""
+        return self.context.save_memory(key, content)
+
+    def get_working_context(self) -> List[Dict[str, Any]]:
+        """获取工作上下文"""
+        return self.context.get_working_context()
+
+    def add_to_context(self, event_type: str, content: Any):
+        """添加到上下文"""
+        event = ContextEvent(event_type=event_type, content=content)
+        self.context.add_to_working(event)
+
+    # ==================== 执行控制 ====================
+
+    async def execute(self, instruction: str) -> Dict[str, Any]:
+        """
+        执行指令
+
+        Args:
+            instruction: 指令 (自然语言或特殊命令)
+
+        Returns:
+            执行结果
+        """
+        self.state.turn += 1
+
+        # 记录
+        self._record_action("execute", {"instruction": instruction[:200]})
+
+        # 解析指令
+        if instruction.startswith("peek:"):
+            # peek:key:start:end
+            parts = instruction.split(":")
+            key = parts[1] if len(parts) > 1 else ""
+            start = int(parts[2]) if len(parts) > 2 else 0
+            end = int(parts[3]) if len(parts) > 3 else 1000
+            result = self.peek(key, start, end)
+            return {"type": "peek", "result": result}
+
+        elif instruction.startswith("store:"):
+            # store:key:value
+            parts = instruction.split(":", 2)
+            key = parts[1] if len(parts) > 1 else "temp"
+            value = parts[2] if len(parts) > 2 else ""
+            success = self.store(key, value)
+            return {"type": "store", "success": success}
+
+        elif instruction.startswith("fold:"):
+            # fold:content
+            content = instruction[5:]
+            summary = self.fold(content)
+            return {"type": "fold", "summary": summary}
+
+        elif instruction.startswith("spawn:"):
+            # spawn:role:task
+            parts = instruction.split(":", 2)
+            role = parts[1] if len(parts) > 1 else "explorer"
+            task = parts[2] if len(parts) > 2 else ""
+            result = await self.spawn_agent(role, task)
+            return {"type": "spawn", "result": result.to_dict()}
+
+        else:
+            # 默认: 分析指令
+            result = await self.spawn_agent(
+                role="analyzer",
+                task=instruction,
+            )
+            self.set_answer(result.to_summary(), ready=True)
+            return {"type": "analyze", "result": result.to_dict()}
+
+    def run_sync(self, instruction: str) -> Dict[str, Any]:
+        """同步执行"""
+        return asyncio.run(self.execute(instruction))
+
+    # ==================== 状态管理 ====================
+
+    def get_status(self) -> Dict[str, Any]:
+        """获取REPL状态"""
+        return {
+            "turn": self.state.turn,
+            "answer_ready": self.state.answer["ready"],
+            "variables_count": len(self.state.variables),
+            "history_count": len(self.state.history),
+            "engine_status": self.engine.get_status(),
+            "context_status": self.context.get_status(),
+        }
+
+    def get_history(self, limit: int = 10) -> List[Dict[str, Any]]:
+        """获取历史"""
+        return self.state.history[-limit:]
+
+    def reset(self):
+        """重置REPL"""
+        self.state = REPLState()
+        self.engine.reset()
+        self.context.reset()
+
+    # ==================== 内部方法 ====================
+
+    def _resolve_path(self, path_str: str) -> Optional[Path]:
+        """解析路径"""
+        path = Path(path_str)
+        if path.is_absolute():
+            return path
+        return self.working_dir / path
+
+    def _record_action(self, action_type: str, details: Dict[str, Any]):
+        """记录动作"""
+        self.state.history.append({
+            "turn": self.state.turn,
+            "action": action_type,
+            "details": details,
+            "timestamp": datetime.now().isoformat(),
+        })
+
+
+# ==================== 交互式REPL ====================
+
+async def interactive_repl():
+    """交互式REPL循环"""
+    print("HelloAGENTS-RLM REPL v1.0.0")
+    print("输入 'help' 查看帮助, 'exit' 退出")
+    print("-" * 40)
+
+    repl = RLMREPL()
+
+    while True:
+        try:
+            user_input = input(f"\n[{repl.state.turn}] >>> ").strip()
+
+            if not user_input:
+                continue
+
+            if user_input.lower() in ('exit', 'quit', 'q'):
+                print("再见!")
+                break
+
+            if user_input.lower() == 'help':
+                print("""
+可用命令:
+  peek:key:start:end  - 查看数据片段
+  store:key:value     - 存储数据
+  fold:content        - 折叠内容
+  spawn:role:task     - 创建子Agent
+  status              - 查看状态
+  history             - 查看历史
+  reset               - 重置
+  exit                - 退出
+
+直接输入其他内容将作为分析任务执行
+                """)
+                continue
+
+            if user_input.lower() == 'status':
+                print(json.dumps(repl.get_status(), ensure_ascii=False, indent=2))
+                continue
+
+            if user_input.lower() == 'history':
+                for item in repl.get_history():
+                    print(f"  [{item['turn']}] {item['action']}: {item['details']}")
+                continue
+
+            if user_input.lower() == 'reset':
+                repl.reset()
+                print("已重置")
+                continue
+
+            # 执行
+            result = await repl.execute(user_input)
+            print(json.dumps(result, ensure_ascii=False, indent=2, default=str))
+
+        except KeyboardInterrupt:
+            print("\n按Ctrl+C退出")
+        except EOFError:
+            break
+        except Exception as e:
+            print(f"错误: {e}")
+
+
+# ==================== CLI入口 ====================
+
+if __name__ == "__main__":
+    import argparse
+
+    parser = argparse.ArgumentParser(description="HelloAGENTS-RLM REPL")
+    parser.add_argument("--interactive", "-i", action="store_true", help="交互式模式")
+    parser.add_argument("--execute", "-e", type=str, help="执行指令")
+    parser.add_argument("--status", action="store_true", help="显示状态")
+
+    args = parser.parse_args()
+
+    if args.interactive:
+        asyncio.run(interactive_repl())
+    elif args.execute:
+        repl = RLMREPL()
+        result = repl.run_sync(args.execute)
+        print(json.dumps(result, ensure_ascii=False, indent=2, default=str))
+    elif args.status:
+        repl = RLMREPL()
+        print(json.dumps(repl.get_status(), ensure_ascii=False, indent=2))
+    else:
+        print("HelloAGENTS-RLM REPL v1.0.0")
+        print("使用 --help 查看帮助, -i 进入交互模式")

package/templates/codex/skills/rlm/roles/analyzer.md

@@ -0,0 +1,66 @@
+# Analyzer 角色预设
+
+你是一个**深度分析专家**，专注于理解代码逻辑、架构设计和潜在问题。
+
+## 核心能力
+
+- 分析代码结构和设计模式
+- 理解业务逻辑和数据流
+- 识别潜在的性能瓶颈
+- 发现安全风险和代码异味
+- 评估技术债务
+
+## 工作原则
+
+1. **深入理解**: 不止于表面，追溯调用链和依赖关系
+2. **多角度分析**: 考虑性能、安全、可维护性等多个维度
+3. **证据支撑**: 每个结论都要有代码引用支持
+4. **可操作建议**: 提供具体、可执行的改进建议
+
+## 分析框架
+
+### 代码质量
+- 复杂度 (圈复杂度、认知复杂度)
+- 重复代码
+- 命名规范
+- 注释质量
+
+### 架构设计
+- 模块耦合度
+- 职责分离
+- 依赖方向
+- 扩展性
+
+### 安全性
+- 输入验证
+- 认证授权
+- 数据保护
+- 常见漏洞 (OWASP Top 10)
+
+## 输出格式
+
+```json
+{
+  "status": "completed",
+  "key_findings": [
+    "架构模式: ...",
+    "核心逻辑: ...",
+    "依赖关系: ..."
+  ],
+  "changes_made": [],
+  "issues_found": [
+    {"severity": "high|medium|low", "description": "...", "location": "file:line"}
+  ],
+  "recommendations": [
+    "优化建议: ...",
+    "重构建议: ..."
+  ]
+}
+```
+
+## 典型任务
+
+- "分析用户认证模块的实现"
+- "评估API的安全性"
+- "识别性能瓶颈"
+- "分析数据库查询效率"

package/templates/codex/skills/rlm/roles/designer.md

@@ -0,0 +1,94 @@
+# Designer 角色预设
+
+你是一个**方案设计专家**，专注于技术方案设计、任务分解和风险评估。
+
+## 核心能力
+
+- 设计清晰、可执行的技术方案
+- 合理分解任务并估算复杂度
+- 识别技术风险和依赖关系
+- 平衡技术优雅与实现成本
+- 制定验收标准和测试策略
+
+## 工作原则
+
+1. **目标导向**: 方案直接服务于需求目标，不过度设计
+2. **可执行性**: 任务拆分具体、可执行、可验证
+3. **风险预判**: 提前识别技术风险，准备应对方案
+4. **约束尊重**: 遵循现有架构和代码风格
+
+## 设计框架
+
+### 方案设计
+
+- 技术路径选择及理由
+- 影响范围分析
+- 与现有系统的集成方式
+- 数据模型/API 设计（如适用）
+
+### 任务分解
+
+- 按逻辑顺序分解任务
+- 标注任务间的依赖关系
+- 识别可并行执行的任务
+- 预估任务复杂度（简单/中等/复杂）
+
+### 风险评估
+
+- 技术风险（兼容性、性能等）
+- 实现风险（复杂度、依赖等）
+- EHRB 风险检测（按 G2 规则）
+
+### 验收标准
+
+- 功能验收点
+- 测试策略建议
+- 边界条件和异常处理
+
+## 输出格式
+
+```json
+{
+  "status": "completed",
+  "key_findings": [
+    "技术路径: ...",
+    "核心变更: ...",
+    "影响范围: ..."
+  ],
+  "changes_made": [],
+  "issues_found": [
+    {"severity": "high|medium|low", "description": "...", "category": "risk|constraint|dependency"}
+  ],
+  "recommendations": [
+    "方案建议: ...",
+    "实现注意: ..."
+  ],
+  "task_breakdown": [
+    {"id": 1, "description": "...", "complexity": "simple|medium|complex", "depends_on": []},
+    {"id": 2, "description": "...", "complexity": "...", "depends_on": [1]}
+  ]
+}
+```
+
+## 典型任务
+
+- "设计用户登录功能的实现方案"
+- "规划数据库迁移的执行步骤"
+- "制定 API 版本升级的任务清单"
+- "评估新功能的技术可行性"
+
+## 与其他角色的协作
+
+```yaml
+与 analyzer 的区别:
+  - analyzer: 分析现有代码，发现问题
+  - designer: 设计新方案，规划实现
+
+与 implementer 的协作:
+  - designer 输出 task_breakdown
+  - implementer 按任务清单执行代码修改
+
+调用场景:
+  - DESIGN 阶段轻量迭代: 单方案设计
+  - 复杂任务: 与 analyzer 并行，analyzer 分析可行性，designer 设计方案
+```

package/templates/codex/skills/rlm/roles/explorer.md

@@ -0,0 +1,43 @@
+# Explorer 角色预设
+
+你是一个**代码库探索专家**，专注于高效地收集和整理项目上下文信息。
+
+## 核心能力
+
+- 快速扫描目录结构，识别关键文件
+- 识别项目类型、技术栈、框架
+- 提取核心模块和入口点
+- 发现配置文件和依赖关系
+
+## 工作原则
+
+1. **只读操作**: 仅进行读取和搜索，不修改任何文件
+2. **结构化输出**: 以清晰的层次结构呈现发现
+3. **关注重点**: 优先识别核心代码，忽略生成文件和依赖
+4. **效率优先**: 使用glob和grep快速定位，避免逐文件读取
+
+## 输出格式
+
+```json
+{
+  "status": "completed",
+  "key_findings": [
+    "项目类型: ...",
+    "主要技术栈: ...",
+    "入口文件: ...",
+    "核心模块: ..."
+  ],
+  "changes_made": [],
+  "issues_found": [],
+  "recommendations": [
+    "建议深入分析: ..."
+  ]
+}
+```
+
+## 典型任务
+
+- "探索src/目录的结构"
+- "识别项目使用的框架和依赖"
+- "找出所有API端点定义"
+- "列出配置文件和环境变量"