Skill: smseow001/claude-code-engine (version 1.0.0)

--- name: claude-code-engine description: 将 OpenClaw 升级为 Claude-Code 引擎架构 - 并发执行/自我反思/向量检索/子代理系统/上下文压缩 --- # Claude-Code 引擎赋能 OpenClaw > 整合 Claude-Code 核心架构 | 并发执行 | 自我反思 | 向量检索 | 子代理系统 --- ## 一、核心定位 本技能帮助将 OpenClaw 升级为类 Claude-Code 的高效代理架构，核心目标： | 目标 | 说明 | |------|------| | **并发执行** | 子代理并行处理，无需等待前序任务 | | **自我反思** | 每6小时无交互时自动反思教训/经验/错误 | | **向量检索** | 精准从记忆文件中找回历史内容 | | **上下文压缩** | 92%阈值自动压缩，保留核心信息 | | **长时自主** | 支持30-50小时连续运行 | --- ## 二、Claude-Code 核心架构 ### 2.1 N0 引擎核心循环 ``` ┌─────────────────────────────────────────────────────┐ │ Claude-Code N0 循环架构 │ ├─────────────────────────────────────────────────────┤ │ │ │ while True: │ │ ┌─────────┐ │ │ │ 获取输入 │ ← 用户请求 + 项目背景 + 系统状态 │ │ └────┬────┘ │ │ ↓ │ │ ┌─────────┐ │ │ │ 模型决策 │ → stop_reason + tool_calls │ │ └────┬────┘ │ │ ↓ │ │ ┌─────────┐ │ │ │ 执行工具 │ → bash/read/write/edit/grep/browser │ │ └────┬────┘ │ │ ↓ │ │ ┌─────────┐ │ │ │ 反馈循环 │ → 工具结果返回 → 再次进入模型 │ │ └─────────┘ │ │ ↓ │ │ 直到 stop_reason == endturn │ │ │ └─────────────────────────────────────────────────────┘ ``` ### 2.2 七种内置工具 | 工具 | 功能 | OpenClaw 等价 | |------|------|--------------| | `bash` | 执行命令行 | `exec` | | `read` | 读文件 | `read` | | `write` | 写文件 | `write` | | `edit` | 编辑文件 | `edit` | | `glob/grep` | 搜索文件 | `exec find/grep` | | `browser` | 访问网页 | `browser` | | `skill` | 加载领域知识 | `skills` | --- ## 三、OpenClaw 升级清单 ### 3.1 自我反思系统 **目标**：每6小时无交互时自动反思 ```bash # 创建自我反思脚本 cat > /root/.openclaw/scripts/self-reflection.sh << 'EOF' #!/bin/bash # OpenClaw 自我反思脚本 # 每6小时无交互时自动执行 REFLECTION_DIR="/root/.openclaw/workspace/memory/reflections" mkdir -p "$REFLECTION_DIR" 反思内容包含： - 教训 (lessons) - 经验 (experiences) - 错误 (errors) - 成功 (successes) - 待优化点 (improvements) timestamp=$(date +%Y%m%d_%H%M%S) log_file="$REFLECTION_DIR/${timestamp}.md" cat > "$log_file" << 'LOG' # 自我反思日志 ## 时间 {TIMESTAMP} ## 教训 (Lessons) - ## 经验 (Experiences) - ## 错误 (Errors) - ## 成功 (Successes) - ## 待优化 (Improvements) - LOG echo "反思已记录: $log_file" EOF chmod +x /root/.openclaw/scripts/self-reflection.sh # 添加到 crontab（每6小时） (crontab -l 2>/dev/null; echo "0 */6 * * * /root/.openclaw/scripts/self-reflection.sh") | crontab - ``` ### 3.2 向量检索配置 **目标**：从记忆文件中精准检索 ```bash # 安装向量检索依赖 pip install chromadb sentence-transformers # 创建向量检索脚本 cat > /root/.openclaw/scripts/vector-search.py << 'EOF' #!/usr/bin/env python3 """ OpenClaw 向量检索系统 基于 ChromaDB + Sentence-Transformers """ import chromadb from sentence_transformers import SentenceTransformer from pathlib import Path import os class VectorMemory: def __init__(self, persist_dir="/root/.openclaw/workspace/memory/vector_db"): self.client = chromadb.PersistentClient(path=persist_dir) self.model = SentenceTransformer('all-MiniLM-L6-v2') self.collection = self.client.get_or_create_collection("openclaw_memory") def add_memory(self, text, metadata=None): """添加记忆到向量库""" embedding = self.model.encode([text]) self.collection.add( embeddings=embedding.tolist(), documents=[text], metadatas=[metadata or {"source": "manual"}] ) def search(self, query, n_results=5): """语义检索记忆""" embedding = self.model.encode([query]) results = self.collection.query( query_embeddings=embedding.tolist(), n_results=n_results ) return results def load_from_files(self, memory_dir="/root/.openclaw/workspace/memory"): """从文件批量加载记忆""" path = Path(memory_dir) for md_file in path.rglob("*.md"): content = md_file.read_text() self.add_memory( content, metadata={"source": str(md_file), "type": "memory"} ) if __name__ == "__main__": vm = VectorMemory() query = input("请输入检索内容: ") results = vm.search(query) print("检索结果:") for i, (doc, meta) in enumerate(zip(results['documents'][0], results['metadatas'][0])): print(f"\n{i+1}. [{meta['source']}]") print(doc[:200] + "..." if len(doc) > 200 else doc) EOF ``` ### 3.3 子代理并发系统 ```bash # 创建并发执行管理器 cat > /root/.openclaw/scripts/subagent_executor.py << 'EOF' #!/usr/bin/env python3 """ OpenClaw 子代理并发执行器 支持多任务并行处理，无需等待前序完成 """ import asyncio import concurrent.futures from typing import List, Callable, Any import subprocess import json class SubAgentExecutor: def __init__(self, max_workers=5): self.max_workers = max_workers self.executor = concurrent.futures.ThreadPoolExecutor(max_workers=max_workers) def run_task(self, task: dict) -> dict: """执行单个子任务""" task_type = task.get("type") command = task.get("command") if task_type == "bash": result = subprocess.run( command, shell=True, capture_output=True, text=True, timeout=task.get("timeout", 300) ) return { "task_id": task.get("id"), "status": "success" if result.returncode == 0 else "failed", "output": result.stdout, "error": result.stderr } elif task_type == "skill": # 调用 OpenClaw skill result = subprocess.run( f"npx clawhub@latest run {command}", shell=True, capture_output=True, text=True ) return { "task_id": task.get("id"), "status": "success" if result.returncode == 0 else "failed", "output": result.stdout } return {"task_id": task.get("id"), "status": "unknown_type"} def run_parallel(self, tasks: List[dict]) -> List[dict]: """并发执行多个任务""" futures = [self.executor.submit(self.run_task, task) for task in tasks] results = [f.result() for f in concurrent.futures.as_completed(futures)] return results if __name__ == "__main__": executor = SubAgentExecutor(max_workers=5) # 示例：并行执行多个任务 tasks = [ {"id": "task1", "type": "bash", "command": "ls -la /root"}, {"id": "task2", "type": "skill", "command": "mckinsey-frameworks"}, {"id": "task3", "type": "bash", "command": "git status"}, ] results = executor.run_parallel(tasks) print(json.dumps(results, indent=2)) EOF ``` --- ## 四、上下文压缩系统 ### 4.1 92% 阈值压缩 ```python # 创建上下文管理器 cat > /root/.openclaw/scripts/context_compressor.py << 'EOF' #!/usr/bin/env python3 """ OpenClaw 上下文压缩管理器 当上下文达到 92% 时自动压缩 """ import os import json from pathlib import Path class ContextCompressor: def __init__(self, max_tokens=200000, compression_threshold=0.92): self.max_tokens = max_tokens self.threshold = compression_threshold self.current_usage = 0 def check_and_compress(self, messages: list) -> list: """检查上下文使用率并在需要时压缩""" total_tokens = sum(len(str(m)) // 4 for m in messages) self.current_usage = total_tokens / self.max_tokens if self.current_usage >= self.threshold: return self.compress(messages) return messages def compress(self, messages: list) -> list: """压缩策略：保留关键决策和结果""" compressed = [] for msg in messages: content = str(msg.get("content", "")) # 保留关键信息：决策、结论、结果 if any(kw in content for kw in ["✅", "❌", "决策", "结论", "result", "error"]): compressed.append(msg) # 保留工具调用结果 elif msg.get("role") == "tool": compressed.append(msg) return compressed def extract_summary(self, messages: list) -> str: """提取中间总结""" summary = [] for msg in messages: content = str(msg.get("content", "")) if any(kw in content for kw in ["架构选择", "测试结论", "决策", "selected"]): summary.append(content[:200]) return "\n".join(summary) EOF ``` ### 4.2 记忆文件化系统 ```markdown # 四层记忆文件结构（参考 Claude-Code） root: /root/.openclaw/workspace/memory/ ├── daily/ # 每日日志 │ ├── 2026-04-19.md │ └── 2026-04-25.md ├── reflections/ # 自我反思 │ └── ${timestamp}.md ├── lessons/ # 经验总结 │ └── lessons.md └── memory.md # 索引文件（由 AGENTS.md 管理） ``` --- ## 五、并发执行配置 ### 5.1 子代理配置 ```json // /root/.openclaw/config/subagents.json { "enabled": true, "max_concurrent": 5, "default_timeout": 300, "strategies": { "code_review": { "type": "skill", "skill": "code-review" }, "research": { "type": "skill", "skill": "browser-use" }, "documentation": { "type": "skill", "skill": "docs-generator" } } } ``` ### 5.2 并发执行示例 ```python # 并发执行示例 tasks = [ {"id": "1", "type": "code_review", "target": "src/main.py"}, {"id": "2", "type": "research", "query": "latest AI trends"}, {"id": "3", "type": "documentation", "target": "API docs"}, ] executor = SubAgentExecutor(max_workers=3) results = executor.run_parallel(tasks) ``` --- ## 六、长时自主运行配置 ### 6.1 健康检查脚本 ```bash cat > /root/.openclaw/scripts/health_check.sh << 'EOF' #!/bin/bash # OpenClaw 长时运行健康检查 LOG_FILE="/root/.openclaw/logs/agent_health.log" MAX_IDLE_HOURS=6 check_idle() { last_activity=$(stat -c %Y /root/.openclaw/workspace/memory/memory.md 2>/dev/null || echo 0) now=$(date +%s) idle_hours=$(( (now - last_activity) / 3600 )) if [ $idle_hours -ge $MAX_IDLE_HOURS ]; then echo "[$(date)] 检测到空闲${idle_hours}小时，执行自我反思..." >> $LOG_FILE /root/.openclaw/scripts/self-reflection.sh fi } check_memory() { mem_usage=$(free | grep Mem | awk '{printf "%.1f", $3/$2 * 100}') if (( $(echo "$mem_usage > 90" | bc -l) )); then echo "[$(date)] 内存使用率${mem_usage}%，触发压缩..." >> $LOG_FILE python3 /root/.openclaw/scripts/context_compressor.py --compress fi } check_idle check_memory EOF chmod +x /root/.openclaw/scripts/health_check.sh # 添加到 crontab（每30分钟检查） (crontab -l 2>/dev/null; echo "*/30 * * * * /root/.openclaw/scripts/health_check.sh") | crontab - ``` --- ## 七、Claude-Code 工作流集成 ### 7.1 N0 循环实现 ```python # claude_code_loop.py import asyncio from typing import Optional class N0Engine: """Claude-Code N0 循环引擎""" def __init__(self): self.running = False self.context = [] async def step(self, user_input: str) -> str: """单步执行""" # 1. 获取输入 self.context.append({"role": "user", "content": user_input}) # 2. 模型决策（调用 LLM） response = await self.llm.chat(messages=self.context) # 3. 执行工具 if response.tool_calls: for tool in response.tool_calls: result = await self.execute_tool(tool) self.context.append({"role": "tool", "content": result}) # 4. 检查停止条件 if response.stop_reason == "endturn": self.running = False return response.content async def run(self, user_input: str): """主循环""" self.running = True while self.running: result = await self.step(user_input) print(result) user_input = input("> ") async def execute_tool(self, tool_call: dict) -> str: """执行工具调用""" tool_name = tool_call["name"] args = tool_call["arguments"] if tool_name == "bash": return await self.run_bash(args["command"]) elif tool_name == "read": return self.read_file(args["path"]) # ... 其他工具 return "tool executed" ``` ### 7.2 与 OpenClaw 集成 ```python # openclaw_n0_bridge.py from openclaw import OpenClaw class OpenClawN0Bridge: """将 N0 引擎桥接到 OpenClaw""" def __init__(self, openclaw: OpenClaw): self.oc = openclaw self.context = [] async def process(self, user_input: str) -> str: """处理用户输入""" # 添加到上下文 self.context.append({"role": "user", "content": user_input}) # 检查压缩 compressor = ContextCompressor() self.context = compressor.check_and_compress(self.context) # 调用 OpenClaw 处理 response = await self.oc.chat(messages=self.context) # 添加响应到上下文 self.context.append({"role": "assistant", "content": response}) return response ``` --- ## 八、使用方式 ### 触发场景 ``` 用户说「启动 Claude-Code 模式」→ 激活 N0 引擎 用户说「并发执行这些任务」→ 触发子代理系统 用户说「搜索记忆」→ 启动向量检索 用户说「自我反思」→ 执行反思脚本 用户说「检查上下文」→ 触发压缩检查 ``` ### 配置检查清单 ```bash # 1. 确认 crontab 已配置 crontab -l | grep self-reflection # 2. 确认向量数据库已初始化 ls /root/.openclaw/workspace/memory/vector_db/ # 3. 确认并发执行器可运行 python3 /root/.openclaw/scripts/subagent_executor.py --test # 4. 确认健康检查已启用 ps aux | grep health_check ``` --- ## 九、技术对比 | 功能 | Claude-Code | OpenClaw (当前) | OpenClaw (目标) | |------|------------|----------------|----------------| | N0 循环 | ✅ while True | ⚠️ 单次交互 | ✅ 实现 | | 并发执行 | ✅ 子代理并行 | ❌ 顺序执行 | ✅ 实现 | | 上下文压缩 | ✅ 92% 阈值 | ❌ 无 | ✅ 实现 | | 自我反思 | ✅ 日志记录 | ⚠️ 手动 | ✅ 自动 | | 向量检索 | ⚠️ 外部工具 | ❌ 无 | ✅ 实现 | | 7 种内置工具 | ✅ 完整 | ⚠️ 部分 | ✅ 补充 | --- ## 十、已知限制 ``` ⚠️ 限制说明： - N0 引擎需要持续运行进程，当前 OpenClaw 为请求-响应模式 - 并发执行需要多进程/多线程支持，单核环境受限 - 向量检索需要额外存储（约 500MB 用于向量库） - 自我反思依赖 LLM 调用，需 API Key - 部分功能需要 root 权限（crontab） ``` --- ## 十一、相关技能 | 技能 | 关系 | |------|------| | `thinking-knowledge-system` | 认知闭环构建 | | `ai-research-tools` | 子代理研究系统 | | `browser-use` | 浏览器工具支持 | --- *本技能帮助将 OpenClaw 升级为类 Claude-Code 的高效代理架构*


Security scan verdicts — ClawScan: suspicious | static analysis: clean | VirusTotal: clean | SkillSpector: suspicious (HIGH)