aetherforge-platform 1.0.0__py3-none-any.whl

ai-life-assistant-copy/backups/backup_20260404_193836/tree_memory.py

@@ -0,0 +1,340 @@
+import json
+import os
+from typing import List, Dict, Any, Optional
+from datetime import datetime, timedelta
+import uuid
+
+
+class MemoryNode:
+    def __init__(
+        self, 
+        content: str, 
+        memory_id: Optional[str] = None,
+        min_age: int = 0, 
+        max_age: int = 150,
+        clarity: int = 80,
+        emotional_tone: str = "neutral",
+        topic: Optional[str] = None,
+        parent_id: Optional[str] = None,
+        created_at: Optional[str] = None,
+        importance: float = 0.5,
+        access_count: int = 0
+    ):
+        self.memory_id = memory_id or str(uuid.uuid4())
+        self.content = content
+        self.min_age = min_age
+        self.max_age = max_age
+        self.clarity = clarity
+        self.emotional_tone = emotional_tone
+        self.topic = topic
+        self.parent_id = parent_id
+        self.created_at = created_at or datetime.now().isoformat()
+        self.importance = importance
+        self.access_count = access_count
+        self.children: List[str] = []
+    
+    def get_age_in_days(self) -> float:
+        created = datetime.fromisoformat(self.created_at)
+        now = datetime.now()
+        return (now - created).total_seconds() / 86400
+    
+    def get_recency_score(self) -> float:
+        age_days = self.get_age_in_days()
+        if age_days < 1:
+            return 1.0
+        elif age_days < 7:
+            return 0.8
+        elif age_days < 30:
+            return 0.5
+        elif age_days < 90:
+            return 0.2
+        else:
+            return 0.05
+    
+    def get_relevance_score(self, query: str) -> float:
+        query_lower = query.lower()
+        content_lower = self.content.lower()
+        topic_lower = self.topic.lower() if self.topic else ""
+        
+        score = 0.0
+        if query_lower in content_lower:
+            score += 0.6
+        if query_lower in topic_lower:
+            score += 0.3
+        
+        score += self.importance * 0.3
+        score += (self.clarity / 100) * 0.2
+        score += self.get_recency_score() * 0.4
+        
+        return min(1.0, score)
+    
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "memory_id": self.memory_id,
+            "content": self.content,
+            "min_age": self.min_age,
+            "max_age": self.max_age,
+            "clarity": self.clarity,
+            "emotional_tone": self.emotional_tone,
+            "topic": self.topic,
+            "parent_id": self.parent_id,
+            "created_at": self.created_at,
+            "importance": self.importance,
+            "access_count": self.access_count,
+            "children": self.children
+        }
+    
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> 'MemoryNode':
+        node = cls(
+            content=data["content"],
+            memory_id=data["memory_id"],
+            min_age=data["min_age"],
+            max_age=data["max_age"],
+            clarity=data["clarity"],
+            emotional_tone=data["emotional_tone"],
+            topic=data.get("topic"),
+            parent_id=data.get("parent_id"),
+            created_at=data.get("created_at"),
+            importance=data.get("importance", 0.5),
+            access_count=data.get("access_count", 0)
+        )
+        node.children = data.get("children", [])
+        return node
+
+
+class InvertedTreeMemory:
+    def __init__(self, tree_id: str = "root"):
+        self.tree_id = tree_id
+        self.nodes: Dict[str, MemoryNode] = {}
+        self.trunk: List[str] = []
+        self.created_at = datetime.now().isoformat()
+    
+    def add_node(self, node: MemoryNode):
+        self.nodes[node.memory_id] = node
+        if not node.parent_id:
+            self.trunk.append(node.memory_id)
+        elif node.parent_id in self.nodes:
+            self.nodes[node.parent_id].children.append(node.memory_id)
+    
+    def get_node(self, memory_id: str) -> Optional[MemoryNode]:
+        return self.nodes.get(memory_id)
+    
+    def filter_by_age(self, target_age: int) -> List[MemoryNode]:
+        filtered = []
+        for node in self.nodes.values():
+            if node.min_age <= target_age <= node.max_age:
+                filtered.append(node)
+        return filtered
+    
+    def search_relevant(self, query: str, min_relevance: float = 0.3, max_results: int = 10) -> List[MemoryNode]:
+        scored_nodes = []
+        for node in self.nodes.values():
+            score = node.get_relevance_score(query)
+            if score >= min_relevance:
+                scored_nodes.append((score, node))
+        
+        scored_nodes.sort(key=lambda x: x[0], reverse=True)
+        return [node for (score, node) in scored_nodes[:max_results]]
+    
+    def get_related_memories(self, memory_id: str) -> List[MemoryNode]:
+        related = []
+        node = self.get_node(memory_id)
+        if not node:
+            return related
+        
+        if node.parent_id:
+            parent = self.get_node(node.parent_id)
+            if parent:
+                related.append(parent)
+        
+        for child_id in node.children:
+            child = self.get_node(child_id)
+            if child:
+                related.append(child)
+        
+        return related
+    
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "tree_id": self.tree_id,
+            "nodes": {k: v.to_dict() for k, v in self.nodes.items()},
+            "trunk": self.trunk,
+            "created_at": self.created_at
+        }
+    
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> 'InvertedTreeMemory':
+        tree = cls(tree_id=data["tree_id"])
+        tree.created_at = data["created_at"]
+        tree.trunk = data.get("trunk", [])
+        for node_data in data.get("nodes", {}).values():
+            node = MemoryNode.from_dict(node_data)
+            tree.nodes[node.memory_id] = node
+        return tree
+
+
+class TreeMemorySystem:
+    def __init__(self, storage_dir: str = "avatar_memory"):
+        self.storage_dir = storage_dir
+        if not os.path.exists(storage_dir):
+            os.makedirs(storage_dir)
+    
+    def _get_tree_file(self, avatar_id: str) -> str:
+        return os.path.join(self.storage_dir, f"{avatar_id}_tree.json")
+    
+    def load_tree(self, avatar_id: str) -> InvertedTreeMemory:
+        file_path = self._get_tree_file(avatar_id)
+        if os.path.exists(file_path):
+            with open(file_path, "r", encoding="utf-8") as f:
+                data = json.load(f)
+                return InvertedTreeMemory.from_dict(data)
+        return InvertedTreeMemory(tree_id=avatar_id)
+    
+    def save_tree(self, avatar_id: str, tree: InvertedTreeMemory):
+        file_path = self._get_tree_file(avatar_id)
+        with open(file_path, "w", encoding="utf-8") as f:
+            json.dump(tree.to_dict(), f, ensure_ascii=False, indent=2)
+    
+    def add_memory(
+        self, 
+        avatar_id: str, 
+        content: str, 
+        min_age: int = 0,
+        max_age: int = 150,
+        clarity: int = 80,
+        emotional_tone: str = "neutral",
+        topic: Optional[str] = None,
+        parent_id: Optional[str] = None,
+        importance: float = 0.5
+    ) -> str:
+        tree = self.load_tree(avatar_id)
+        node = MemoryNode(
+            content=content,
+            min_age=min_age,
+            max_age=max_age,
+            clarity=clarity,
+            emotional_tone=emotional_tone,
+            topic=topic,
+            parent_id=parent_id,
+            importance=importance
+        )
+        tree.add_node(node)
+        self.save_tree(avatar_id, tree)
+        return node.memory_id
+    
+    def get_memories_by_age(self, avatar_id: str, target_age: int) -> List[Dict[str, Any]]:
+        tree = self.load_tree(avatar_id)
+        nodes = tree.filter_by_age(target_age)
+        return [node.to_dict() for node in nodes]
+    
+    def get_all_memories(self, avatar_id: str) -> List[Dict[str, Any]]:
+        tree = self.load_tree(avatar_id)
+        return [node.to_dict() for node in tree.nodes.values()]
+    
+    def get_tree_structure(self, avatar_id: str) -> Dict[str, Any]:
+        tree = self.load_tree(avatar_id)
+        return tree.to_dict()
+    
+    def delete_memory(self, avatar_id: str, memory_id: str) -> bool:
+        tree = self.load_tree(avatar_id)
+        if memory_id in tree.nodes:
+            del tree.nodes[memory_id]
+            tree.trunk = [mid for mid in tree.trunk if mid != memory_id]
+            for node in tree.nodes.values():
+                node.children = [mid for mid in node.children if mid != memory_id]
+            self.save_tree(avatar_id, tree)
+            return True
+        return False
+    
+    def search_relevant_memories(
+        self, 
+        avatar_id: str, 
+        query: str, 
+        min_relevance: float = 0.3, 
+        max_results: int = 10
+    ) -> List[Dict[str, Any]]:
+        tree = self.load_tree(avatar_id)
+        nodes = tree.search_relevant(query, min_relevance, max_results)
+        results = []
+        for node in nodes:
+            node.access_count += 1
+            results.append(node.to_dict())
+        self.save_tree(avatar_id, tree)
+        return results
+    
+    def get_related_memories(self, avatar_id: str, memory_id: str) -> List[Dict[str, Any]]:
+        tree = self.load_tree(avatar_id)
+        nodes = tree.get_related_memories(memory_id)
+        return [node.to_dict() for node in nodes]
+    
+    def get_relevant_context(
+        self, 
+        avatar_id: str, 
+        current_message: str, 
+        min_relevance: float = 0.3, 
+        max_results: int = 5
+    ) -> str:
+        memories = self.search_relevant_memories(avatar_id, current_message, min_relevance, max_results)
+        if not memories:
+            return ""
+        
+        context_parts = ["【用户背景信息 - 树状记忆系统】"]
+        for mem in memories:
+            age_info = ""
+            if mem["min_age"] != 0 or mem["max_age"] != 150:
+                if mem["min_age"] == mem["max_age"]:
+                    age_info = f" [年龄: {mem['min_age']}]"
+                else:
+                    age_info = f" [年龄: {mem['min_age']}-{mem['max_age']}]"
+            
+            clarity_info = f" [清晰度: {mem['clarity']}%]"
+            emotion_info = f" [情感: {mem['emotional_tone']}]"
+            topic_info = f" [主题: {mem['topic']}]" if mem['topic'] else ""
+            
+            context_parts.append(f"- {mem['content']}{age_info}{clarity_info}{emotion_info}{topic_info}")
+        
+        return "\n".join(context_parts)
+    
+    def extract_and_save_memory(
+        self, 
+        avatar_id: str, 
+        message: str, 
+        response: str = "",
+        current_age: int = 25
+    ) -> Optional[str]:
+        message_lower = message.lower()
+        
+        importance = 0.5
+        if "永远" in message_lower or "绝对" in message_lower or "绝不" in message_lower:
+            importance = 0.9
+        elif "非常" in message_lower or "特别" in message_lower:
+            importance = 0.75
+        
+        emotional_tone = "neutral"
+        positive_words = ["开心", "快乐", "高兴", "喜欢", "爱", "好", "棒", "完美"]
+        negative_words = ["难过", "伤心", "讨厌", "恨", "不好", "糟糕", "生气", "愤怒"]
+        
+        if any(word in message_lower for word in positive_words):
+            emotional_tone = "positive"
+        elif any(word in message_lower for word in negative_words):
+            emotional_tone = "negative"
+        
+        user_keywords = ["我是", "我喜欢", "我偏好", "我不喜欢", "我讨厌", "我想要", "我爱吃", "我爱玩", "记得", "小时候", "曾经"]
+        should_save = any(keyword in message_lower for keyword in user_keywords) or len(message) > 20
+        
+        if should_save:
+            return self.add_memory(
+                avatar_id=avatar_id,
+                content=message,
+                min_age=current_age,
+                max_age=current_age,
+                clarity=80,
+                emotional_tone=emotional_tone,
+                importance=importance
+            )
+        
+        return None
+
+
+tree_memory_system = TreeMemorySystem()

ai-life-assistant-copy/commands.py

@@ -0,0 +1,210 @@
+"""命令系统"""
+
+from typing import Dict, Any, List
+import re
+
+class CommandParser:
+    """命令解析器"""
+    
+    def __init__(self):
+        self.commands = {
+            "weather": self._parse_weather,
+            "w": self._parse_weather,
+            "calendar": self._parse_calendar,
+            "cal": self._parse_calendar,
+            "reminder": self._parse_reminder,
+            "rem": self._parse_reminder,
+            "shopping": self._parse_shopping,
+            "buy": self._parse_shopping,
+            "food": self._parse_food,
+            "taxi": self._parse_taxi,
+            "flight": self._parse_flight,
+            "help": self._parse_help
+        }
+    
+    def parse(self, message: str) -> Dict[str, Any]:
+        """解析命令
+        
+        Args:
+            message: 用户输入
+        
+        Returns:
+            解析结果
+        """
+        if not message.startswith("/"):
+            return {"type": "normal", "message": message}
+        
+        # 提取命令和参数
+        parts = message[1:].split(" ", 1)
+        command = parts[0].lower()
+        args = parts[1] if len(parts) > 1 else ""
+        
+        if command in self.commands:
+            return self.commands[command](args)
+        else:
+            return {"type": "normal", "message": message}
+    
+    def _parse_weather(self, args: str) -> Dict[str, Any]:
+        """解析天气命令"""
+        location = args.strip() or "北京"
+        return {
+            "type": "command",
+            "command": "weather",
+            "intent": "weather",
+            "requirements": {"location": location}
+        }
+    
+    def _parse_calendar(self, args: str) -> Dict[str, Any]:
+        """解析日程命令"""
+        parts = args.split(" ")
+        if not parts:
+            return {
+                "type": "command",
+                "command": "calendar",
+                "intent": "calendar",
+                "requirements": {}
+            }
+        
+        if parts[0] == "add":
+            # /calendar add 标题 时间 [日期]
+            if len(parts) >= 3:
+                title = " ".join(parts[1:-1])
+                time = parts[-1]
+                return {
+                    "type": "command",
+                    "command": "calendar",
+                    "intent": "calendar",
+                    "requirements": {
+                        "action": "add",
+                        "title": title,
+                        "time": time
+                    }
+                }
+        
+        # 默认获取日程
+        date = args.strip()
+        return {
+            "type": "command",
+            "command": "calendar",
+            "intent": "calendar",
+            "requirements": {"date": date}
+        }
+    
+    def _parse_reminder(self, args: str) -> Dict[str, Any]:
+        """解析提醒命令"""
+        parts = args.split(" ")
+        if not parts:
+            return {
+                "type": "command",
+                "command": "reminder",
+                "intent": "reminder",
+                "requirements": {}
+            }
+        
+        if parts[0] == "set":
+            # /reminder set 标题 时间 [日期] [重复]
+            if len(parts) >= 3:
+                title = " ".join(parts[1:-1])
+                time = parts[-1]
+                return {
+                    "type": "command",
+                    "command": "reminder",
+                    "intent": "reminder",
+                    "requirements": {
+                        "action": "set",
+                        "title": title,
+                        "time": time
+                    }
+                }
+        
+        # 默认获取提醒
+        date = args.strip()
+        return {
+            "type": "command",
+            "command": "reminder",
+            "intent": "reminder",
+            "requirements": {"date": date}
+        }
+    
+    def _parse_shopping(self, args: str) -> Dict[str, Any]:
+        """解析购物命令"""
+        query = args.strip()
+        return {
+            "type": "command",
+            "command": "shopping",
+            "intent": "shopping",
+            "requirements": {"query": query}
+        }
+    
+    def _parse_food(self, args: str) -> Dict[str, Any]:
+        """解析外卖命令"""
+        query = args.strip()
+        return {
+            "type": "command",
+            "command": "food",
+            "intent": "food",
+            "requirements": {"query": query}
+        }
+    
+    def _parse_taxi(self, args: str) -> Dict[str, Any]:
+        """解析打车命令"""
+        destination = args.strip()
+        return {
+            "type": "command",
+            "command": "taxi",
+            "intent": "taxi",
+            "requirements": {"destination": destination}
+        }
+    
+    def _parse_flight(self, args: str) -> Dict[str, Any]:
+        """解析机票命令"""
+        parts = args.split(" ")
+        if len(parts) >= 2:
+            from_city = parts[0]
+            to_city = parts[1]
+            return {
+                "type": "command",
+                "command": "flight",
+                "intent": "flight",
+                "requirements": {
+                    "from": from_city,
+                    "to": to_city
+                }
+            }
+        return {
+            "type": "command",
+            "command": "flight",
+            "intent": "flight",
+            "requirements": {}
+        }
+    
+    def _parse_help(self, args: str) -> Dict[str, Any]:
+        """解析帮助命令"""
+        return {
+            "type": "command",
+            "command": "help",
+            "intent": "general",
+            "requirements": {}
+        }
+
+    def get_help(self) -> str:
+        """获取帮助信息"""
+        help_text = """可用命令：
+
+/weather [城市] - 查看天气
+/calendar [日期] - 查看日程
+/calendar add [标题] [时间] - 添加日程
+/reminder [日期] - 查看提醒
+/reminder set [标题] [时间] - 设置提醒
+/shopping [关键词] - 搜索商品
+/food [关键词] - 点外卖
+/taxi [目的地] - 打车
+/flight [出发地] [目的地] - 查机票
+/help - 查看帮助
+
+示例：
+/weather 上海
+/reminder set 吃药 08:00
+/shopping 手机
+"""
+        return help_text

ai-life-assistant-copy/config.py

@@ -0,0 +1,30 @@
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+
+# API Keys
+GROK_API_KEY = os.getenv("GROK_API_KEY", "")
+SUPABASE_URL = os.getenv("SUPABASE_URL", "")
+SUPABASE_KEY = os.getenv("SUPABASE_KEY", "")
+
+# Amazon Affiliate
+AMAZON_ASSOCIATE_TAG = os.getenv("AMAZON_ASSOCIATE_TAG", "")
+AMAZON_ACCESS_KEY = os.getenv("AMAZON_ACCESS_KEY", "")
+AMAZON_SECRET_KEY = os.getenv("AMAZON_SECRET_KEY", "")
+
+# Uber Affiliate
+UBER_CLIENT_ID = os.getenv("UBER_CLIENT_ID", "")
+UBER_CLIENT_SECRET = os.getenv("UBER_CLIENT_SECRET", "")
+
+# App Settings
+APP_NAME = "AI Life Assistant"
+APP_VERSION = "1.0.0"
+DEBUG = os.getenv("DEBUG", "True").lower() == "true"
+
+# API Settings
+MAX_RETRIES = 3
+REQUEST_TIMEOUT = 30
+
+# Memory Settings
+MEMORY_MAX_LENGTH = 50

ai-life-assistant-copy/daemon/__init__.py

@@ -0,0 +1,3 @@
+"""梦游功能（智能后台服务）"""
+
+from .daemon import LifeAssistantDaemon