Update app.py

app.py

@@ -8,13 +8,18 @@ from datetime import datetime
 import logging
 import re
 import os
+import requests
+import asyncio
+import aiohttp
+import gc
+import threading
 
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-app = FastAPI(title="Windows AI Controller - الخادم المركزي الحقيقي")
+app = FastAPI(title="Windows AI Controller - النسخة الذكية المجانية")
 
-# تمكين CORS للسماح بالاتصال من تطبيبات Windows
+# تمكين CORS
 app.add_middleware(
     CORSMiddleware,
     allow_origins=["*"],
@@ -23,32 +28,96 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
-# تخزين البيانات - نظام الذاكرة الكامل
-pending_commands = {}
-client_results = {}
-connected_clients = {}
-
-# نظام الذاكرة الجديد
-client_memories = {}  # ذاكرة المحادثات لكل عميل
-game_analysis_memory = {}  # ذاكرة تحليل الألعاب
-system_info_memory = {}  # ذاكرة معلومات النظام
-installed_programs_memory = {}  # ذاكرة البرامج المثبتة
-action_history_memory = {}  # سجل الإجراءات
-
-class WindowsCommand(BaseModel):
-    command_type: str
-    target_game: Optional[str] = None
-    action: str
-    parameters: Dict = {}
-    client_id: str
-
-class ClientResult(BaseModel):
-    client_id: str
-    command_id: str
-    result: Dict
-    status: str
-
-# نماذج جديدة للمحادثة
+# 🔥 نظام إدارة النماذج الذكي
+class SmartModelManager:
+    def __init__(self):
+        self.loaded_models = {}
+        self.model_lock = threading.Lock()
+        
+        # نماذج Hugging Face المجانية الموصى بها
+        self.models_config = {
+            "arabic_general": {
+                "name": "aubmindlab/aragpt2-mega",  # نموذج عربي قوي
+                "type": "text-generation",
+                "description": "النموذج العربي للفهم العام والردود"
+            },
+            "coding_expert": {
+                "name": "microsoft/DialoGPT-medium",  # بديل جيد للبرمجة
+                "type": "text-generation", 
+                "description": "نموذج البرمجة والأمن السيبراني"
+            },
+            "cyber_security": {
+                "name": "google/flan-t5-base",  # نموذج متعدد المهام
+                "type": "text2text-generation",
+                "description": "نموذج الأمن السيبراني المتخصص"
+            }
+        }
+    
+    def load_model(self, model_type: str):
+        """تحميل نموذج من Hugging Face عند الحاجة فقط"""
+        with self.model_lock:
+            if model_type in self.loaded_models:
+                logger.info(f"✅ النموذج {model_type} محمل بالفعل")
+                return self.loaded_models[model_type]
+            
+            try:
+                logger.info(f"📥 جاري تحميل النموذج {model_type}...")
+                
+                model_config = self.models_config[model_type]
+                
+                if model_config["type"] == "text-generation":
+                    from transformers import AutoTokenizer, AutoModelForCausalLM, pipeline
+                    
+                    # تحميل النموذج باستخدام pipeline
+                    model = pipeline(
+                        "text-generation",
+                        model=model_config["name"],
+                        tokenizer=model_config["name"],
+                        device=-1,  # استخدام CPU
+                        max_length=500,
+                        do_sample=True,
+                        temperature=0.7
+                    )
+                    
+                elif model_config["type"] == "text2text-generation":
+                    from transformers import pipeline
+                    
+                    model = pipeline(
+                        "text2text-generation",
+                        model=model_config["name"],
+                        max_length=500,
+                        device=-1
+                    )
+                
+                self.loaded_models[model_type] = model
+                logger.info(f"✅ تم تحميل النموذج {model_type} بنجاح")
+                return model
+                
+            except Exception as e:
+                logger.error(f"❌ فشل تحميل النموذج {model_type}: {e}")
+                return None
+    
+    def unload_model(self, model_type: str):
+        """إلغاء تحميل النموذج لتحرير الذاكرة"""
+        with self.model_lock:
+            if model_type in self.loaded_models:
+                del self.loaded_models[model_type]
+                gc.collect()  # تنظيف الذاكرة
+                logger.info(f"🗑️ تم إلغاء تحميل النموذج {model_type}")
+    
+    def unload_all_models(self):
+        """إلغاء تحمي�� جميع النماذج"""
+        with self.model_lock:
+            model_types = list(self.loaded_models.keys())
+            for model_type in model_types:
+                self.unload_model(model_type)
+            logger.info("🧹 تم إلغاء تحميل جميع النماذج")
+    
+    def get_loaded_models(self):
+        """الحصول على قائمة النماذج المحملة"""
+        return list(self.loaded_models.keys())
+
+# هياكل البيانات
 class ChatRequest(BaseModel):
     message: str
     client_id: str
@@ -68,789 +137,477 @@ class ClientRegistration(BaseModel):
     timestamp: str
     agent_type: str
 
-class MemoryEntry(BaseModel):
-    timestamp: str
-    type: str  # conversation, game_analysis, system_info, action_result, installed_programs
-    data: Dict[str, Any]
-    client_id: str
-
-def update_client_activity(client_id: str, activity: str = "chat"):
-    """تحديث نشاط العميل"""
-    connected_clients[client_id] = {
-        "last_seen": datetime.now().isoformat(),
-        "status": "active",
-        "last_activity": activity,
-        "message_count": connected_clients.get(client_id, {}).get("message_count", 0) + 1
-    }
-    logger.info(f"📊 تم تحديث نشاط العميل {client_id}: {activity}")
-
-def save_to_memory(client_id: str, memory_type: str, data: Dict[str, Any]):
-    """حفظ البيانات في الذاكرة"""
-    if client_id not in client_memories:
-        client_memories[client_id] = []
-    
-    memory_entry = {
-        "timestamp": datetime.now().isoformat(),
-        "type": memory_type,
-        "data": data,
-        "client_id": client_id
-    }
-    
-    client_memories[client_id].append(memory_entry)
-    
-    # حفظ فقط آخر 1000 إدخال لكل عميل لمنع استهلاك الذاكرة
-    if len(client_memories[client_id]) > 1000:
-        client_memories[client_id] = client_memories[client_id][-1000:]
-    
-    logger.info(f"💾 تم حفظ بيانات في الذاكرة للعميل {client_id}: {memory_type}")
-
-def get_client_memory(client_id: str, memory_type: str = None, limit: int = 10):
-    """استرجاع الذاكرة للعميل"""
-    if client_id not in client_memories:
-        return []
-    
-    memories = client_memories[client_id]
-    
-    if memory_type:
-        memories = [m for m in memories if m["type"] == memory_type]
-    
-    return memories[-limit:]
-
-def save_game_analysis(client_id: str, game_name: str, analysis_data: Dict[str, Any]):
-    """حفظ تحليل اللعبة في الذاكرة"""
-    if client_id not in game_analysis_memory:
-        game_analysis_memory[client_id] = {}
-    
-    if game_name not in game_analysis_memory[client_id]:
-        game_analysis_memory[client_id][game_name] = []
-    
-    analysis_entry = {
-        "timestamp": datetime.now().isoformat(),
-        "analysis_data": analysis_data,
-        "client_id": client_id
-    }
-    
-    game_analysis_memory[client_id][game_name].append(analysis_entry)
-    
-    # أيضا حفظ في الذاكرة العامة
-    save_to_memory(client_id, "game_analysis", {
-        "game_name": game_name,
-        "analysis_data": analysis_data
-    })
-    
-    logger.info(f"🎮 تم حفظ تحليل اللعبة {game_name} للعميل {client_id}")
-
-def get_game_analysis(client_id: str, game_name: str = None):
-    """استرجاع تحليل الألعاب"""
-    if client_id not in game_analysis_memory:
-        return {}
-    
-    if game_name:
-        return game_analysis_memory[client_id].get(game_name, [])
-    else:
-        return game_analysis_memory[client_id]
-
-def save_system_info(client_id: str, system_info: Dict[str, Any]):
-    """حفظ معلومات النظام"""
-    system_info_memory[client_id] = {
-        "timestamp": datetime.now().isoformat(),
-        "system_info": system_info
-    }
-    
-    # أيضا حفظ في الذاكرة العامة
-    save_to_memory(client_id, "system_info", system_info)
-    
-    logger.info(f"💻 تم حفظ معلومات النظام للعميل {client_id}")
-
-def get_system_info(client_id: str):
-    """استرجاع معلومات النظام"""
-    return system_info_memory.get(client_id, {})
+# 🔥 نظام الذاكرة المتقدم
+model_manager = SmartModelManager()
+client_memories = {}
+conversation_contexts = {}
 
-def save_installed_programs(client_id: str, programs_data: Dict[str, Any]):
-    """حفظ البرامج المثبتة"""
-    installed_programs_memory[client_id] = {
-        "timestamp": datetime.now().isoformat(),
-        "programs": programs_data
-    }
-    
-    # أيضا حفظ في الذاكرة العامة
-    save_to_memory(client_id, "installed_programs", programs_data)
-    
-    logger.info(f"📦 تم حفظ بيانات البرامج المثبتة للعميل {client_id}")
-
-def get_installed_programs(client_id: str):
-    """استرجاع البرامج المثبتة"""
-    return installed_programs_memory.get(client_id, {})
-
-def save_action_history(client_id: str, action_data: Dict[str, Any]):
-    """حفظ سجل الإجراءات"""
-    if client_id not in action_history_memory:
-        action_history_memory[client_id] = []
-    
-    action_entry = {
-        "timestamp": datetime.now().isoformat(),
-        "action_data": action_data
-    }
-    
-    action_history_memory[client_id].append(action_entry)
-    
-    # أيضا حفظ في الذاكرة العامة
-    save_to_memory(client_id, "action_history", action_data)
-    
-    logger.info(f"📝 تم حفظ إجراء في السجل للعميل {client_id}: {action_data.get('action_type', 'unknown')}")
-
-def get_action_history(client_id: str, limit: int = 20):
-    """استرجاع سجل الإجراءات"""
-    if client_id not in action_history_memory:
-        return []
-    
-    return action_history_memory[client_id][-limit:]
-
-def extract_file_name(file_path: str) -> str:
-    """استخراج اسم الملف من المسار - الإصلاح هنا"""
+# 🔥 نظام البحث المتكامل
+async def search_web(query: str, max_results: int = 3) -> List[Dict]:
+    """بحث ذكي على الويب"""
     try:
-        if '/' in file_path:
-            return file_path.split('/')[-1]
-        elif '\\' in file_path:
-            return file_path.split('\\')[-1]
-        else:
-            return file_path
-    except Exception:
-        return file_path
-
-@app.get("/")
-async def root():
-    total_memories = sum(len(memories) for memories in client_memories.values())
-    return {
-        "status": "running",
-        "service": "Windows AI Controller Server - النسخة الحقيقية مع الذاكرة",
-        "timestamp": datetime.now().isoformat(),
-        "connected_clients": len(connected_clients),
-        "pending_commands": len(pending_commands),
-        "active_clients": list(connected_clients.keys()),
-        "total_memories": total_memories,
-        "memory_stats": {
-            "conversations": total_memories,
-            "game_analyses": sum(len(analyses) for analyses in game_analysis_memory.values()),
-            "system_info": len(system_info_memory),
-            "installed_programs": len(installed_programs_memory)
-        }
-    }
-
-@app.post("/api/chat")
-async def chat_with_ai(request: ChatRequest):
-    """نقطة النهاية للمحادثة مع الذكاء الاصطناعي - النسخة المحسنة"""
-    try:
-        logger.info(f"💬 طلب محادثة من العميل {request.client_id}: {request.message}")
-        update_client_activity(request.client_id, "chat")
-        
-        # حفظ المحادثة في الذاكرة
-        save_to_memory(request.client_id, "conversation", {
-            "user_message": request.message,
-            "timestamp": request.timestamp,
-            "direction": "incoming"
-        })
-        
-        user_message = request.message.lower()
-        
-        # تحليل الطلب وتحديد الإجراءات الحقيقية
-        if "مسح" in user_message and "برامج" in user_message:
-            return await handle_scan_programs(request)
-        elif "مسح" in user_message and "عمليات" in user_message:
-            return await handle_scan_processes(request)
-        elif "هندسة عكسية" in user_message or "reverse engineer" in user_message:
-            return await handle_reverse_engineering(request)
-        elif "بوت" in user_message or "bot" in user_message:
-            return await handle_bot_development(request)
-        elif "شاشة" in user_message or "screenshot" in user_message:
-            return await handle_screenshot(request)
-        elif "ذاكرة" in user_message or "memory" in user_message:
-            return await handle_memory_scan(request)
-        elif "تثبيت" in user_message or "install" in user_message:
-            return await handle_tool_installation(request)
-        elif "الذاكرة" in user_message or "memory" in user_message:
-            return await handle_memory_query(request)
-        elif "ماذا تستطيع" in user_message or "الميزات" in user_message or "capabilities" in user_message:
-            return await handle_capabilities_query(request)
-        else:
-            return await handle_general_conversation(request)
+        async with aiohttp.ClientSession() as session:
+            # استخدام DuckDuckGo API مجاني
+            url = f"https://api.duckduckgo.com/?q={query}&format=json"
+            
+            try:
+                async with session.get(url, timeout=10) as response:
+                    if response.status == 200:
+                        data = await response.json()
+                        results = []
+                        
+                        # استخراج النتائج من DuckDuckGo
+                        if 'Results' in data:
+                            for item in data['Results'][:max_results]:
+                                results.append({
+                                    "title": item.get('Text', ''),
+                                    "url": item.get('FirstURL', ''),
+                                    "snippet": item.get('Text', '')[:200]
+                                })
+                        
+                        # إذا لم توجد نتائج، استخدام Abstract
+                        if not results and 'Abstract' in data:
+                            results.append({
+                                "title": data.get('Heading', 'نتيجة البحث'),
+                                "url": data.get('AbstractURL', ''),
+                                "snippet": data.get('Abstract', '')[:200]
+                            })
+                        
+                        return results
+            except:
+                pass
+            
+            # استخدام fallback بسيط
+            return [
+                {
+                    "title": f"نتائج البحث عن: {query}",
+                    "url": "",
+                    "snippet": "يمكنني مساعدتك في هذا الموضوع بناءً على معرفتي التقنية."
+                }
+            ]
             
     except Exception as e:
-        logger.error(f"❌ خطأ في معالجة المحادثة: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
+        logger.error(f"❌ خطأ في البحث: {e}")
+        return []
 
-async def handle_scan_programs(request: ChatRequest):
-    """معالجة طلب مسح البرامج"""
-    thinking = "المستخدم يطلب مسح البرامج المثبتة. جاري إعداد أمر المسح الشامل."
+# 🔥 نظام التفكير المتقدم المحسن
+class AdvancedThinker:
+    def __init__(self):
+        self.thinking_steps = []
+        self.knowledge_base = {
+            "cybersecurity": [
+                "تعديل الذاكرة: استخدام Cheat Engine، قراءة/كتابة الذاكرة",
+                "الهندسة العكسية: IDA Pro، x64dbg، تحليل assembly",
+                "تحليل الشبكات: Wireshark، تحليل الحزم",
+                "تطوير البوتات: OpenCV للكشف، PyAutoGUI للأتمتة"
+            ],
+            "game_hacking": [
+                "البحث عن القيم في الذاكرة: المال، الصحة، الذخيرة",
+                "تعديل المتغيرات: float، int، string",
+                "حقن الـ DLL: تعديل السلوك أثناء التشغيل",
+                "تخطي الحماية: Anti-Cheat bypass"
+            ],
+            "programming": [
+                "Python: pyautogui, opencv, pymem, requests",
+                "C++: كتابة برامج تعديل الذاكرة",
+                "C#: تطوير أدوات الويندوز",
+                "التجميع: فهم التعليمات المنخفضة المستوى"
+            ]
+        }
     
-    response = ChatResponse(
-        thinking_process=thinking,
-        message="جاري مسح البرامج المثبتة على جهازك...",
-        actions=[
-            {
-                "type": "scan_installed_programs",
-                "description": "مسح شامل للبرامج المثبتة على النظام",
-                "parameters": {
-                    "scan_type": "comprehensive",
-                    "include_versions": True,
-                    "save_to_memory": True
-                }
-            }
-        ]
-    )
-    return response
-
-async def handle_scan_processes(request: ChatRequest):
-    """معالجة طلب مسح العمليات"""
-    thinking = "المستخدم يريد مسح العمليات النشطة. تحديد العمليات الجارية والألعاب النشطة."
+    def analyze_request(self, user_message: str, context: List[Dict]) -> Dict:
+        """تحليل متقدم للطلب"""
+        self.thinking_steps = []
+        
+        # الخطوة 1: فهم النية الأساسية
+        intent = self._detect_intent(user_message)
+        self.thinking_steps.append(f"📝 النية المكتشفة: {intent}")
+        
+        # الخطوة 2: تحليل السياق
+        context_analysis = self._analyze_context(context)
+        self.thinking_steps.append(f"🔍 تحليل السياق: {context_analysis}")
+        
+        # الخطوة 3: تحديد النموذج المطلوب
+        required_model = self._determine_model(intent, user_message)
+        self.thinking_steps.append(f"🤖 النموذج المطلوب: {required_model}")
+        
+        # الخطوة 4: تحديد الإجراءات
+        required_actions = self._determine_actions(intent, user_message)
+        self.thinking_steps.append(f"⚡ الإجراءات المطلوبة: {len(required_actions)} إجراء")
+        
+        return {
+            "intent": intent,
+            "context_analysis": context_analysis,
+            "required_model": required_model,
+            "required_actions": required_actions,
+            "thinking_steps": self.thinking_steps
+        }
     
-    response = ChatResponse(
-        thinking_process=thinking,
-        message="جاري مسح العمليات النشطة على جهازك...",
-        actions=[
-            {
-                "type": "scan_running_processes",
-                "description": "مسح العمليات النشطة على النظام",
-                "parameters": {
-                    "include_memory_usage": True,
-                    "detect_games": True,
-                    "save_to_memory": True
-                }
-            }
-        ]
-    )
-    return response
-
-async def handle_reverse_engineering(request: ChatRequest):
-    """معالجة طلب الهندسة العكسية"""
-    thinking = "المستخدم يطلب هندسة عكسية لملف. تحديد المسار وتحليل المتطلبات."
+    def _detect_intent(self, message: str) -> str:
+        """كشف النية بدقة"""
+        message_lower = message.lower()
+        
+        intents = {
+            "counting": [r'عد\s+من\s+\d+\s+إلى\s+\d+', r'count\s+from\s+\d+\s+to\s+\d+', r'رَقِّم', r'اعدد'],
+            "greeting": ["مرحبا", "اهلا", "سلام", "hello", "hi", "اهلاً", "أهلاً"],
+            "technical_request": ["بوت", "bot", "هندسة", "reverse", "ذاكرة", "memory", "تعديل", "mod"],
+            "coding": ["برمجة", "code", "سكريبت", "script", "أكواد", "مشروع", "برمج", "كود"],
+            "game_hacking": ["تهكير", "hack", "مخترق", "هاكر", "cheat", "غش", "تعديل لعبة", "هاكينغ"],
+            "cybersecurity": ["أمن", "حماية", "اختراق", "هاكر", "hack", "security", "سيبر", "cyber"],
+            "question": ["كيف", "لماذا", "متى", "أين", "ماذا", "هل", "?"],
+            "research": ["ابحث", "بحث", "information", "معلومات", "دراسة", "أعطيني معلومات"]
+        }
+        
+        for intent, patterns in intents.items():
+            for pattern in patterns:
+                if isinstance(pattern, str):
+                    if pattern in message_lower:
+                        return intent
+                else:  # regex pattern
+                    if re.search(pattern, message_lower):
+                        return intent
+        
+        return "general_conversation"
     
-    # استخراج مسار الملف من الرسالة
-    file_path = extract_file_path(request.message)
+    def _analyze_context(self, context: List[Dict]) -> str:
+        """تحليل سياق المحادثة"""
+        if not context:
+            return "محادثة جديدة"
+        
+        last_messages = context[-3:]
+        topics = []
+        
+        for msg in last_messages:
+            user_msg = msg.get('user', '').lower()
+            if any(word in user_msg for word in ["بوت", "bot"]):
+                topics.append("تطوير البوتات")
+            elif any(word in user_msg for word in ["هندسة", "reverse"]):
+                topics.append("الهندسة العكسية")
+            elif any(word in user_msg for word in ["تهكير", "hack"]):
+                topics.append("الأمن السيبراني")
+            elif any(word in user_msg for word in ["برمجة", "code"]):
+                topics.append("البرمجة")
+        
+        return "، ".join(topics) if topics else "مواضيع عامة"
+    
+    def _determine_model(self, intent: str, message: str) -> str:
+        """تحديد النموذج المناسب"""
+        if intent in ["coding", "technical_request", "game_hacking"]:
+            return "coding_expert"
+        elif intent in ["cybersecurity"]:
+            return "cyber_security"
+        else:
+            return "arabic_general"
     
-    if not file_path:
-        response = ChatResponse(
-            thinking_process=thinking + " لم يتم تحديد مسار الملف. طلب التوضيح من المستخدم.",
-            message="أحتاج إلى مسار الملف للبدء في الهندسة العكسية. مثال: `F:\\Coven Kal\\engine.exe`",
-            actions=[
-                {
-                    "type": "prepare_reverse_engineering",
-                    "description": "تحضير بيئة الهندسة العكسية",
-                    "parameters": {}
-                }
-            ]
-        )
-    else:
-        # استخراج اسم الملف فقط للعرض - الإصلاح هنا
-        file_name = extract_file_name(file_path)
+    def _determine_actions(self, intent: str, message: str) -> List[Dict]:
+        """تحديد الإجراءات المطلوبة"""
+        actions = []
         
-        response = ChatResponse(
-            thinking_process=thinking + f" تم تحديد المسار: {file_path}. جاري إعداد أدوات الهندسة العكسية.",
-            message=f"جاري تحضير ��لهندسة العكسية للملف: `{file_path}`",
-            actions=[
+        if intent == "counting":
+            # لا يحتاج لإجراءات - سينفذ مباشرة
+            pass
+        elif intent == "technical_request":
+            if "بوت" in message.lower() or "bot" in message.lower():
+                actions.append({
+                    "type": "prepare_bot_development",
+                    "description": "تحضير بيئة تطوير البوتات المتقدمة",
+                    "priority": "high"
+                })
+            if "هندسة" in message.lower() or "reverse" in message.lower():
+                actions.append({
+                    "type": "prepare_reverse_engineering",
+                    "description": "تحضير أدوات الهندسة العكسية المتقدمة", 
+                    "priority": "high"
+                })
+        elif intent == "game_hacking":
+            actions.extend([
                 {
-                    "type": "reverse_engineer",
-                    "description": f"هندسة عكسية متقدمة للملف {file_name}",
-                    "parameters": {
-                        "file_path": file_path,
-                        "analysis_depth": "deep",
-                        "extract_resources": True,
-                        "analyze_imports": True,
-                        "save_to_memory": True
-                    }
+                    "type": "scan_running_processes", 
+                    "description": "مسح العمليات النشطة للألعاب",
+                    "priority": "medium"
                 },
                 {
-                    "type": "analyze_game_file",
-                    "description": f"تحليل بنية ملف اللعبة",
-                    "parameters": {
-                        "file_path": file_path,
-                        "save_to_memory": True
-                    }
-                }
-            ]
-        )
-    
-    return response
-
-async def handle_bot_development(request: ChatRequest):
-    """معالجة طلب تطوير البوت"""
-    thinking = "المستخدم يطلب تطوير بوت. تحديد نوع البوت واللعبة المستهدفة."
-    
-    game_name = extract_game_name(request.message)
-    bot_type = extract_bot_type(request.message)
-    
-    if not game_name:
-        response = ChatResponse(
-            thinking_process=thinking + " لم يتم تحديد اسم اللعبة. طلب التوضيح.",
-            message="أخبرني اسم اللعبة ونوع البوت المطلوب (مزرعة، قتال، إلخ).",
-            actions=[
-                {
-                    "type": "prepare_bot_development",
-                    "description": "تحضير بيئة تطوير البوتات",
-                    "parameters": {}
-                }
-            ]
-        )
-    else:
-        response = ChatResponse(
-            thinking_process=thinking + f" تطوير بوت {bot_type} للعبة {game_name}.",
-            message=f"بدأت تطوير بوت {bot_type} للعبة {game_name}.",
-            actions=[
-                {
-                    "type": "develop_bot",
-                    "description": f"تطوير بوت {bot_type} للعبة {game_name}",
-                    "parameters": {
-                        "game_name": game_name,
-                        "bot_type": bot_type,
-                        "features": ["auto_detection", "memory_control", "image_recognition", "screen_capture"],
-                        "save_to_memory": True
-                    }
+                    "type": "install_tool",
+                    "description": "تثبيت أدوات التعديل",
+                    "parameters": {"tool_name": "cheatengine"},
+                    "priority": "high"
                 }
-            ]
-        )
-    
-    return response
+            ])
+        elif intent == "research":
+            actions.append({
+                "type": "web_research",
+                "description": "البحث عن المعلومات المطلوبة",
+                "parameters": {"query": message},
+                "priority": "medium"
+            })
+        
+        # إجراء عام للمحادثة
+        if not actions:
+            actions.append({
+                "type": "general_analysis",
+                "description": "تحليل المهمة العامة",
+                "priority": "low"
+            })
+        
+        return actions
 
-async def handle_screenshot(request: ChatRequest):
-    """معالجة طلب تصوير الشاشة"""
-    thinking = "المستخدم يطلب تصوير شاشة جهازه. إعداد أمر التقاط الصورة."
-    
-    response = ChatResponse(
-        thinking_process=thinking,
-        message="جاري التقاط صورة لشاشة جهازك...",
-        actions=[
-            {
-                "type": "take_screenshot",
-                "description": "التقا�� صورة للشاشة الحالية",
-                "parameters": {
-                    "save_path": f"screenshots/screen_{datetime.now().strftime('%Y%m%d_%H%M%S')}.png",
-                    "save_to_memory": True
-                }
-            }
-        ]
-    )
-    return response
+# 🔥 النظام الرئيسي المحسن
+thinker = AdvancedThinker()
 
-async def handle_memory_scan(request: ChatRequest):
-    """معالجة طلب مسح الذاكرة"""
-    thinking = "المستخدم يريد مسح ذاكرة لعبة. تحديد اسم العملية المستهدفة."
-    
-    process_name = extract_process_name(request.message)
-    
-    if not process_name:
-        response = ChatResponse(
-            thinking_process=thinking + " لم يتم تحديد اسم العملية. طلب التوضيح.",
-            message="أخبرني اسم العملية أو اللعبة التي تريد مسح ذاكرتها.",
-            actions=[]
-        )
-    else:
-        response = ChatResponse(
-            thinking_process=thinking + f" مسح ذاكرة العملية: {process_name}.",
-            message=f"جاري مسح ذاكرة اللعبة: {process_name}",
-            actions=[
-                {
-                    "type": "scan_game_memory",
-                    "description": f"مسح ذاكرة العملية {process_name}",
-                    "parameters": {
-                        "process_name": process_name,
-                        "scan_for": ["money", "health", "ammo", "experience"],
-                        "save_to_memory": True
-                    }
-                }
-            ]
-        )
-    
-    return response
+async def generate_with_model(model_type: str, prompt: str, max_length: int = 500) -> str:
+    """توليد النص باستخدام النموذج المحدد"""
+    try:
+        model = model_manager.load_model(model_type)
+        if model is None:
+            return f"عذراً، لا يمكن تحميل النموذج {model_type} حالياً."
+        
+        # توليد النص بناءً على نوع النموذج
+        if model_type == "arabic_general":
+            result = model(
+                prompt,
+                max_length=max_length,
+                num_return_sequences=1,
+                temperature=0.7,
+                do_sample=True,
+                pad_token_id=50256
+            )
+            response = result[0]['generated_text']
+            
+        elif model_type == "coding_expert":
+            result = model(
+                prompt,
+                max_length=max_length,
+                temperature=0.7,
+                do_sample=True
+            )
+            response = result[0]['generated_text']
+            
+        elif model_type == "cyber_security":
+            result = model(prompt, max_length=max_length)
+            response = result[0]['generated_text']
+        
+        # تنظيف الاستجابة
+        response = response.replace(prompt, "").strip()
+        
+        # إلغاء تحميل النموذج بعد الاستخدام لتوفير الذاكرة
+        model_manager.unload_model(model_type)
+        
+        return response if response else "أفهم طلبك، ولكن أحتاج إلى مزيد من التوضيح."
+        
+    except Exception as e:
+        logger.error(f"❌ خطأ في توليد النص: {e}")
+        model_manager.unload_model(model_type)  # تنظيف الذاكرة في حالة الخطأ
+        return "عذراً، حدث خطأ أثناء المعالجة. هل يمكنك إعادة المحاولة؟"
 
-async def handle_tool_installation(request: ChatRequest):
-    """معالجة طلب تثبيت الأدوات"""
-    thinking = "المستخدم يريد تثبيت أداة. تحديد الأداة المطلوبة."
+def handle_simple_requests(message: str) -> Optional[str]:
+    """معالجة الطلبات البسيطة مباشرة دون نماذج"""
+    message_lower = message.lower()
     
-    tool_name = extract_tool_name(request.message)
+    # طلبات العد
+    counting_match = re.search(r'عد\s+من\s+(\d+)\s+إلى\s+(\d+)', message_lower)
+    if counting_match:
+        start = int(counting_match.group(1))
+        end = int(counting_match.group(2))
+        if start < end:
+            numbers = " ".join(str(i) for i in range(start, end + 1))
+            return f"بالطبع: {numbers}"
+        else:
+            return "الرقم الأول يجب أن يكون أصغر من الرقم الثاني"
     
-    if not tool_name:
-        response = ChatResponse(
-            thinking_process=thinking + " لم يتم تحديد الأداة. عرض القائمة.",
-            message="الأدوات المتاحة: cheatengine, python, ida, x64dbg. ما الأداة التي تريدها؟",
-            actions=[]
-        )
-    else:
-        response = ChatResponse(
-            thinking_process=thinking + f" تثبيت الأداة: {tool_name}.",
-            message=f"جاري تثبيت الأداة: {tool_name}",
-            actions=[
-                {
-                    "type": "install_tool",
-                    "description": f"تثبيت أداة {tool_name}",
-                    "parameters": {
-                        "tool_name": tool_name,
-                        "save_to_memory": True
-                    }
-                }
-            ]
-        )
+    # تحيات بسيطة
+    if any(word in message_lower for word in ["مرحبا", "اهلا", "سلام", "hello", "hi"]):
+        return "مرحباً بك! 🚀 أنا المساعد الذكي المتخصص في الأمن السيبراني وتطوير البوتات. كيف يمكنني مساعدتك اليوم؟"
     
-    return response
-
-async def handle_capabilities_query(request: ChatRequest):
-    """معالجة استعلام الميزات"""
-    thinking = "المستخدم يطلب معرفة الميزات المتاحة."
+    # شكر
+    if any(word in message_lower for word in ["شكر", "thank", "مشكور"]):
+        return "على الرحب والسعة! 😊 هل هناك شيء آخر تحتاج المساعدة فيه؟"
     
-    response = ChatResponse(
-        thinking_process=thinking,
-        message="**الميزات المتاحة:**\n\n• 🔍 مسح البرامج والعمليات\n• 🎮 تحليل ذاكرة الألعاب\n• 🤖 تطوير البوتات\n• 🔬 الهندسة العكسية\n• 📸 تصوير الشاشة\n• ⚡ تثبيت الأدوات\n\nما الذي تريد القيام به؟",
-        actions=[]
-    )
-    return response
+    return None
 
-async def handle_memory_query(request: ChatRequest):
-    """معالجة استعلامات الذاكرة"""
-    thinking = "المستخدم يطلب معلومات عن الذاكرة. تجهيز إحصائيات الذاكرة."
+def build_smart_prompt(user_message: str, context: List[Dict], analysis: Dict, model_type: str) -> str:
+    """بناء prompt ذكي حسب نوع النموذج"""
     
-    memory_stats = await get_memory_stats_for_client(request.client_id)
+    context_text = "\n".join([f"المستخدم: {c['user']}\nالمساعد: {c['assistant']}" for c in context[-2:]])
     
-    response = ChatResponse(
-        thinking_process=thinking,
-        message=f"**إحصائيات الذاكرة:**\n• المحادثات: {memory_stats['conversations']}\n• تحليلات الألعاب: {memory_stats['game_analyses']}\n• الإجراءات: {memory_stats['actions']}",
-        actions=[]
-    )
-    return response
+    if model_type == "arabic_general":
+        prompt = f"""
+أنت مساعد ذكي يتحدث العربية بطلاقة. أنت متخصص في:
+- الأمن السيبراني واختبار الاختراق
+- تطوير البوتات وتعديل الألعاب
+- البرمجة والهندسة العكسية
 
-async def handle_general_conversation(request: ChatRequest):
-    """معالجة المحادثة العامة - النسخة المحسنة"""
-    thinking = "تحليل رسالة المستخدم العامة والرد بشكل طبيعي مع تحديد الإجراءات المناسبة."
-    
-    # تحليل نية المستخدم من الرسالة
-    user_intent = analyze_user_intent(request.message)
-    
-    if user_intent == "greeting":
-        response = ChatResponse(
-            thinking_process=thinking + " المستخدم يرسل تحية. الرد بترحيب بسيط.",
-            message="مرحباً! كيف يمكنني مساعدتك اليوم؟",
-            actions=[]
-        )
-    elif user_intent == "thanks":
-        response = ChatResponse(
-            thinking_process=thinking + " المستخدم يشكر. الرد بأدب.",
-            message="على الرحب والسعة! هل هناك شيء آخر تحتاج المساعدة فيه؟",
-            actions=[]
-        )
-    elif user_intent == "question":
-        response = ChatResponse(
-            thinking_process=thinking + " المستخدم يطرح سؤالاً عاماً. تقديم إجابة مفيدة.",
-            message="أفهم سؤالك. يمكنني مساعدتك في مهام مثل تحليل البرامج، تطوير البوتات، الهندسة العكسية، وغيرها. هل يمكنك توضيح طلبك أكثر؟",
-            actions=[]
-        )
-    else:
-        response = ChatResponse(
-            thinking_process=thinking + " رسالة عامة. الرد بشكل طبيعي وتقديم المساعدة.",
-            message="فهمت ما تقصد. سأقوم بمساعدتك في هذا الأمر. هل يمكنك إعطائي المزيد من التفاصيل أو توضيح ما تريد بالضبط؟",
-            actions=[
-                {
-                    "type": "general_analysis",
-                    "description": "تحليل المهمة العامة وتحديد المتطلبات",
-                    "parameters": {
-                        "user_message": request.message,
-                        "analysis_type": "comprehensive",
-                        "save_to_memory": True
-                    }
-                }
-            ]
-        )
-    
-    return response
+المحادثة السابقة:
+{context_text}
 
-def analyze_user_intent(message: str) -> str:
-    """تحليل نية المستخدم من الرسالة"""
-    message_lower = message.lower()
-    
-    greeting_words = ["مرحبا", "اهلا", "سلام", "السلام", "hello", "hi", "hey"]
-    thanks_words = ["شكرا", "متشكر", "thanks", "thank you"]
-    question_words = ["كيف", "لماذا", "متى", "أين", "ماذا", "هل", "?", "what", "how", "when", "where", "why"]
-    
-    if any(word in message_lower for word in greeting_words):
-        return "greeting"
-    elif any(word in message_lower for word in thanks_words):
-        return "thanks"
-    elif any(word in message_lower for word in question_words):
-        return "question"
-    else:
-        return "general"
+المستخدم: {user_message}
 
-async def get_memory_stats_for_client(client_id: str):
-    """الحصول على إحصائيات الذاكرة للعميل"""
-    conversations = len(get_client_memory(client_id, "conversation"))
-    game_analyses = len(get_client_memory(client_id, "game_analysis"))
-    system_info = 1 if client_id in system_info_memory else 0
-    installed_programs = 1 if client_id in installed_programs_memory else 0
-    actions = len(get_action_history(client_id))
+قم بالرد بشكل طبيعي ومفيد باللغة العربية:
+"""
     
-    return {
-        "conversations": conversations,
-        "game_analyses": game_analyses,
-        "system_info": system_info,
-        "installed_programs": installed_programs,
-        "actions": actions
-    }
+    elif model_type == "coding_expert":
+        prompt = f"""
+You are an expert AI assistant specialized in:
+- Cybersecurity and penetration testing  
+- Game hacking and memory modification
+- Bot development and automation
+- Reverse engineering and malware analysis
+- Programming in Python, C++, C#, Assembly
 
-def extract_file_path(message: str) -> str:
-    """استخراج مسار الملف من الرسالة"""
-    # البحث عن أنماط المسارات في النص
-    patterns = [
-        r'[A-Z]:\\[^\s]+',
-        r'/[^\s]+',
-        r'~[^\s]+'
-    ]
-    
-    for pattern in patterns:
-        matches = re.findall(pattern, message)
-        if matches:
-            return matches[0]
-    
-    return ""
+User request: {user_message}
 
-def extract_game_name(message: str) -> str:
-    """استخراج اسم اللعبة من الرسالة"""
-    games = ["Genshin Impact", "Minecraft", "Among Us", "VALORANT", "Overwatch", "Coven Kal", "Fortnite", "Cyberpunk", "Witcher"]
+Provide a detailed technical response in Arabic. Include code examples if relevant:
+"""
     
-    for game in games:
-        if game.lower() in message.lower():
-            return game
-    
-    return ""
+    elif model_type == "cyber_security":
+        prompt = f"""
+You are a cybersecurity expert specializing in:
+- Memory hacking and game modification
+- Reverse engineering executable files
+- Developing security tools and bots
+- Network analysis and packet manipulation
 
-def extract_bot_type(message: str) -> str:
-    """استخراج نوع البوت من الرسالة"""
-    bot_types = {
-        "مزرعة": "farming",
-        "زراعة": "farming", 
-        "قتال": "combat",
-        "قتل": "combat",
-        "تجارة": "trading",
-        "تلقائي": "auto",
-        "حماية": "defense"
-    }
-    
-    for arabic_type, english_type in bot_types.items():
-        if arabic_type in message:
-            return english_type
-    
-    if "farm" in message.lower():
-        return "farming"
-    elif "combat" in message.lower():
-        return "combat"
-    elif "trade" in message.lower():
-        return "trading"
-    
-    return "auto"
+User: {user_message}
 
-def extract_process_name(message: str) -> str:
-    """استخراج اسم العملية من الرسالة"""
-    # البحث عن أسماء العمليات الشائعة
-    common_processes = ["GenshinImpact", "Minecraft", "AmongUs", "VALORANT", "Overwatch", "Fortnite"]
-    
-    for process in common_processes:
-        if process.lower() in message.lower():
-            return process + ".exe"
-    
-    # البحث عن نمط .exe في النص
-    exe_pattern = r'(\w+\.exe)'
-    matches = re.findall(exe_pattern, message, re.IGNORECASE)
-    if matches:
-        return matches[0]
+Provide a professional cybersecurity response in Arabic:
+"""
     
-    return ""
+    return prompt
 
-def extract_tool_name(message: str) -> str:
-    """استخراج اسم الأداة من الرسالة"""
-    tools = {
-        "cheat engine": "cheatengine",
-        "cheatengine": "cheatengine",
-        "python": "python",
-        "ida": "ida",
-        "x64dbg": "x64dbg",
-        "process hacker": "processhacker",
-        "processhacker": "processhacker"
-    }
+async def get_intelligent_response(user_message: str, client_id: str, context: List[Dict] = None) -> Dict[str, Any]:
+    """الحصول على رد ذكي من النموذج المناسب"""
     
-    for tool_name, tool_id in tools.items():
-        if tool_name.lower() in message.lower():
-            return tool_id
+    if context is None:
+        context = []
     
-    return ""
-
-# نقاط النهاية الجديدة للذاكرة
-@app.get("/api/memory/{client_id}")
-async def get_client_memory_endpoint(client_id: str, memory_type: str = None, limit: int = 10):
-    """الحصول على ذاكرة العميل"""
-    try:
-        memories = get_client_memory(client_id, memory_type, limit)
-        return {
-            "success": True,
-            "client_id": client_id,
-            "memories": memories,
-            "total": len(memories)
-        }
-    except Exception as e:
-        logger.error(f"❌ خطأ في استرجاع الذاكرة: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
-
-@app.get("/api/game-analysis/{client_id}")
-async def get_game_analysis_endpoint(client_id: str, game_name: str = None):
-    """الحصول على تحليل الألعاب"""
-    try:
-        analysis = get_game_analysis(client_id, game_name)
-        return {
-            "success": True,
-            "client_id": client_id,
-            "game_analysis": analysis
-        }
-    except Exception as e:
-        logger.error(f"❌ خطأ في استرجاع تحليل الألعاب: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
-
-@app.post("/api/save-system-info/{client_id}")
-async def save_system_info_endpoint(client_id: str, system_info: Dict[str, Any]):
-    """حفظ معلومات النظام"""
     try:
-        save_system_info(client_id, system_info)
-        return {
-            "success": True,
-            "message": "تم حفظ معلومات النظام بنجاح"
-        }
-    except Exception as e:
-        logger.error(f"❌ خطأ في حفظ معلومات النظام: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
-
-@app.get("/api/system-info/{client_id}")
-async def get_system_info_endpoint(client_id: str):
-    """الحصول على معلومات النظام"""
-    try:
-        system_info = get_system_info(client_id)
-        return {
-            "success": True,
-            "client_id": client_id,
-            "system_info": system_info
-        }
-    except Exception as e:
-        logger.error(f"❌ خطأ في استرجاع معلومات النظام: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
-
-@app.post("/api/save-installed-programs/{client_id}")
-async def save_installed_programs_endpoint(client_id: str, programs_data: Dict[str, Any]):
-    """حفظ البرامج المثبتة"""
-    try:
-        save_installed_programs(client_id, programs_data)
-        return {
-            "success": True,
-            "message": "تم حفظ بيانات البرامج المثبتة بنجاح"
-        }
-    except Exception as e:
-        logger.error(f"❌ خطأ في حفظ البرامج المثبتة: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
-
-@app.get("/api/installed-programs/{client_id}")
-async def get_installed_programs_endpoint(client_id: str):
-    """الحصول على البرامج المثبتة"""
-    try:
-        programs = get_installed_programs(client_id)
+        # 🔥 التحليل المتقدم للطلب
+        analysis = thinker.analyze_request(user_message, context)
+        
+        # 🔥 التحقق من الطلبات البسيطة أولاً
+        simple_response = handle_simple_requests(user_message)
+        if simple_response:
+            return {
+                "response": simple_response,
+                "actions": [],
+                "thinking": "طلب بسيط - معالجة مباشرة",
+                "analysis": analysis
+            }
+        
+        # 🔥 البحث إذا لزم الأمر
+        search_results = []
+        if analysis["intent"] in ["research", "technical_request", "game_hacking"]:
+            search_results = await search_web(user_message)
+            analysis["thinking_steps"].append(f"🔎 نتائج البحث: {len(search_results)} نتيجة")
+        
+        # 🔥 بناء prompt ذكي
+        prompt = build_smart_prompt(user_message, context, analysis, analysis["required_model"])
+        
+        # 🔥 الحصول على الرد من النموذج المناسب
+        ai_response = await generate_with_model(analysis["required_model"], prompt)
+        
+        # 🔥 استخراج الإجراءات
+        actions = analysis["required_actions"]
+        
         return {
-            "success": True,
-            "client_id": client_id,
-            "installed_programs": programs
+            "response": ai_response,
+            "actions": actions,
+            "thinking": "\n".join(analysis["thinking_steps"]),
+            "analysis": analysis
         }
+        
     except Exception as e:
-        logger.error(f"❌ خطأ في استرجاع البرامج المثبتة: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
-
-@app.post("/api/save-action-result/{client_id}")
-async def save_action_result_endpoint(client_id: str, action_result: Dict[str, Any]):
-    """حفظ نتيجة الإجراء في الذاكرة"""
-    try:
-        save_action_history(client_id, action_result)
+        logger.error(f"❌ خطأ في النظام الذكي: {e}")
+        # تنظيف الذاكرة في حالة الخطأ
+        model_manager.unload_all_models()
         return {
-            "success": True,
-            "message": "تم حفظ نتيجة الإجراء بنجاح"
+            "response": "أنا هنا لمساعدتك! حدث خطأ تقني بسيط. هل يمكنك إعادة صياغة طلبك؟",
+            "actions": [],
+            "thinking": f"خطأ في المعالجة: {e}"
         }
-    except Exception as e:
-        logger.error(f"❌ خطأ في حفظ نتيجة الإجراء: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
 
-@app.get("/api/action-history/{client_id}")
-async def get_action_history_endpoint(client_id: str, limit: int = 20):
-    """الحصول على سجل الإجراءات"""
+@app.post("/api/chat")
+async def chat_with_ai(request: ChatRequest):
+    """نقطة النهاية للمحادثة الذكية المتقدمة"""
     try:
-        history = get_action_history(client_id, limit)
-        return {
-            "success": True,
-            "client_id": client_id,
-            "action_history": history,
-            "total": len(history)
-        }
+        logger.info(f"💬 محادثة متقدمة من {request.client_id}: {request.message}")
+        
+        # تحديث سياق المحادثة
+        if request.client_id not in conversation_contexts:
+            conversation_contexts[request.client_id] = []
+        
+        context = conversation_contexts[request.client_id]
+        
+        # الحصول على رد ذكي متقدم
+        ai_result = await get_intelligent_response(request.message, request.client_id, context)
+        
+        # تحديث السياق
+        context.append({
+            "user": request.message,
+            "assistant": ai_result["response"],
+            "timestamp": datetime.now().isoformat()
+        })
+        
+        # الحفاظ على آخر 10 رسائل فقط
+        if len(context) > 10:
+            conversation_contexts[request.client_id] = context[-10:]
+        
+        response = ChatResponse(
+            thinking_process=ai_result["thinking"],
+            message=ai_result["response"],
+            actions=ai_result["actions"]
+        )
+        
+        return response
+        
     except Exception as e:
-        logger.error(f"❌ خطأ في استرجاع سجل الإجراءات: {e}")
+        logger.error(f"❌ خطأ في المحادثة المتقدمة: {e}")
         raise HTTPException(status_code=500, detail=str(e))
 
-@app.get("/api/memory-stats")
-async def get_memory_stats_endpoint():
-    """إحصائيات الذاكرة"""
-    total_memories = sum(len(memories) for memories in client_memories.values())
-    total_clients = len(client_memories)
-    total_game_analyses = sum(len(analyses) for analyses in game_analysis_memory.values())
-    total_system_info = len(system_info_memory)
-    total_installed_programs = len(installed_programs_memory)
+@app.get("/api/system-status")
+async def system_status():
+    """حالة النظام مع معلومات النماذج"""
+    loaded_models = model_manager.get_loaded_models()
     
     return {
         "success": True,
-        "total_memories": total_memories,
-        "total_clients": total_clients,
-        "total_game_analyses": total_game_analyses,
-        "total_system_info": total_system_info,
-        "total_installed_programs": total_installed_programs,
-        "clients_with_memory": list(client_memories.keys()),
-        "timestamp": datetime.now().isoformat()
+        "status": "running",
+        "loaded_models": loaded_models,
+        "total_models_available": 3,
+        "memory_management": "active",
+        "server_time": datetime.now().isoformat()
     }
 
-@app.get("/api/client-memory-stats/{client_id}")
-async def get_client_memory_stats_endpoint(client_id: str):
-    """إحصائيات ذاكرة عميل محدد"""
+@app.post("/api/cleanup-memory")
+async def cleanup_memory():
+    """تنظيف الذاكرة يدوياً"""
     try:
-        stats = await get_memory_stats_for_client(client_id)
+        model_manager.unload_all_models()
         return {
             "success": True,
-            "client_id": client_id,
-            "memory_stats": stats,
-            "timestamp": datetime.now().isoformat()
+            "message": "تم تنظ��ف الذاكرة بنجاح",
+            "loaded_models": model_manager.get_loaded_models()
         }
     except Exception as e:
-        logger.error(f"❌ خطأ في إحصائيات الذاكرة: {e}")
+        logger.error(f"❌ خطأ في تنظيف الذاكرة: {e}")
         raise HTTPException(status_code=500, detail=str(e))
 
-# نقاط النهاية القديمة (محفوظة للتوافق)
+# نقاط النهاية الأخرى للتوافق
+@app.get("/")
+async def root():
+    loaded_models = model_manager.get_loaded_models()
+    return {
+        "status": "running",
+        "service": "Windows AI Controller - النسخة الذكية المجانية",
+        "timestamp": datetime.now().isoformat(),
+        "loaded_models": loaded_models,
+        "memory_management": "active"
+    }
+
 @app.post("/api/register-client")
 async def register_client(registration: ClientRegistration):
     """تسجيل عميل جديد"""
     try:
-        connected_clients[registration.client_id] = {
-            "machine_name": registration.machine_name,
-            "os_version": registration.os_version,
-            "agent_type": registration.agent_type,
-            "first_seen": registration.timestamp,
-            "last_seen": datetime.now().isoformat(),
-            "status": "active",
-            "message_count": 0
-        }
-        
-        # حفظ معلومات النظام الأولية في الذاكرة
-        save_system_info(registration.client_id, {
-            "machine_name": registration.machine_name,
-            "os_version": registration.os_version,
-            "agent_type": registration.agent_type,
-            "first_seen": registration.timestamp
-        })
-        
-        logger.info(f"🆕 عميل جديد مسجل: {registration.client_id} - {registration.machine_name}")
-        
+        # يمكن إضافة منطق التسجيل هنا
         return {
             "success": True, 
             "message": "تم تسجيل العميل بنجاح",
@@ -860,136 +617,22 @@ async def register_client(registration: ClientRegistration):
         logger.error(f"❌ خطأ في تسجيل العميل: {e}")
         raise HTTPException(status_code=500, detail=str(e))
 
-@app.post("/api/send-command")
-async def send_command(command: WindowsCommand):
-    """استقبال أمر من العميل وتخزينه"""
-    try:
-        command_id = f"cmd_{int(time.time())}_{command.client_id}"
-        pending_commands[command_id] = {
-            "type": command.command_type,
-            "action": command.action,
-            "target_game": command.target_game,
-            "parameters": command.parameters,
-            "client_id": command.client_id,
-            "timestamp": datetime.now().isoformat(),
-            "status": "pending"
-        }
-        
-        update_client_activity(command.client_id, "command")
-        
-        logger.info(f"📨 تم استلام أمر من العميل {command.client_id}: {command.action}")
-        
-        return {
-            "success": True, 
-            "command_id": command_id,
-            "message": "تم استلام الأمر بنجاح"
-        }
-    except Exception as e:
-        logger.error(f"❌ خطأ في استقبال الأمر: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
-
-@app.get("/api/get-commands/{client_id}")
-async def get_commands(client_id: str):
-    """الحصول على الأوامر المعلقة للعميل"""
-    try:
-        commands = []
-        for cmd_id, cmd in pending_commands.items():
-            if cmd["client_id"] == client_id and cmd["status"] == "pending":
-                commands.append({
-                    "id": cmd_id,
-                    "type": cmd["type"],
-                    "action": cmd["action"],
-                    "target_game": cmd["target_game"],
-                    "parameters": cmd["parameters"]
-                })
-                pending_commands[cmd_id]["status"] = "processing"
-        
-        return {"success": True, "commands": commands}
-    except Exception as e:
-        logger.error(f"❌ خطأ في إرسال الأوامر: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
-
 @app.post("/api/submit-result")
-async def submit_result(result: ClientResult):
+async def submit_result(result: Dict[str, Any]):
     """استقبال النتائج من العميل"""
     try:
-        client_results[result.client_id] = {
-            "command_id": result.command_id,
-            "result": result.result,
-            "status": result.status,
-            "timestamp": datetime.now().isoformat()
-        }
-        
-        update_client_activity(result.client_id, "result")
-        
-        # حفظ نتيجة الإجراء في الذاكرة
-        save_action_history(result.client_id, {
-            "command_id": result.command_id,
-            "result": result.result,
-            "status": result.status,
-            "type": "action_result"
-        })
-        
-        logger.info(f"📊 تم استلام نتيجة من العميل {result.client_id}")
-        
+        # يمكن إضافة منطق معالجة النتائج هنا
         return {"success": True, "message": "تم استلام النتيجة بنجاح"}
     except Exception as e:
         logger.error(f"❌ خطأ في استقبال النتيجة: {e}")
         raise HTTPException(status_code=500, detail=str(e))
 
-@app.get("/api/client-status/{client_id}")
-async def client_status(client_id: str):
-    """الحصول على حالة العميل"""
-    client_data = connected_clients.get(client_id, {})
-    memory_stats = await get_memory_stats_for_client(client_id)
-    
-    return {
-        "success": True,
-        "client_id": client_id,
-        "status": client_data.get("status", "offline"),
-        "last_seen": client_data.get("last_seen"),
-        "message_count": client_data.get("message_count", 0),
-        "memory_stats": memory_stats,
-        "timestamp": datetime.now().isoformat()
-    }
-
-@app.get("/api/system-status")
-async def system_status():
-    """حالة النظام العام"""
-    active_clients = []
-    for client_id, data in connected_clients.items():
-        if data.get("status") == "active":
-            active_clients.append({
-                "client_id": client_id,
-                "machine_name": data.get("machine_name"),
-                "last_seen": data.get("last_seen"),
-                "message_count": data.get("message_count", 0)
-            })
-    
-    return {
-        "success": True,
-        "status": "running",
-        "connected_clients": len(connected_clients),
-        "active_clients": active_clients,
-        "pending_commands": len(pending_commands),
-        "total_results": len(client_results),
-        "total_memories": sum(len(memories) for memories in client_memories.values()),
-        "memory_system": "active",
-        "server_time": datetime.now().isoformat()
-    }
-
-@app.get("/api/debug-clients")
-async def debug_clients():
-    """تصحيح الأخطاء - عرض جميع العملاء"""
-    return {
-        "connected_clients": connected_clients,
-        "client_memories": {client_id: len(memories) for client_id, memories in client_memories.items()},
-        "game_analysis_memory": {client_id: len(analyses) for client_id, analyses in game_analysis_memory.items()},
-        "system_info_memory": list(system_info_memory.keys()),
-        "installed_programs_memory": list(installed_programs_memory.keys()),
-        "total": len(connected_clients)
-    }
-
 if __name__ == "__main__":
     import uvicorn
-    uvicorn.run(app, host="0.0.0.0", port=7860)
+    port = int(os.getenv("PORT", 7860))
+    uvicorn.run(
+        "server:app",
+        host="0.0.0.0",
+        port=port,
+        reload=True
+    )