aetherforge-platform 1.0.0__py3-none-any.whl

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

@@ -0,0 +1,262 @@
+#!/usr/bin/env python3
+"""
+完整备份脚本 - 备份整个 AI Life Assistant 系统
+包括所有代码、数据库、静态文件和配置
+"""
+
+import os
+import shutil
+import sqlite3
+import json
+from datetime import datetime
+from pathlib import Path
+
+def create_backup():
+    """创建完整备份"""
+    
+    # 获取当前目录
+    base_dir = Path(__file__).parent
+    backup_dir = base_dir / "backups"
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    backup_folder = backup_dir / f"backup_{timestamp}"
+    
+    print(f"🚀 开始创建备份...")
+    print(f"📂 备份目录：{backup_folder}")
+    
+    # 创建备份文件夹
+    backup_folder.mkdir(parents=True, exist_ok=True)
+    
+    # 1. 备份数据库
+    db_file = base_dir / "avatar_system.db"
+    if db_file.exists():
+        print("💾 备份数据库...")
+        shutil.copy2(db_file, backup_folder / "avatar_system.db")
+        
+        # 导出数据库内容为 JSON（双重保险）
+        export_database_to_json(db_file, backup_folder / "database_export.json")
+    else:
+        print("⚠️ 数据库文件不存在")
+    
+    # 2. 备份所有 Python 文件
+    print("📄 备份 Python 文件...")
+    py_files = list(base_dir.glob("*.py"))
+    for py_file in py_files:
+        shutil.copy2(py_file, backup_folder / py_file.name)
+    
+    # 3. 备份静态文件
+    static_dir = base_dir / "static"
+    if static_dir.exists():
+        print("🎨 备份静态文件...")
+        backup_static = backup_folder / "static"
+        backup_static.mkdir(exist_ok=True)
+        shutil.copytree(static_dir, backup_static, dirs_exist_ok=True)
+    
+    # 4. 备份工具文件
+    tools_dir = base_dir / "tools"
+    if tools_dir.exists():
+        print("🔧 备份工具文件...")
+        backup_tools = backup_folder / "tools"
+        backup_tools.mkdir(exist_ok=True)
+        shutil.copytree(tools_dir, backup_tools, dirs_exist_ok=True)
+    
+    # 5. 备份守护进程
+    daemon_dir = base_dir / "daemon"
+    if daemon_dir.exists():
+        print("👻 备份守护进程...")
+        backup_daemon = backup_folder / "daemon"
+        backup_daemon.mkdir(exist_ok=True)
+        shutil.copytree(daemon_dir, backup_daemon, dirs_exist_ok=True)
+    
+    # 6. 备份重要文档
+    print("📚 备份文档...")
+    doc_files = ["README.md", "SYSTEM_GUIDE.md", "requirements.txt", ".env.example"]
+    for doc_file in doc_files:
+        src = base_dir / doc_file
+        if src.exists():
+            shutil.copy2(src, backup_folder / doc_file)
+    
+    # 7. 创建备份清单
+    create_backup_manifest(backup_folder, timestamp)
+    
+    print(f"\n✅ 备份完成！")
+    print(f"📦 备份位置：{backup_folder}")
+    print(f"💡 提示：建议将备份文件夹压缩保存")
+    
+    return backup_folder
+
+def export_database_to_json(db_file, output_file):
+    """导出数据库内容为 JSON"""
+    try:
+        conn = sqlite3.connect(db_file)
+        conn.row_factory = sqlite3.Row
+        cursor = conn.cursor()
+        
+        data = {
+            "exported_at": datetime.now().isoformat(),
+            "tables": {}
+        }
+        
+        # 获取所有表
+        cursor.execute("SELECT name FROM sqlite_master WHERE type='table'")
+        tables = [row[0] for row in cursor.fetchall()]
+        
+        for table in tables:
+            cursor.execute(f"SELECT * FROM {table}")
+            rows = cursor.fetchall()
+            
+            if rows:
+                # 转换为字典列表
+                columns = [description[0] for description in cursor.description]
+                data["tables"][table] = [dict(row) for row in rows]
+        
+        conn.close()
+        
+        with open(output_file, 'w', encoding='utf-8') as f:
+            json.dump(data, f, ensure_ascii=False, indent=2)
+        
+        print(f"  ✓ 数据库已导出为 JSON: {output_file}")
+        
+    except Exception as e:
+        print(f"  ✗ 数据库导出失败：{e}")
+
+def create_backup_manifest(backup_folder, timestamp):
+    """创建备份清单"""
+    manifest = {
+        "backup_date": timestamp,
+        "backup_type": "complete",
+        "version": "2.0",
+        "files": [],
+        "database": {
+            "exists": (backup_folder / "avatar_system.db").exists(),
+            "exported": (backup_folder / "database_export.json").exists()
+        }
+    }
+    
+    # 列出所有文件
+    for file_path in backup_folder.rglob("*"):
+        if file_path.is_file():
+            relative_path = str(file_path.relative_to(backup_folder))
+            size = file_path.stat().st_size
+            manifest["files"].append({
+                "path": relative_path,
+                "size": size
+            })
+    
+    # 保存清单
+    manifest_file = backup_folder / "backup_manifest.json"
+    with open(manifest_file, 'w', encoding='utf-8') as f:
+        json.dump(manifest, f, ensure_ascii=False, indent=2)
+    
+    print(f"  ✓ 已创建备份清单：{manifest_file}")
+
+def restore_from_backup(backup_folder):
+    """从备份恢复"""
+    backup_folder = Path(backup_folder)
+    
+    if not backup_folder.exists():
+        print(f"❌ 备份文件夹不存在：{backup_folder}")
+        return
+    
+    print(f"🔄 开始从备份恢复...")
+    print(f"📂 备份来源：{backup_folder}")
+    
+    base_dir = Path(__file__).parent
+    
+    # 1. 恢复数据库
+    db_backup = backup_folder / "avatar_system.db"
+    if db_backup.exists():
+        print("💾 恢复数据库...")
+        shutil.copy2(db_backup, base_dir / "avatar_system.db")
+    
+    # 2. 恢复 Python 文件
+    print("📄 恢复 Python 文件...")
+    for py_file in backup_folder.glob("*.py"):
+        if py_file.name != "backup_all.py":  # 不覆盖备份脚本本身
+            shutil.copy2(py_file, base_dir / py_file.name)
+    
+    # 3. 恢复静态文件
+    static_backup = backup_folder / "static"
+    if static_backup.exists():
+        print("🎨 恢复静态文件...")
+        static_dir = base_dir / "static"
+        if static_dir.exists():
+            shutil.rmtree(static_dir)
+        shutil.copytree(static_backup, static_dir)
+    
+    # 4. 恢复工具文件
+    tools_backup = backup_folder / "tools"
+    if tools_backup.exists():
+        print("🔧 恢复工具文件...")
+        tools_dir = base_dir / "tools"
+        if tools_dir.exists():
+            shutil.rmtree(tools_dir)
+        shutil.copytree(tools_backup, tools_dir)
+    
+    # 5. 恢复守护进程
+    daemon_backup = backup_folder / "daemon"
+    if daemon_backup.exists():
+        print("👻 恢复守护进程...")
+        daemon_dir = base_dir / "daemon"
+        if daemon_dir.exists():
+            shutil.rmtree(daemon_dir)
+        shutil.copytree(daemon_backup, daemon_dir)
+    
+    print("\n✅ 恢复完成！")
+    print("🚀 现在可以启动服务器：python main.py")
+
+def list_backups():
+    """列出所有备份"""
+    backup_dir = Path(__file__).parent / "backups"
+    
+    if not backup_dir.exists():
+        print("❌ 没有找到备份文件夹")
+        return
+    
+    print("📦 可用备份：")
+    print("-" * 60)
+    
+    for backup_folder in sorted(backup_dir.iterdir()):
+        if backup_folder.is_dir():
+            manifest_file = backup_folder / "backup_manifest.json"
+            if manifest_file.exists():
+                with open(manifest_file, 'r', encoding='utf-8') as f:
+                    manifest = json.load(f)
+                
+                date = manifest.get("backup_date", "未知")
+                files = len(manifest.get("files", []))
+                db_status = "✓" if manifest.get("database", {}).get("exists") else "✗"
+                
+                print(f"📁 {backup_folder.name}")
+                print(f"   日期：{date}")
+                print(f"   文件数：{files}")
+                print(f"   数据库：{db_status}")
+                print("-" * 60)
+
+if __name__ == "__main__":
+    import sys
+    
+    if len(sys.argv) > 1:
+        command = sys.argv[1]
+        
+        if command == "backup":
+            create_backup()
+        
+        elif command == "restore":
+            if len(sys.argv) > 2:
+                restore_from_backup(sys.argv[2])
+            else:
+                print("❌ 请指定备份文件夹路径")
+                print("用法：python backup_all.py restore <备份文件夹>")
+        
+        elif command == "list":
+            list_backups()
+        
+        else:
+            print("❌ 未知命令")
+            print("用法:")
+            print("  python backup_all.py backup   - 创建备份")
+            print("  python backup_all.py restore <文件夹> - 从备份恢复")
+            print("  python backup_all.py list     - 列出所有备份")
+    else:
+        # 默认创建备份
+        create_backup()

ai-life-assistant-copy/backups/backup_20260404_193836/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/backups/backup_20260404_193836/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/backups/backup_20260404_193836/daemon/__init__.py

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

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

@@ -0,0 +1,174 @@
+"""生活助手守护进程"""
+
+import threading
+import time
+import schedule
+from typing import Dict, Any, List
+import json
+import os
+from datetime import datetime
+
+class LifeAssistantDaemon:
+    """生活助手守护进程"""
+    
+    def __init__(self, user_id: str = "default"):
+        self.user_id = user_id
+        self.running = False
+        self.thread = None
+        self.memory = self._load_memory()
+        self.triggers = {
+            "stock_check": self._check_stock,
+            "weather_alert": self._check_weather,
+            "reminder_check": self._check_reminders,
+            "habit_analysis": self._analyze_habits
+        }
+        
+    def start(self):
+        """启动守护进程"""
+        if self.running:
+            return
+        
+        self.running = True
+        self.thread = threading.Thread(target=self._run, daemon=True)
+        self.thread.start()
+        print(f"[Daemon] 生活助手守护进程已启动")
+    
+    def stop(self):
+        """停止守护进程"""
+        self.running = False
+        if self.thread:
+            self.thread.join()
+        print(f"[Daemon] 生活助手守护进程已停止")
+    
+    def _run(self):
+        """运行守护进程"""
+        # 初始化定时任务
+        self._schedule_tasks()
+        
+        while self.running:
+            schedule.run_pending()
+            time.sleep(1)
+    
+    def _schedule_tasks(self):
+        """调度任务"""
+        # 每天检查库存
+        schedule.every().day.at("08:00").do(self._check_stock)
+        # 每天检查天气
+        schedule.every().day.at("07:00").do(self._check_weather)
+        # 每分钟检查提醒
+        schedule.every().minute.do(self._check_reminders)
+        # 每周分析习惯
+        schedule.every().sunday.at("22:00").do(self._analyze_habits)
+    
+    def _check_stock(self):
+        """检查库存"""
+        print(f"[Daemon] 检查库存 - {datetime.now()}")
+        # 示例：检查常用商品库存
+        stocks = self.memory.get("stocks", {})
+        low_stock_items = []
+        
+        for item, info in stocks.items():
+            if info.get("stock", 0) < info.get("threshold", 5):
+                low_stock_items.append(item)
+        
+        if low_stock_items:
+            alert = f"您的以下商品库存不足：{', '.join(low_stock_items)}"
+            self._send_alert("stock", alert)
+    
+    def _check_weather(self):
+        """检查天气"""
+        print(f"[Daemon] 检查天气 - {datetime.now()}")
+        # 示例：检查天气并发送提醒
+        from tools.weather_tool import get_weather
+        weather = get_weather()
+        
+        if weather.get("success"):
+            data = weather.get("data", {})
+            temp = data.get("temperature", "")
+            desc = data.get("description", "")
+            
+            alert = f"今日天气：{temp}，{desc}"
+            self._send_alert("weather", alert)
+    
+    def _check_reminders(self):
+        """检查提醒"""
+        now = datetime.now()
+        current_time = now.strftime("%H:%M")
+        current_date = now.strftime("%Y-%m-%d")
+        
+        # 示例：检查提醒
+        from tools.reminder_tool import get_reminders
+        reminders = get_reminders(current_date)
+        
+        if reminders.get("success"):
+            for reminder in reminders.get("reminders", []):
+                if reminder.get("time") == current_time:
+                    alert = f"提醒：{reminder.get('title')}"
+                    self._send_alert("reminder", alert)
+    
+    def _analyze_habits(self):
+        """分析习惯"""
+        print(f"[Daemon] 分析习惯 - {datetime.now()}")
+        # 示例：分析用户习惯
+        habits = self.memory.get("habits", {})
+        
+        # 简单的习惯分析
+        if habits:
+            analysis = "习惯分析：\n"
+            for habit, data in habits.items():
+                frequency = data.get("frequency", 0)
+                analysis += f"- {habit}: 频率 {frequency}次/周\n"
+            
+            self._send_alert("habit", analysis)
+    
+    def _send_alert(self, type: str, message: str):
+        """发送提醒"""
+        print(f"[Alert] {type}: {message}")
+        # 这里可以集成到前端通知系统
+    
+    def _load_memory(self) -> Dict[str, Any]:
+        """加载记忆"""
+        memory_file = f"memory_{self.user_id}.json"
+        if os.path.exists(memory_file):
+            try:
+                with open(memory_file, "r", encoding="utf-8") as f:
+                    return json.load(f)
+            except:
+                pass
+        return {
+            "stocks": {
+                "纸巾": {"stock": 3, "threshold": 5},
+                "牙膏": {"stock": 2, "threshold": 3},
+                "洗发水": {"stock": 1, "threshold": 2}
+            },
+            "habits": {
+                "购物": {"frequency": 3},
+                "外卖": {"frequency": 2},
+                "打车": {"frequency": 1}
+            }
+        }
+    
+    def save_memory(self):
+        """保存记忆"""
+        memory_file = f"memory_{self.user_id}.json"
+        with open(memory_file, "w", encoding="utf-8") as f:
+            json.dump(self.memory, f, ensure_ascii=False, indent=2)
+    
+    def add_habit(self, habit: str):
+        """添加习惯"""
+        if "habits" not in self.memory:
+            self.memory["habits"] = {}
+        
+        if habit not in self.memory["habits"]:
+            self.memory["habits"][habit] = {"frequency": 0}
+        
+        self.memory["habits"][habit]["frequency"] += 1
+        self.save_memory()
+    
+    def update_stock(self, item: str, stock: int):
+        """更新库存"""
+        if "stocks" not in self.memory:
+            self.memory["stocks"] = {}
+        
+        self.memory["stocks"][item] = {"stock": stock, "threshold": 5}
+        self.save_memory()