erlangshen 0.1.0

package/src/core/knowledge.py

@@ -0,0 +1,207 @@
+"""
+Knowledge - 知识库管理
+基于向量的语义搜索知识库
+"""
+import os
+import json
+import time
+from datetime import datetime
+from pathlib import Path
+from typing import Optional
+from pydantic import BaseModel, Field
+from loguru import logger
+
+
+class KnowledgeEntry(BaseModel):
+    """知识条目"""
+    entry_id: str
+    content: str
+    category: str = "general"
+    tags: list[str] = Field(default_factory=list)
+    created_at: float = Field(default_factory=time.time)
+    updated_at: float = Field(default_factory=time.time)
+    metadata: dict = Field(default_factory=dict)
+
+
+class KnowledgeBase:
+    """
+    知识库管理
+
+    提供：
+    - 添加知识条目
+    - 语义搜索
+    - 分类管理
+    - 知识沉淀
+    """
+
+    def __init__(self, base_path: Optional[str] = None):
+        if base_path is None:
+            base_path = Path(__file__).parent.parent.parent / "knowledge"
+        self.base_path = Path(base_path)
+        self.memos_path = self.base_path / "memos"
+        self.reports_path = self.base_path / "reports"
+        self.insights_path = self.base_path / "insights"
+        self.facts_path = self.base_path / "facts"
+
+        # 确保目录存在
+        for p in [self.memos_path, self.reports_path, self.insights_path, self.facts_path]:
+            p.mkdir(parents=True, exist_ok=True)
+
+        # 内存索引
+        self._index: list[KnowledgeEntry] = []
+        self._load_index()
+        logger.info(f"KnowledgeBase initialized at {self.base_path}")
+
+    def _load_index(self) -> None:
+        """加载知识库索引"""
+        index_file = self.base_path / "index.json"
+        if index_file.exists():
+            try:
+                data = json.loads(index_file.read_text())
+                self._index = [KnowledgeEntry(**e) for e in data]
+                logger.info(f"Loaded {len(self._index)} entries from index")
+            except Exception as e:
+                logger.warning(f"Failed to load index: {e}")
+
+    def _save_index(self) -> None:
+        """保存知识库索引"""
+        index_file = self.base_path / "index.json"
+        try:
+            data = [e.model_dump() for e in self._index]
+            index_file.write_text(json.dumps(data, ensure_ascii=False, indent=2))
+        except Exception as e:
+            logger.error(f"Failed to save index: {e}")
+
+    def add(
+        self,
+        content: str,
+        category: str = "general",
+        tags: Optional[list[str]] = None,
+        metadata: Optional[dict] = None,
+    ) -> KnowledgeEntry:
+        """
+        添加知识条目
+
+        Args:
+            content: 知识内容
+            category: 分类 (memo/report/insight/fact)
+            tags: 标签
+            metadata: 额外元数据
+
+        Returns:
+            KnowledgeEntry 新增的条目
+        """
+        entry = KnowledgeEntry(
+            entry_id=f"kb_{int(time.time()*1000)}",
+            content=content,
+            category=category,
+            tags=tags or [],
+            metadata=metadata or {},
+        )
+        self._index.append(entry)
+        self._save_index()
+        logger.info(f"Added knowledge entry: {entry.entry_id} [{category}]")
+        return entry
+
+    async def search(
+        self,
+        query: str,
+        top_k: int = 5,
+        category: Optional[str] = None,
+    ) -> list[dict]:
+        """
+        搜索知识库 (简单关键词匹配，实际可接入向量数据库)
+
+        Args:
+            query: 搜索查询
+            top_k: 返回数量
+            category: 限定分类
+
+        Returns:
+            list[dict] 匹配的知识条目
+        """
+        query_lower = query.lower()
+        results = []
+
+        for entry in reversed(self._index):  # 优先返回最新的
+            if category and entry.category != category:
+                continue
+
+            # 简单评分：内容匹配度
+            score = 0.0
+            query_words = query_lower.split()
+            content_lower = entry.content.lower()
+
+            for word in query_words:
+                if word in content_lower:
+                    score += 1.0
+                if word in entry.tags:
+                    score += 2.0  # 标签匹配权重更高
+
+            if score > 0:
+                results.append({
+                    "entry_id": entry.entry_id,
+                    "content": entry.content,
+                    "category": entry.category,
+                    "tags": entry.tags,
+                    "score": score,
+                    "created_at": entry.created_at,
+                })
+
+        # 排序并返回top_k
+        results.sort(key=lambda x: x["score"], reverse=True)
+        return results[:top_k]
+
+    async def write_memo(self, content: str, title: Optional[str] = None) -> str:
+        """写入纪要"""
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        title_str = title or "memo"
+        filename = self.memos_path / f"{timestamp}_{title_str}.md"
+        filename.write_text(content, encoding="utf-8")
+
+        # 同时添加到索引
+        self.add(content, category="memo", metadata={"title": title or "untitled"})
+        logger.info(f"Wrote memo: {filename.name}")
+        return str(filename)
+
+    async def write_report(self, content: str, title: str) -> str:
+        """写入报告"""
+        timestamp = datetime.now().strftime("%Y%m%d")
+        filename = self.reports_path / f"{timestamp}_{title}.md"
+        filename.write_text(content, encoding="utf-8")
+
+        self.add(content, category="report", metadata={"title": title})
+        logger.info(f"Wrote report: {filename.name}")
+        return str(filename)
+
+    async def append_insight(self, insight: str, tags: Optional[list[str]] = None) -> KnowledgeEntry:
+        """追加洞察"""
+        return self.add(
+            content=insight,
+            category="insight",
+            tags=tags or ["insight"],
+        )
+
+    async def add_fact(self, fact: str, source: Optional[str] = None) -> KnowledgeEntry:
+        """添加事实"""
+        return self.add(
+            content=fact,
+            category="fact",
+            metadata={"source": source} if source else {},
+        )
+
+    def list_entries(self, category: Optional[str] = None) -> list[KnowledgeEntry]:
+        """列出知识条目"""
+        if category:
+            return [e for e in self._index if e.category == category]
+        return self._index
+
+    def stats(self) -> dict:
+        """知识库统计"""
+        categories = {}
+        for e in self._index:
+            categories[e.category] = categories.get(e.category, 0) + 1
+        return {
+            "total": len(self._index),
+            "by_category": categories,
+        }

package/src/core/memory.py

@@ -0,0 +1,115 @@
+"""
+Memory - 多层记忆系统
+工作记忆、情景记忆、语义记忆、程序记忆
+"""
+import json
+import time
+from datetime import datetime
+from typing import Any, Optional
+from pydantic import BaseModel, Field
+from loguru import logger
+
+
+class Message(BaseModel):
+    """工作记忆中的单条消息"""
+    role: str  # user, assistant, system
+    content: str
+    timestamp: float = Field(default_factory=time.time)
+
+
+class Event(BaseModel):
+    """情景记忆中的事件"""
+    event_id: str
+    description: str
+    timestamp: float
+    tags: list[str] = Field(default_factory=list)
+    importance: float = 0.5  # 0-1
+
+
+class Memory:
+    """
+    多层记忆系统
+
+    - working_memory: 当前上下文中的消息
+    - episodic_memory: 重要事件记录
+    - semantic_memory: 语义知识(通过KnowledgeBase)
+    - procedural_memory: 能力技能注册
+    """
+
+    def __init__(self, max_working: int = 50):
+        self.max_working = max_working
+        self.working_memory: list[Message] = []
+        self.episodic_memory: list[Event] = []
+        self.procedural_memory: dict[str, Any] = {}
+        logger.info("Memory initialized")
+
+    async def add_message(self, role: str, content: str) -> None:
+        """添加工作记忆消息"""
+        msg = Message(role=role, content=content)
+        self.working_memory.append(msg)
+        if len(self.working_memory) > self.max_working:
+            self.working_memory = self.working_memory[-self.max_working:]
+        logger.debug(f"Added message to working memory: {role}")
+
+    async def add_interaction(self, query: str, response: str) -> None:
+        """记录一次交互"""
+        await self.add_message("user", query)
+        await self.add_message("assistant", response)
+
+        # 同时记录到情景记忆
+        event = Event(
+            event_id=f"evt_{int(time.time()*1000)}",
+            description=f"Query: {query[:100]} | Response: {response[:100]}",
+            timestamp=time.time(),
+            tags=["interaction"],
+        )
+        self.episodic_memory.append(event)
+        # 保留最近100个重要事件
+        if len(self.episodic_memory) > 100:
+            self.episodic_memory = self.episodic_memory[-100:]
+
+    async def get_context(self, last_n: Optional[int] = None) -> list[Message]:
+        """获取工作记忆上下文"""
+        if last_n:
+            return self.working_memory[-last_n:]
+        return self.working_memory
+
+    async def get_recent_events(self, hours: float = 24) -> list[Event]:
+        """获取最近的事件"""
+        now = time.time()
+        cutoff = now - hours * 3600
+        return [e for e in self.episodic_memory if e.timestamp >= cutoff]
+
+    def register_skill(self, name: str, skill: Any) -> None:
+        """注册程序记忆(技能)"""
+        self.procedural_memory[name] = skill
+
+    def get_skill(self, name: str) -> Optional[Any]:
+        """获取技能"""
+        return self.procedural_memory.get(name)
+
+    def list_skills(self) -> list[str]:
+        """列出所有已注册技能"""
+        return list(self.procedural_memory.keys())
+
+    async def search_episodic(self, keyword: str) -> list[Event]:
+        """搜索情景记忆"""
+        keyword = keyword.lower()
+        return [
+            e for e in self.episodic_memory
+            if keyword in e.description.lower()
+        ]
+
+    def export_state(self) -> dict:
+        """导出记忆状态(用于持久化)"""
+        return {
+            "episodic": [e.model_dump() for e in self.episodic_memory],
+            "procedural": list(self.procedural_memory.keys()),
+            "export_time": datetime.now().isoformat(),
+        }
+
+    def import_state(self, state: dict) -> None:
+        """导入记忆状态"""
+        if "episodic" in state:
+            self.episodic_memory = [Event(**e) for e in state["episodic"]]
+        logger.info(f"Imported {len(self.episodic_memory)} events into episodic memory")

package/src/hooks/__init__.py

@@ -0,0 +1,3 @@
+"""
+Hooks 模块
+"""

package/src/hooks/session_end.py

@@ -0,0 +1,57 @@
+"""
+SessionEnd 钩子 - 会话结束时执行
+"""
+
+from datetime import datetime
+from pathlib import Path
+from typing import Any
+from src.brain import Brain
+from src.mcp.registry import MCPRegistry
+
+
+class SessionEndHook:
+    """
+    会话结束钩子
+    
+    在会话结束时执行，用于：
+    - 保存会话摘要
+    - 更新知识库
+    - 清理临时文件
+    """
+    
+    def __init__(self, brain: Brain, mcp: MCPRegistry):
+        self.brain = brain
+        self.mcp = mcp
+        self.session_summary_dir = Path("~/.openclaw-agent-06/workspace/erlangshen/knowledge/memos").expanduser()
+        self.session_summary_dir.mkdir(parents=True, exist_ok=True)
+    
+    async def run(self) -> None:
+        """执行会话结束钩子"""
+        try:
+            # 生成会话摘要
+            summary = self._generate_summary()
+            
+            # 保存会话摘要
+            await self._save_session_summary(summary)
+            
+        except Exception as e:
+            print(f"会话结束处理完成 (部分操作失败: {e})")
+    
+    def _generate_summary(self) -> dict:
+        """生成会话摘要"""
+        return {
+            "session_id": datetime.now().strftime("%Y%m%d_%H%M%S"),
+            "start_time": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+            "conversations": [],
+            "commands_executed": [],
+        }
+    
+    async def _save_session_summary(self, summary: dict) -> None:
+        """保存会话摘要"""
+        filename = f"session_{summary['session_id']}.json"
+        filepath = self.session_summary_dir / filename
+        
+        import json
+        
+        with open(filepath, "w", encoding="utf-8") as f:
+            json.dump(summary, f, ensure_ascii=False, indent=2)

package/src/hooks/session_start.py

@@ -0,0 +1,75 @@
+"""
+SessionStart 钩子 - 会话开始时执行
+"""
+
+from datetime import datetime
+from typing import Any
+from src.brain import Brain
+from src.mcp.registry import MCPRegistry
+
+
+class SessionStartHook:
+    """
+    会话开始钩子
+    
+    在新会话开始时执行，用于：
+    - 加载市场快照
+    - 检查重要数据更新
+    - 初始化会话上下文
+    """
+    
+    def __init__(self, brain: Brain, mcp: MCPRegistry):
+        self.brain = brain
+        self.mcp = mcp
+    
+    async def run(self) -> None:
+        """执行会话开始钩子"""
+        try:
+            # 获取市场快照
+            snapshot = await self._get_market_snapshot()
+            
+            # 显示欢迎信息
+            self._print_welcome(snapshot)
+            
+        except Exception as e:
+            print(f"会话初始化完成 (部分数据加载失败: {e})")
+    
+    async def _get_market_snapshot(self) -> dict:
+        """获取市场快照"""
+        snapshot = {
+            "indices": [],
+            "time": datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        }
+        
+        # 尝试获取主要指数
+        try:
+            index_codes = ["000001.SH", "399001.SZ", "399006.SZ", "000300.SH"]
+            for code in index_codes:
+                result = await self.mcp.call_tool("get_index_quote", index_code=code)
+                if isinstance(result, dict) and result.get("price"):
+                    snapshot["indices"].append(result)
+        except Exception:
+            pass
+        
+        return snapshot
+    
+    def _print_welcome(self, snapshot: dict) -> None:
+        """打印欢迎信息"""
+        print(f"\n{'='*50}")
+        print(f"  二郎神投资分析智能体")
+        print(f"{'='*50}")
+        print(f"  时间: {snapshot['time']}")
+        
+        if snapshot["indices"]:
+            print(f"\n  市场快照:")
+            for index in snapshot["indices"]:
+                name = index.get("name", "")
+                price = index.get("price", 0)
+                change = index.get("change_pct", 0)
+                arrow = "▲" if change >= 0 else "▼"
+                color = "" if not hasattr(self, '_has_color') else ("\033[92m" if change >= 0 else "\033[91m")
+                reset = "" if not hasattr(self, '_has_color') else "\033[0m"
+                print(f"    {name}: {price:.2f} {arrow} {abs(change):.2f}%")
+        
+        print(f"\n  输入 /help 查看可用命令")
+        print(f"{'='*50}\n")

package/src/knowledge/__init__.py

@@ -0,0 +1 @@
+"""Knowledge base"""

package/src/mcp/__init__.py

@@ -0,0 +1,3 @@
+"""
+MCP 模块
+"""