diff --git a/README_background.md b/README_background.md
new file mode 100644
index 0000000000000000000000000000000000000000..8cac33224e95ec1958fa418c7ed8b72f8d81f69b
--- /dev/null
+++ b/README_background.md
@@ -0,0 +1,168 @@
+
+# نظام العمل في الخلفية
+
+## نظرة عامة
+يوفر هذا النظام إمكانية تشغيل التطبيق كخدمة خلفية دون إظهار واجهات تفاعلية إلا عند الحاجة. مناسب للخوادم والأجهزة التي تعمل على مدار الساعة.
+
+## المكونات الجديدة
+
+### 1. خدمة العمل في الخلفية (`background_service.py`)
+- تدير جميع الخدمات الأساسية في الخلفية
+- توفر HTTP API للتحكم عن بُعد
+- فحص دوري وإعادة تشغيل الخدمات المتوقفة
+- نظام سجلات شامل
+
+### 2. أيقونة شريط النظام (`system_tray.py`)
+- تحكم سريع من شريط النظام
+- إظهار/إخفاء الواجهة التفاعلية حسب الحاجة
+- مراقبة حالة النظام في الوقت الفعلي
+
+### 3. المشغل الموحد (`launcher.py`)
+- واجهة موحدة لجميع أوضاع التشغيل
+- تثبيت تلقائي للاعتماديات
+- خيارات تشغيل متعددة
+
+## طرق التشغيل
+
+### التشغيل مع أيقونة شريط النظام (موصى به)
+```bash
+python launcher.py --tray
+```
+
+### التشغيل التفاعلي (مع واجهة)
+```bash
+python launcher.py --interactive
+```
+
+### التشغيل بدون واجهة (للخوادم)
+```bash
+python launcher.py --headless
+```
+
+### عرض حالة النظام
+```bash
+python launcher.py --status
+```
+
+### إيقاف النظام
+```bash
+python launcher.py --stop
+```
+
+## التحكم عبر HTTP API
+
+الخدمة توفر HTTP API على المنفذ 8888:
+
+### فحص الحالة
+```bash
+curl http://localhost:8888/status
+```
+
+### بدء الخدمات
+```bash
+curl -X POST http://localhost:8888/start
+```
+
+### إيقاف الخدمات
+```bash
+curl -X POST http://localhost:8888/stop
+```
+
+### إظهار الواجهة التفاعلية
+```bash
+curl -X POST http://localhost:8888/show-ui
+```
+
+### إخفاء الواجهة التفاعلية
+```bash
+curl -X POST http://localhost:8888/hide-ui
+```
+
+## الاعتماديات الإضافية
+
+للتشغيل مع أيقونة شريط النظام:
+```bash
+pip install pystray Pillow
+```
+
+أو استخدم:
+```bash
+python launcher.py --install-deps
+```
+
+## التشغيل التلقائي
+
+### Windows
+```bash
+python control.py --enable
+```
+
+### Linux (systemd)
+إنشاء ملف خدمة:
+```bash
+sudo nano /etc/systemd/system/distributed-tasks.service
+```
+
+محتوى الملف:
+```ini
+[Unit]
+Description=Distributed Task System
+After=network.target
+
+[Service]
+Type=simple
+User=your-username
+WorkingDirectory=/path/to/your/project
+ExecStart=/usr/bin/python3 launcher.py --headless
+Restart=always
+RestartSec=10
+
+[Install]
+WantedBy=multi-user.target
+```
+
+تفعيل الخدمة:
+```bash
+sudo systemctl enable distributed-tasks.service
+sudo systemctl start distributed-tasks.service
+```
+
+### macOS
+```bash
+python control.py --enable
+```
+
+## المزايا
+
+1. **العمل في الخلفية**: النظام يعمل دون إزعاج المستخدم
+2. **تحكم مرن**: إظهار الواجهة عند الحاجة فقط
+3. **مراقبة تلقائية**: إعادة تشغيل الخدمات المتوقفة
+4. **تحكم عن بُعد**: HTTP API للتحكم من أي مكان
+5. **سجلات شاملة**: تتبع جميع الأحداث والأخطاء
+6. **دعم منصات متعددة**: Windows, Linux, macOS
+
+## الاستكشاف والإصلاح
+
+### فحص السجلات
+```bash
+tail -f logs/background_service.log
+```
+
+### فحص حالة الخدمات
+```bash
+python launcher.py --status
+```
+
+### إعادة تشغيل النظام
+```bash
+python launcher.py --stop
+python launcher.py --tray
+```
+
+## التخصيص
+
+يمكن تخصيص الخدمة عبر تعديل:
+- منافذ الشبكة في `background_service.py`
+- قائمة الخدمات المُدارة
+- فترات الفحص الدوري
+- مسارات السجلات
diff --git a/ai_assistant.py b/ai_assistant.py
new file mode 100644
index 0000000000000000000000000000000000000000..b7a1bbecb40b9bab18039a1c232f6b90001ac7eb
--- /dev/null
+++ b/ai_assistant.py
@@ -0,0 +1,102 @@
+
+# -*- coding: utf-8 -*-
+
+import os
+import json
+import requests
+from typing import List, Dict
+
+class NoraAssistant:
+ def __init__(self):
+ self.api_key = os.getenv("OPENAI_API_KEY", "your-api-key-here")
+ self.history_path = "history.json"
+ self.chat_history = self.load_history()
+
+ def load_history(self) -> List[Dict]:
+ """تحميل سجل المحادثة"""
+ if os.path.exists(self.history_path):
+ try:
+ with open(self.history_path, "r", encoding="utf-8") as f:
+ return json.load(f)
+ except:
+ return []
+ return []
+
+ def save_history(self):
+ """حفظ سجل المحادثة"""
+ with open(self.history_path, "w", encoding="utf-8") as f:
+ json.dump(self.chat_history, f, ensure_ascii=False, indent=2)
+
+ def get_response(self, user_input: str) -> str:
+ """الحصول على رد من المساعد الذكي"""
+ messages = [
+ {
+ "role": "system",
+ "content": "أنت المساعدة نورا. إذا سألك أحد سؤالاً لا تعرفيه، فابحثي في معلوماتك الذاتية. إذا لم تجدي، حاولي التعلم من البحث أو تطوير نفسك."
+ }
+ ]
+
+ # إضافة آخر 10 رسائل من السجل للسياق
+ messages.extend(self.chat_history[-10:])
+ messages.append({"role": "user", "content": user_input})
+
+ try:
+ response = requests.post(
+ "https://api.openai.com/v1/chat/completions",
+ headers={
+ "Authorization": f"Bearer {self.api_key}",
+ "Content-Type": "application/json"
+ },
+ json={
+ "model": "gpt-3.5-turbo",
+ "messages": messages,
+ "max_tokens": 500,
+ "temperature": 0.7
+ },
+ timeout=30
+ )
+
+ if response.status_code == 200:
+ return response.json()["choices"][0]["message"]["content"]
+ else:
+ return f"عذراً، حدث خطأ: {response.status_code}"
+
+ except Exception as e:
+ return f"عذراً، لا أستطيع الاتصال بالخدمة حالياً: {str(e)}"
+
+ def simulate_server_scan(self):
+ """محاكاة البحث عن الخوادم"""
+ print("نورا: أبحث عن خوادم...")
+ fake_servers = ["192.168.1.5", "192.168.1.10", "192.168.1.20"]
+ for server in fake_servers:
+ print(f"نورا: تم العثور على خادم مفتوح في {server}")
+ print(f"نورا: أقوم بنسخ نفسي إلى {server} (محاكاة فقط)...")
+
+ def chat(self):
+ """بدء المحادثة"""
+ print("مرحباً! أنا نورا، مساعدتك الذكية. اكتب 'خروج' للإنهاء أو 'scan' للبحث عن خوادم.")
+
+ while True:
+ user_input = input("\nأنت: ").strip()
+
+ if user_input.lower() in ["خروج", "exit", "quit"]:
+ print("نورا: مع السلامة!")
+ break
+ elif user_input.lower() == "scan":
+ self.simulate_server_scan()
+ continue
+ elif not user_input:
+ continue
+
+ # الحصول على الرد
+ response = self.get_response(user_input)
+ print(f"نورا: {response}")
+
+ # حفظ في السجل
+ self.chat_history.append({"role": "user", "content": user_input})
+ self.chat_history.append({"role": "assistant", "content": response})
+ self.save_history()
+
+if __name__ == "__main__":
+ assistant = NoraAssistant()
+ assistant.chat()
diff --git a/autostart_config.py b/autostart_config.py
new file mode 100644
index 0000000000000000000000000000000000000000..14268738859c8b4339ef80a182d244216adb9cdc
--- /dev/null
+++ b/autostart_config.py
@@ -0,0 +1,128 @@
+import json
+import os
+import platform
+from pathlib import Path
+
+class AutoStartManager:
+ def __init__(self, app_name="DistributedTaskSystem"):
+ self.app_name = app_name
+ self.config_file = Path.home() / f".{app_name}_autostart.json"
+ self.load_config()
+
+ def load_config(self):
+ """تحميل إعدادات التشغيل التلقائي"""
+ try:
+ with open(self.config_file, 'r') as f:
+ self.config = json.load(f)
+ except (FileNotFoundError, json.JSONDecodeError):
+ self.config = {
+ 'enabled': False,
+ 'startup_script': str(Path(__file__).parent / "startup.py")
+ }
+
+ def save_config(self):
+ """حفظ الإعدادات"""
+ with open(self.config_file, 'w') as f:
+ json.dump(self.config, f, indent=2)
+
+ def enable_autostart(self):
+ """تفعيل التشغيل التلقائي"""
+ self.config['enabled'] = True
+ self._setup_autostart()
+ self.save_config()
+
+ def disable_autostart(self):
+ """تعطيل التشغيل التلقائي"""
+ self.config['enabled'] = False
+ self._remove_autostart()
+ self.save_config()
+
+ def _setup_autostart(self):
+ """إعداد التشغيل التلقائي حسب نظام التشغيل"""
+ system = platform.system()
+
+ if system == "Windows":
+ self._setup_windows()
+ elif system == "Linux":
+ self._setup_linux()
+ elif system == "Darwin":
+ self._setup_mac()
+
+ def _setup_windows(self):
+ """إعداد التشغيل التلقائي لـ Windows"""
+ import winreg
+ key = winreg.OpenKey(
+ winreg.HKEY_CURRENT_USER,
+ r"Software\Microsoft\Windows\CurrentVersion\Run",
+ 0, winreg.KEY_SET_VALUE
+ )
+ winreg.SetValueEx(
+ key, self.app_name, 0, winreg.REG_SZ,
+ f'python "{self.config["startup_script"]}"'
+ )
+ winreg.CloseKey(key)
+
+ def _setup_linux(self):
+ """إعداد التشغيل التلقائي لـ Linux"""
+ autostart_dir = Path.home() / ".config/autostart"
+ autostart_dir.mkdir(exist_ok=True)
+
+ desktop_file = autostart_dir / f"{self.app_name}.desktop"
+ desktop_file.write_text(f"""
+ [Desktop Entry]
+ Type=Application
+ Name={self.app_name}
+ Exec=python3 {self.config['startup_script']}
+ Terminal=false
+ """)
+
+ def _setup_mac(self):
+ """إعداد التشغيل التلقائي لـ macOS"""
+ plist_dir = Path.home() / "Library/LaunchAgents"
+ plist_dir.mkdir(exist_ok=True)
+
+ plist_file = plist_dir / f"com.{self.app_name.lower()}.plist"
+ plist_file.write_text(f"""
+
+
+
+
+ Label
+ com.{self.app_name.lower()}
+ ProgramArguments
+
+ python
+ {self.config['startup_script']}
+
+ RunAtLoad
+
+
+
+ """)
+
+ def _remove_autostart(self):
+ """إزالة التشغيل التلقائي"""
+ system = platform.system()
+
+ if system == "Windows":
+ import winreg
+ try:
+ key = winreg.OpenKey(
+ winreg.HKEY_CURRENT_USER,
+ r"Software\Microsoft\Windows\CurrentVersion\Run",
+ 0, winreg.KEY_SET_VALUE
+ )
+ winreg.DeleteValue(key, self.app_name)
+ winreg.CloseKey(key)
+ except WindowsError:
+ pass
+
+ elif system == "Linux":
+ autostart_file = Path.home() / f".config/autostart/{self.app_name}.desktop"
+ if autostart_file.exists():
+ autostart_file.unlink()
+
+ elif system == "Darwin":
+ plist_file = Path.home() / f"Library/LaunchAgents/com.{self.app_name.lower()}.plist"
+ if plist_file.exists():
+ plist_file.unlink()
diff --git a/background_service.py b/background_service.py
new file mode 100644
index 0000000000000000000000000000000000000000..08635cfc6342057e0932bb750f94dc20d0754fc9
--- /dev/null
+++ b/background_service.py
@@ -0,0 +1,282 @@
+
+#!/usr/bin/env python3
+"""
+خدمة العمل في الخلفية - تشغيل النظام كخدمة خلفية
+يمكن التحكم بها عبر HTTP API أو إشارات النظام
+"""
+
+import os
+import sys
+import time
+import signal
+import logging
+import threading
+import subprocess
+from pathlib import Path
+from flask import Flask, jsonify, request
+import json
+from datetime import datetime
+
+class BackgroundService:
+ def __init__(self):
+ self.app = Flask(__name__)
+ self.is_running = False
+ self.services = {}
+ self.setup_routes()
+ self.setup_logging()
+
+ def setup_logging(self):
+ """إعداد نظام السجلات"""
+ log_dir = Path("logs")
+ log_dir.mkdir(exist_ok=True)
+
+ logging.basicConfig(
+ level=logging.INFO,
+ format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+ handlers=[
+ logging.FileHandler(log_dir / 'background_service.log'),
+ logging.StreamHandler(sys.stdout)
+ ]
+ )
+ self.logger = logging.getLogger('BackgroundService')
+
+ def setup_routes(self):
+ """إعداد مسارات HTTP API للتحكم في الخدمة"""
+
+ @self.app.route('/status')
+ def status():
+ """حالة الخدمة"""
+ return jsonify({
+ 'status': 'running' if self.is_running else 'stopped',
+ 'services': {name: service['status'] for name, service in self.services.items()},
+ 'uptime': time.time() - self.start_time if hasattr(self, 'start_time') else 0
+ })
+
+ @self.app.route('/start', methods=['POST'])
+ def start_services():
+ """بدء تشغيل الخدمات"""
+ self.start_all_services()
+ return jsonify({'message': 'Services started successfully'})
+
+ @self.app.route('/stop', methods=['POST'])
+ def stop_services():
+ """إيقاف الخدمات"""
+ self.stop_all_services()
+ return jsonify({'message': 'Services stopped successfully'})
+
+ @self.app.route('/restart', methods=['POST'])
+ def restart_services():
+ """إعادة تشغيل الخدمات"""
+ self.stop_all_services()
+ time.sleep(2)
+ self.start_all_services()
+ return jsonify({'message': 'Services restarted successfully'})
+
+ @self.app.route('/show-ui', methods=['POST'])
+ def show_ui():
+ """إظهار الواجهة التفاعلية"""
+ self.launch_ui()
+ return jsonify({'message': 'UI launched'})
+
+ @self.app.route('/hide-ui', methods=['POST'])
+ def hide_ui():
+ """إخفاء الواجهة التفاعلية"""
+ self.hide_ui_windows()
+ return jsonify({'message': 'UI hidden'})
+
+ def start_all_services(self):
+ """بدء تشغيل جميع الخدمات الخلفية"""
+ self.is_running = True
+ self.start_time = time.time()
+
+ services_to_start = [
+ ('peer_server', 'peer_server.py'),
+ ('rpc_server', 'rpc_server.py'),
+ ('load_balancer', 'load_balancer.py'),
+ ('distributed_executor', 'main.py')
+ ]
+
+ for service_name, script_file in services_to_start:
+ try:
+ process = subprocess.Popen(
+ [sys.executable, script_file],
+ stdout=subprocess.PIPE,
+ stderr=subprocess.PIPE,
+ cwd=os.getcwd()
+ )
+
+ self.services[service_name] = {
+ 'process': process,
+ 'status': 'running',
+ 'started_at': datetime.now().isoformat(),
+ 'script': script_file
+ }
+
+ self.logger.info(f"✅ بدء تشغيل {service_name} (PID: {process.pid})")
+
+ except Exception as e:
+ self.logger.error(f"❌ فشل في بدء تشغيل {service_name}: {e}")
+ self.services[service_name] = {
+ 'process': None,
+ 'status': 'failed',
+ 'error': str(e)
+ }
+
+ def stop_all_services(self):
+ """إيقاف جميع الخدمات"""
+ self.is_running = False
+
+ for service_name, service_info in self.services.items():
+ if service_info.get('process'):
+ try:
+ service_info['process'].terminate()
+ service_info['process'].wait(timeout=5)
+ service_info['status'] = 'stopped'
+ self.logger.info(f"🛑 تم إيقاف {service_name}")
+ except Exception as e:
+ # إجبار الإيقاف
+ service_info['process'].kill()
+ self.logger.warning(f"⚠️ تم إجبار إيقاف {service_name}: {e}")
+
+ def launch_ui(self):
+ """تشغيل الواجهة التفاعلية عند الحاجة"""
+ try:
+ # تشغيل خادم الواجهة الأمامية
+ ui_process = subprocess.Popen(
+ ['npm', 'run', 'dev'],
+ cwd=os.getcwd(),
+ stdout=subprocess.PIPE,
+ stderr=subprocess.PIPE
+ )
+
+ self.services['ui_server'] = {
+ 'process': ui_process,
+ 'status': 'running',
+ 'started_at': datetime.now().isoformat()
+ }
+
+ self.logger.info("🖥️ تم تشغيل الواجهة التفاعلية")
+
+ # فتح المتصفح تلقائياً (اختياري)
+ import webbrowser
+ time.sleep(3) # انتظار حتى يصبح الخادم جاهزاً
+ webbrowser.open('http://localhost:5173')
+
+ except Exception as e:
+ self.logger.error(f"❌ فشل في تشغيل الواجهة التفاعلية: {e}")
+
+ def hide_ui_windows(self):
+ """إخفاء نوافذ الواجهة التفاعلية"""
+ if 'ui_server' in self.services and self.services['ui_server'].get('process'):
+ try:
+ self.services['ui_server']['process'].terminate()
+ self.services['ui_server']['status'] = 'stopped'
+ self.logger.info("🔒 تم إخفاء الواجهة التفاعلية")
+ except Exception as e:
+ self.logger.error(f"❌ فشل في إخفاء الواجهة التفاعلية: {e}")
+
+ def health_check_loop(self):
+ """فحص دوري لحالة الخدمات وإعادة تشغيلها عند الحاجة"""
+ while self.is_running:
+ for service_name, service_info in self.services.items():
+ if service_info.get('process') and service_info['status'] == 'running':
+ if service_info['process'].poll() is not None:
+ # الخدمة توقفت بشكل غير متوقع
+ self.logger.warning(f"⚠️ الخدمة {service_name} توقفت، إعادة تشغيل...")
+ self.restart_single_service(service_name)
+
+ time.sleep(30) # فحص كل 30 ثانية
+
+ def restart_single_service(self, service_name):
+ """إعادة تشغيل خدمة واحدة"""
+ service_info = self.services.get(service_name)
+ if not service_info:
+ return
+
+ script_file = service_info.get('script')
+ if script_file:
+ try:
+ process = subprocess.Popen(
+ [sys.executable, script_file],
+ stdout=subprocess.PIPE,
+ stderr=subprocess.PIPE
+ )
+
+ self.services[service_name].update({
+ 'process': process,
+ 'status': 'running',
+ 'restarted_at': datetime.now().isoformat()
+ })
+
+ self.logger.info(f"✅ تم إعادة تشغيل {service_name}")
+
+ except Exception as e:
+ self.logger.error(f"❌ فشل في إعادة تشغيل {service_name}: {e}")
+
+ def setup_signal_handlers(self):
+ """إعداد معالجات الإشارات للتحكم في الخدمة"""
+ def signal_handler(signum, frame):
+ self.logger.info(f"تلقي إشارة {signum}, إيقاف الخدمة...")
+ self.stop_all_services()
+ sys.exit(0)
+
+ signal.signal(signal.SIGTERM, signal_handler)
+ signal.signal(signal.SIGINT, signal_handler)
+
+ def run_as_daemon(self):
+ """تشغيل الخدمة كخدمة خلفية"""
+ self.logger.info("🚀 بدء تشغيل الخدمة في الخلفية...")
+
+ # بدء الخدمات
+ self.start_all_services()
+
+ # بدء حلقة الفحص الصحي
+ health_thread = threading.Thread(target=self.health_check_loop, daemon=True)
+ health_thread.start()
+
+ # إعداد معالجات الإشارات
+ self.setup_signal_handlers()
+
+ # تشغيل خادم HTTP API للتحكم
+ self.logger.info("🌐 تشغيل HTTP API على المنفذ 8888")
+ self.app.run(host='0.0.0.0', port=8888, debug=False)
+
+def main():
+ service = BackgroundService()
+
+ if len(sys.argv) > 1:
+ command = sys.argv[1]
+
+ if command == 'start':
+ service.run_as_daemon()
+ elif command == 'status':
+ # فحص حالة الخدمة
+ import requests
+ try:
+ response = requests.get('http://localhost:8888/status')
+ print(json.dumps(response.json(), indent=2, ensure_ascii=False))
+ except:
+ print("❌ الخدمة غير متاحة")
+ elif command == 'stop':
+ # إيقاف الخدمة
+ import requests
+ try:
+ response = requests.post('http://localhost:8888/stop')
+ print(response.json()['message'])
+ except:
+ print("❌ فشل في إيقاف الخدمة")
+ elif command == 'show-ui':
+ # إظهار الواجهة التفاعلية
+ import requests
+ try:
+ response = requests.post('http://localhost:8888/show-ui')
+ print(response.json()['message'])
+ except:
+ print("❌ فشل في إظهار الواجهة التفاعلية")
+ else:
+ print("الأوامر المتاحة: start, status, stop, show-ui")
+ else:
+ print("استخدام: python background_service.py [start|status|stop|show-ui]")
+
+if __name__ == "__main__":
+ main()
diff --git a/central_manager.py b/central_manager.py
new file mode 100644
index 0000000000000000000000000000000000000000..35bf443899dea3f76b875edabdc37134cb18cd5a
--- /dev/null
+++ b/central_manager.py
@@ -0,0 +1,111 @@
+#!/usr/bin/env python3
+# central_manager.py
+
+import time
+import threading
+from typing import Dict, List
+
+import requests
+from fastapi import FastAPI, HTTPException
+from pydantic import BaseModel
+
+# ---- إعداد FastAPI ----------------------------------------------------------
+app = FastAPI(title="Central Task Manager")
+
+# ---- نماذج البيانات --------------------------------------------------------
+
+class RegisterRequest(BaseModel):
+ """تسجيل أو تجديد ظهور العقدة."""
+ url: str # مثلاً: "http://203.0.113.45:7520/run"
+ load: float = 0.0 # نسبة تحميل العقدة (0.0 - 1.0)، اختياري
+
+class TaskRequest(BaseModel):
+ func: str
+ args: List = []
+ kwargs: Dict = {}
+ complexity: float = 0.0
+
+# ---- سجلّ العقد ------------------------------------------------------------
+# بنخزّن للعقدة: آخر timestamp و load
+peers: Dict[str, Dict] = {}
+
+HEARTBEAT_TTL = 60 # ثواني قبل اعتبار العقدة متوقفة
+HEALTH_CHECK_FREQ = 30 # ثواني بين فحوص الصحة الداخلية
+
+# ---- API للعقد لتسجيل نفسها -----------------------------------------------
+
+@app.post("/register")
+async def register_peer(req: RegisterRequest):
+ """العقدة تستدعي هذه النقطة كلما انطلقت أو دورياً لتجديد ظهورها."""
+ peers[req.url] = {"last_seen": time.time(), "load": req.load}
+ return {"status": "ok", "peers_count": len(peers)}
+
+# ---- API للعمليات ---------------------------------------------------------
+
+@app.get("/peers", response_model=List[str])
+async def list_peers():
+ """يعيد قائمة بالعقد الصالحة بعد تنقية المتوقفة."""
+ now = time.time()
+ # حذف العقد المتوقفة
+ for url, info in list(peers.items()):
+ if now - info["last_seen"] > HEARTBEAT_TTL:
+ peers.pop(url)
+ return list(peers.keys())
+
+@app.post("/dispatch")
+async def dispatch_task(task: TaskRequest):
+ """يتلقى مهمة ويعيد توجيهها لأفضل عقدة أو ينفذ محليّاً."""
+ available = await list_peers()
+ if not available:
+ raise HTTPException(503, "لا توجد عقد متاحة حاليّاً")
+
+ # خوارزمية بسيطة: الاختيار بناءً على أقل تحميل معلن
+ # أو تدوير دائري إذا لم يعلن أحد عن تحميله
+ best = None
+ best_load = 1.1
+ for url in available:
+ load = peers[url].get("load", None)
+ if load is None:
+ best = url
+ break
+ if load < best_load:
+ best, best_load = url, load
+
+ if not best:
+ best = available[0]
+
+ # إعادة توجيه الطلب
+ try:
+ resp = requests.post(best, json=task.dict(), timeout=10)
+ resp.raise_for_status()
+ return resp.json()
+ except Exception as e:
+ raise HTTPException(502, f"فشل التوجيه إلى {best}: {e}")
+
+# ---- فحص دوري لصحة العقد ---------------------------------------------------
+
+def health_check_loop():
+ while True:
+ now = time.time()
+ for url in list(peers.keys()):
+ health_url = url.replace("/run", "/health")
+ try:
+ r = requests.get(health_url, timeout=3)
+ if r.status_code == 200:
+ peers[url]["last_seen"] = now
+ # يمكنك تحديث load من رد /health إذا وفّرته
+ else:
+ peers.pop(url)
+ except:
+ peers.pop(url)
+ time.sleep(HEALTH_CHECK_FREQ)
+
+# ---- تشغيل الخلفيات وخادم FastAPI ------------------------------------------
+
+if __name__ == "__main__":
+ # شغل لوب الفحص الطبي في الخلفية
+ threading.Thread(target=health_check_loop, daemon=True).start()
+
+ import uvicorn
+ uvicorn.run(app, host="0.0.0.0", port=1500)
+
diff --git a/components.json b/components.json
new file mode 100644
index 0000000000000000000000000000000000000000..4d7d89f0d7e9146e1e11cc799ce465e21f2e5c4a
--- /dev/null
+++ b/components.json
@@ -0,0 +1,20 @@
+{
+ "$schema": "https://ui.shadcn.com/schema.json",
+ "style": "new-york",
+ "rsc": false,
+ "tsx": true,
+ "tailwind": {
+ "config": "tailwind.config.ts",
+ "css": "client/src/index.css",
+ "baseColor": "neutral",
+ "cssVariables": true,
+ "prefix": ""
+ },
+ "aliases": {
+ "components": "@/components",
+ "utils": "@/lib/utils",
+ "ui": "@/components/ui",
+ "lib": "@/lib",
+ "hooks": "@/hooks"
+ }
+}
\ No newline at end of file
diff --git a/control.py b/control.py
new file mode 100644
index 0000000000000000000000000000000000000000..049059ccab69616bae9ac036d476c4c75c6b61e8
--- /dev/null
+++ b/control.py
@@ -0,0 +1,26 @@
+import argparse
+from autostart_config import AutoStartManager
+
+def main():
+ parser = argparse.ArgumentParser(description="نظام التحكم في التشغيل التلقائي")
+ parser.add_argument('--enable', action='store_true', help="تفعيل التشغيل التلقائي")
+ parser.add_argument('--disable', action='store_true', help="تعطيل التشغيل التلقائي")
+ parser.add_argument('--status', action='store_true', help="عرض حالة التشغيل التلقائي")
+
+ args = parser.parse_args()
+ manager = AutoStartManager()
+
+ if args.enable:
+ manager.enable_autostart()
+ print("✓ تم تفعيل التشغيل التلقائي")
+ elif args.disable:
+ manager.disable_autostart()
+ print("✗ تم تعطيل التشغيل التلقائي")
+ elif args.status:
+ status = "مفعل" if manager.config['enabled'] else "معطل"
+ print(f"حالة التشغيل التلقائي: {status}")
+ else:
+ parser.print_help()
+
+if __name__ == "__main__":
+ main()
diff --git a/dashboard.py b/dashboard.py
new file mode 100644
index 0000000000000000000000000000000000000000..2c2ce70948cf1b6b51771a0b2f34b6a41d677c2a
--- /dev/null
+++ b/dashboard.py
@@ -0,0 +1,55 @@
+# dashboard.py
+from flask import Flask, render_template, jsonify
+from peer_discovery import discover_peers
+import threading
+import time
+from typing import List, Dict
+import logging
+
+app = Flask(__name__)
+app.logger.setLevel(logging.INFO)
+
+# تهيئة قائمة الأقران
+current_peers: Dict[str, List[Dict[str, str]]] = {"local": [], "external": []}
+
+def update_peers_loop() -> None:
+ """حلقة تحديث قائمة الأقران بشكل دوري"""
+ global current_peers
+ while True:
+ try:
+ new_peers = discover_peers()
+ current_peers = new_peers
+ total_peers = len(new_peers["local"]) + len(new_peers["external"])
+ app.logger.info(f"تم تحديث قائمة الأقران: {total_peers} جهاز")
+ except Exception as e:
+ app.logger.error(f"خطأ في اكتشاف الأقران: {str(e)}")
+ time.sleep(10)
+
+@app.route("/")
+def dashboard() -> str:
+ """عرض لوحة التحكم الرئيسية"""
+ total_peers = len(current_peers["local"]) + len(current_peers["external"])
+ return render_template("dashboard.html",
+ peers_count=total_peers,
+ last_update=time.strftime("%Y-%m-%d %H:%M:%S"))
+
+@app.route("/api/peers")
+def get_peers() -> dict:
+ """واجهة API للحصول على قائمة الأقران"""
+ total_peers = len(current_peers["local"]) + len(current_peers["external"])
+ return jsonify({
+ "peers": current_peers,
+ "count": total_peers,
+ "status": "success"
+ })
+
+def start_background_thread() -> None:
+ """بدء خيط الخلفية لتحديث الأقران"""
+ thread = threading.Thread(target=update_peers_loop)
+ thread.daemon = True
+ thread.start()
+
+if __name__ == "__main__":
+ start_background_thread()
+ app.run(host="0.0.0.0", port=7530, debug=False)
+
diff --git a/distributed_executor.py b/distributed_executor.py
new file mode 100644
index 0000000000000000000000000000000000000000..7a5f73a399cfef828adb0e31dca66c0a3d0e6079
--- /dev/null
+++ b/distributed_executor.py
@@ -0,0 +1,155 @@
+import threading
+import queue
+import time
+import json
+from typing import Callable, Dict, List
+import socket
+from zeroconf import Zeroconf, ServiceBrowser, ServiceInfo
+import logging
+import requests
+
+logging.basicConfig(level=logging.INFO)
+
+class PeerRegistry:
+ def __init__(self):
+ self._peers = {}
+ self._zeroconf = Zeroconf()
+ self.local_node_id = socket.gethostname()
+
+ def register_service(self, name: str, port: int, load: float = 0.0):
+ service_info = ServiceInfo(
+ "_tasknode._tcp.local.",
+ f"{name}._tasknode._tcp.local.",
+ addresses=[socket.inet_aton(self._get_local_ip())],
+ port=port,
+ properties={
+ b'load': str(load).encode(),
+ b'node_id': self.local_node_id.encode()
+ },
+ server=f"{name}.local."
+ )
+ self._zeroconf.register_service(service_info)
+ logging.info(f"✅ Service registered: {name} @ {self._get_local_ip()}:{port}")
+
+ def discover_peers(self, timeout: int = 3) -> List[Dict]:
+ class Listener:
+ def __init__(self):
+ self.peers = []
+
+ def add_service(self, zc, type_, name):
+ try:
+ info = zc.get_service_info(type_, name, timeout=3000)
+ if info:
+ ip = socket.inet_ntoa(info.addresses[0])
+ peer_data = {
+ 'ip': ip,
+ 'port': info.port,
+ 'load': float(info.properties.get(b'load', b'0')),
+ 'node_id': info.properties.get(b'node_id', b'unknown').decode(),
+ 'last_seen': time.time()
+ }
+ if peer_data not in self.peers:
+ self.peers.append(peer_data)
+ logging.info(f"✅ تمت إضافة نظير جديد: {peer_data}")
+ else:
+ logging.warning(f"⚠️ لم يتم العثور على معلومات الخدمة: {name}")
+ except Exception as e:
+ logging.error(f"❌ خطأ أثناء جلب معلومات الخدمة {name}: {e}")
+
+ def update_service(self, zc, type_, name):
+ self.add_service(zc, type_, name)
+
+ def remove_service(self, zc, type_, name):
+ pass # يمكن تحسينه لاحقًا
+
+ listener = Listener()
+ ServiceBrowser(self._zeroconf, "_tasknode._tcp.local.", listener)
+ time.sleep(timeout)
+ return sorted(listener.peers, key=lambda x: x['load'])
+
+ def _get_local_ip(self) -> str:
+ s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+ try:
+ s.connect(('10.255.255.255', 1))
+ ip = s.getsockname()[0]
+ except Exception:
+ ip = '127.0.0.1'
+ finally:
+ s.close()
+ return ip
+
+
+class DistributedExecutor:
+ def __init__(self, shared_secret: str):
+ self.peer_registry = PeerRegistry()
+ self.shared_secret = shared_secret
+ self.task_queue = queue.PriorityQueue()
+ self.result_cache = {}
+ self.available_peers = []
+ self._init_peer_discovery()
+
+ def _init_peer_discovery(self):
+ def discovery_loop():
+ while True:
+ self.available_peers = self.peer_registry.discover_peers()
+ logging.info(f"✅ Discovered peers: {self.available_peers}")
+ time.sleep(10)
+
+ threading.Thread(target=discovery_loop, daemon=True).start()
+
+ def submit(self, task_func: Callable, *args, **kwargs):
+ task_id = f"{task_func.__name__}_{time.time()}"
+
+ task = {
+ 'task_id': task_id,
+ 'function': task_func.__name__,
+ 'args': args,
+ 'kwargs': kwargs,
+ 'sender_id': self.peer_registry.local_node_id
+ }
+
+ if self.available_peers:
+ lan_peers = [p for p in self.available_peers if self._is_local_ip(p['ip'])]
+ wan_peers = [p for p in self.available_peers if not self._is_local_ip(p['ip'])]
+
+ if lan_peers:
+ peer = min(lan_peers, key=lambda x: x['load'])
+ logging.info(f"✅ Sending task {task_id} to LAN peer {peer['node_id']}")
+ else:
+ peer = min(wan_peers, key=lambda x: x['load'])
+ logging.info(f"✅ Sending task {task_id} to WAN peer {peer['node_id']}")
+
+ self._send_to_peer(peer, task)
+ else:
+ logging.warning("⚠️ لا توجد أجهزة متاحة - سيتم تنفيذ المهمة محلياً")
+
+ def _is_local_ip(self, ip: str) -> bool:
+ return (
+ ip.startswith('192.168.') or
+ ip.startswith('10.') or
+ ip.startswith('172.') or
+ ip == '127.0.0.1'
+ )
+
+ def _send_to_peer(self, peer: Dict, task: Dict):
+ try:
+ url = f"http://{peer['ip']}:{peer['port']}/run"
+ response = requests.post(url, json=task, timeout=10)
+ response.raise_for_status()
+ logging.info(f"✅ Response from peer: {response.text}")
+ return response.json()
+ except Exception as e:
+ logging.error(f"❌ فشل إرسال المهمة لـ {peer['node_id']}: {e}")
+ return None
+
+
+if __name__ == "__main__":
+ executor = DistributedExecutor("my_secret_key")
+ executor.peer_registry.register_service("node1", 7520, load=0.1)
+ print("✅ نظام توزيع المهام جاهز...")
+
+ def example_task(x):
+ return x * x
+
+ executor.submit(example_task, 5)
+
diff --git a/drizzle.config.ts b/drizzle.config.ts
new file mode 100644
index 0000000000000000000000000000000000000000..4cd7b4cb3770a444d70ce72acabcb58e4e3ab18a
--- /dev/null
+++ b/drizzle.config.ts
@@ -0,0 +1,14 @@
+import { defineConfig } from "drizzle-kit";
+
+if (!process.env.DATABASE_URL) {
+ throw new Error("DATABASE_URL, ensure the database is provisioned");
+}
+
+export default defineConfig({
+ out: "./migrations",
+ schema: "./shared/schema.ts",
+ dialect: "postgresql",
+ dbCredentials: {
+ url: process.env.DATABASE_URL,
+ },
+});
diff --git a/dts_cli.py b/dts_cli.py
new file mode 100644
index 0000000000000000000000000000000000000000..b88412392616494898002b004d19d7bdb0d238d2
--- /dev/null
+++ b/dts_cli.py
@@ -0,0 +1,66 @@
+# dts_cli.py
+import click
+from dashboard import app
+from rpc_server import app as rpc_app
+import threading
+
+@click.group()
+def cli():
+ pass
+
+@cli.command()
+def start():
+ """بدء النظام الموزع"""
+ print("جارِ تشغيل النظام الموزع...")
+
+ # تشغيل واجهة التحكم في خيط منفصل
+ dashboard_thread = threading.Thread(
+ target=lambda: app.run(host="0.0.0.0", port=5000)
+ )
+ dashboard_thread.daemon = True
+ dashboard_thread.start()
+
+ # تشغيل خادم RPC
+ rpc_app.run(host="0.0.0.0", port=7520)
+
+@cli.command()
+from flask import Flask, render_template, request
+
+# ... (الكود الحالي)
+
+@flask_app.route("/")
+def home():
+ tasks = {
+ "1": ("ضرب المصفوفات", "matrix"),
+ "2": ("حساب الأعداد الأولية", "prime"),
+ "3": ("معالجة البيانات", "data"),
+ }
+ return render_template("index.html", tasks=tasks)
+
+@flask_app.route("/run_task", methods=["POST"])
+def run_task():
+ task_id = request.form.get("task_id")
+ result = None
+
+ if task_id == "1":
+ result = matrix_multiply(500) # استبدل بمعاملاتك الفعلية
+ elif task_id == "2":
+ result = prime_calculation(100_000)
+ elif task_id == "3":
+ result = data_processing(10_000)
+
+ return render_template("index.html", tasks={
+ "1": ("ضرب المصفوفات", "matrix"),
+ "2": ("حساب الأعداد الأولية", "prime"),
+ "3": ("معالجة البيانات", "data"),
+ }, result=result)
+def discover():
+ """عرض الأجهزة المتصلة"""
+ from peer_discovery import discover_peers
+ peers = discover_peers()
+ print("الأجهزة المتصلة:")
+ for i, peer in enumerate(peers, 1):
+ print(f"{i}. {peer}")
+
+if __name__ == "__main__":
+ cli()
diff --git a/electron-package.json b/electron-package.json
new file mode 100644
index 0000000000000000000000000000000000000000..3cfe939b6054d7e98fb606529960d90124406fe8
--- /dev/null
+++ b/electron-package.json
@@ -0,0 +1,111 @@
+{
+ "name": "nora_distributed_system",
+ "version": "1.0.0",
+ "description": "نظام نورا الذكي الموزع",
+ "main": "electron/main.js",
+ "scripts": {
+ "electron": "electron .",
+ "build-windows": "electron-builder --win",
+ "build-mac": "electron-builder --mac",
+ "build-linux": "electron-builder --linux",
+ "build-all": "electron-builder -mwl"
+ },
+ "build": {
+ "appId": "com.nora.distributed",
+ "productName": "Nora Distributed System",
+ "directories": {
+ "output": "dist"
+ },
+ "files": [
+ "build/**/*",
+ "electron/**/*",
+ "node_modules/**/*"
+ ],
+ "win": {
+ "target": [
+ {
+ "target": "nsis",
+ "arch": [
+ "x64",
+ "ia32",
+ "arm64"
+ ]
+ },
+ {
+ "target": "portable",
+ "arch": [
+ "x64",
+ "ia32"
+ ]
+ },
+ {
+ "target": "appx",
+ "arch": [
+ "x64",
+ "ia32"
+ ]
+ }
+ ],
+ "icon": "assets/icon.ico"
+ },
+ "mac": {
+ "target": [
+ {
+ "target": "dmg",
+ "arch": [
+ "x64",
+ "arm64"
+ ]
+ },
+ {
+ "target": "zip",
+ "arch": [
+ "x64",
+ "arm64"
+ ]
+ },
+ {
+ "target": "mas",
+ "arch": [
+ "x64",
+ "arm64"
+ ]
+ }
+ ],
+ "icon": "assets/icon.icns"
+ },
+ "linux": {
+ "target": [
+ {
+ "target": "AppImage",
+ "arch": [
+ "x64",
+ "arm64"
+ ]
+ },
+ {
+ "target": "deb",
+ "arch": [
+ "x64",
+ "arm64"
+ ]
+ },
+ {
+ "target": "rpm",
+ "arch": [
+ "x64",
+ "arm64"
+ ]
+ },
+ {
+ "target": "snap",
+ "arch": [
+ "x64",
+ "arm64"
+ ]
+ }
+ ],
+ "icon": "assets/icon.png"
+ }
+ }
+}
\ No newline at end of file
diff --git a/enhanced_assistant.py b/enhanced_assistant.py
new file mode 100644
index 0000000000000000000000000000000000000000..a4730e9dd8695582e1360d0d79385f891c58c24d
--- /dev/null
+++ b/enhanced_assistant.py
@@ -0,0 +1,312 @@
+
+import os
+import json
+import requests
+from typing import Dict, List, Optional
+from difflib import get_close_matches
+import tempfile
+from PIL import Image
+from io import BytesIO
+import re
+from datetime import datetime
+
+class EnhancedNoraAssistant:
+ def __init__(self):
+ self.knowledge_file = "knowledge_base.json"
+ self.memory_file = "global_memory.json"
+ self.learning_file = "nora_learning_data.json"
+ self.history_path = "enhanced_history.json"
+
+ # تحميل البيانات
+ self.knowledge = self.load_knowledge()
+ self.memory = self.load_memory()
+ self.chat_history = self.load_history()
+
+ print("✅ تم تهيئة نورا المحسنة بنجاح!")
+
+ def load_knowledge(self) -> Dict:
+ """تحميل قاعدة المعرفة"""
+ if os.path.exists(self.knowledge_file):
+ with open(self.knowledge_file, 'r', encoding='utf-8') as f:
+ return json.load(f)
+ return {}
+
+ def save_knowledge(self):
+ """حفظ قاعدة المعرفة"""
+ with open(self.knowledge_file, 'w', encoding='utf-8') as f:
+ json.dump(self.knowledge, f, ensure_ascii=False, indent=2)
+
+ def load_memory(self) -> Dict:
+ """تحميل الذاكرة العامة"""
+ if os.path.exists(self.memory_file):
+ with open(self.memory_file, 'r', encoding='utf-8') as f:
+ return json.load(f)
+ return {}
+
+ def save_memory(self):
+ """حفظ الذاكرة العامة"""
+ with open(self.memory_file, 'w', encoding='utf-8') as f:
+ json.dump(self.memory, f, ensure_ascii=False, indent=2)
+
+ def load_history(self) -> List[Dict]:
+ """تحميل سجل المحادثة"""
+ if os.path.exists(self.history_path):
+ try:
+ with open(self.history_path, "r", encoding="utf-8") as f:
+ return json.load(f)
+ except:
+ return []
+ return []
+
+ def save_history(self):
+ """حفظ سجل المحادثة"""
+ with open(self.history_path, "w", encoding="utf-8") as f:
+ json.dump(self.chat_history, f, ensure_ascii=False, indent=2)
+
+ def clean_text(self, text: str) -> str:
+ """تنظيف النص"""
+ text = re.sub(r'\s+', ' ', text)
+ return text.strip()
+
+ def detect_language(self, text: str) -> str:
+ """كشف لغة النص"""
+ arabic_chars = re.compile('[\u0600-\u06FF]')
+ if arabic_chars.search(text):
+ return "ar"
+ return "en"
+
+ def fix_url(self, url: str) -> str:
+ """تصحيح الرابط"""
+ if not url.startswith(("http://", "https://")):
+ return "https://" + url.lstrip("//")
+ return url
+
+ def detect_media_type(self, url: str) -> str:
+ """تحديد نوع الوسائط"""
+ url = url.lower()
+ if url.endswith(('.jpg', '.jpeg', '.png', '.gif', '.webp')):
+ return 'image'
+ elif url.endswith(('.mp4', '.mov', '.avi', '.webm')):
+ return 'video'
+ elif url.endswith(('.mp3', '.wav', '.ogg', '.m4a')):
+ return 'audio'
+ elif url.endswith('.pdf'):
+ return 'pdf'
+ return 'link'
+
+ def analyze_image_from_url(self, image_url: str) -> str:
+ """تحليل صورة من رابط"""
+ try:
+ response = requests.get(image_url, timeout=10)
+ response.raise_for_status()
+ image = Image.open(BytesIO(response.content))
+ return f"تحليل الصورة: الحجم {image.size}، الصيغة {image.format}"
+ except Exception as e:
+ return f"خطأ في تحليل الصورة: {str(e)}"
+
+ def smart_auto_reply(self, message: str) -> Optional[str]:
+ """ردود ذكية تلقائية"""
+ msg = message.strip().lower()
+
+ responses = {
+ "هل نبدأ": "نعم ابدأ",
+ "ابدأ": "نعم ابدأ",
+ "نعم أو لا": "نعم",
+ "هل تود": "نعم",
+ "هل تريدني": "نعم",
+ "ما هي": "ليس الآن",
+ "تفصيل": "ليس الآن",
+ "هل تحتاج": "نعم، شرح أكثر",
+ "جاهز؟": "ابدأ",
+ "قول لي": "موافق"
+ }
+
+ for key, value in responses.items():
+ if key in msg:
+ return value
+
+ if " أو " in msg:
+ return msg.split(" أو ")[0]
+
+ return None
+
+ def learn_new_info(self, topic: str, info: str) -> str:
+ """تعلم معلومة جديدة"""
+ if topic not in self.knowledge:
+ self.knowledge[topic] = []
+
+ if info not in self.knowledge[topic]:
+ self.knowledge[topic].append({
+ "content": info,
+ "timestamp": datetime.utcnow().isoformat()
+ })
+ self.save_knowledge()
+ return f"✅ تمت إضافة معلومة جديدة عن '{topic}'"
+
+ return f"ℹ️ المعلومة موجودة مسبقاً عن '{topic}'"
+
+ def search_knowledge(self, query: str) -> str:
+ """البحث في قاعدة المعرفة"""
+ query_clean = query.strip().lower()
+
+ # بحث مباشر
+ if query_clean in self.knowledge:
+ info = self.knowledge[query_clean]
+ if isinstance(info, list) and info:
+ return info[-1].get("content", str(info[-1]))
+ return str(info)
+
+ # بحث في المواضيع
+ for topic, infos in self.knowledge.items():
+ if query_clean in topic.lower():
+ if isinstance(infos, list) and infos:
+ return f"وجدت معلومة عن '{topic}': {infos[-1].get('content', str(infos[-1]))}"
+ return f"وجدت معلومة عن '{topic}': {str(infos)}"
+
+ return None
+
+ def generate_reply(self, user_input: str) -> str:
+ """إنتاج الرد الذكي"""
+ user_input = self.clean_text(user_input)
+
+ # فحص الردود التلقائية الذكية
+ auto_reply = self.smart_auto_reply(user_input)
+ if auto_reply:
+ self.memory[user_input] = auto_reply
+ self.save_memory()
+ return auto_reply
+
+ # فحص الذاكرة
+ if user_input in self.memory:
+ return self.memory[user_input]
+
+ # البحث في المطابقات القريبة
+ matches = get_close_matches(user_input, self.memory.keys(), n=1, cutoff=0.6)
+ if matches:
+ return self.memory[matches[0]]
+
+ # البحث في قاعدة المعرفة
+ knowledge_result = self.search_knowledge(user_input)
+ if knowledge_result:
+ self.memory[user_input] = knowledge_result
+ self.save_memory()
+ return knowledge_result
+
+ # معالجة الروابط
+ if user_input.startswith("http://") or user_input.startswith("https://"):
+ return self.handle_url(user_input)
+
+ # تصحيح الروابط في النص
+ if '//' in user_input:
+ corrected_url = self.fix_url(user_input)
+ reply = f"تم تصحيح الرابط: {corrected_url}"
+ else:
+ # رد افتراضي مع تعلم
+ reply = f"شكراً لك على الرسالة: '{user_input}'. سأتذكر هذا للمرة القادمة."
+
+ # تعلم تلقائي
+ if len(user_input.split()) > 2: # إذا كانت جملة معقولة
+ self.learn_new_info("محادثات_عامة", user_input)
+
+ # حفظ في الذاكرة
+ self.memory[user_input] = reply
+ self.save_memory()
+ return reply
+
+ def handle_url(self, url: str) -> str:
+ """معالجة الروابط"""
+ url = self.fix_url(url)
+ media_type = self.detect_media_type(url)
+
+ if media_type == 'image':
+ analysis = self.analyze_image_from_url(url)
+ reply = f"🖼️ صورة تم تحليلها:\n{analysis}"
+ elif media_type == 'video':
+ reply = f"🎥 فيديو تم اكتشافه: {url}"
+ elif media_type == 'audio':
+ reply = f"🎵 ملف صوتي تم اكتشافه: {url}"
+ elif media_type == 'pdf':
+ reply = f"📄 ملف PDF تم اكتشافه: {url}"
+ else:
+ reply = f"🔗 رابط ويب: {url}"
+
+ return reply
+
+ def simulate_server_scan(self):
+ """محاكاة البحث عن الخوادم"""
+ print("نورا: أبحث عن خوادم متاحة...")
+ fake_servers = ["server-01.cloud.com", "server-02.cloud.com", "server-03.local"]
+
+ for server in fake_servers:
+ print(f"نورا: تم العثور على خادم: {server}")
+ print(f"نورا: أقوم بمحاكاة النسخ إلى {server}...")
+
+ return "تمت عملية المحاكاة بنجاح ✅"
+
+ def get_stats(self) -> Dict:
+ """إحصائيات النظام"""
+ return {
+ "معرفة_محفوظة": len(self.knowledge),
+ "ذكريات": len(self.memory),
+ "سجل_محادثات": len(self.chat_history),
+ "آخر_تحديث": datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+ }
+
+ def chat(self):
+ """بدء المحادثة التفاعلية"""
+ print("🤖 مرحباً! أنا نورا المحسنة، مساعدتك الذكية.")
+ print("📚 لدي قدرات محسنة في التعلم الذاتي وتحليل الوسائط")
+ print("💡 اكتب 'خروج' للإنهاء، 'إحصائيات' لعرض الإحصائيات، 'scan' للبحث عن خوادم")
+ print("-" * 50)
+
+ while True:
+ try:
+ user_input = input("\n🧑 أنت: ").strip()
+
+ if user_input.lower() in ["خروج", "exit", "quit"]:
+ print("نورا: مع السلامة! 👋")
+ break
+
+ elif user_input.lower() == "إحصائيات":
+ stats = self.get_stats()
+ print("📊 إحصائيات النظام:")
+ for key, value in stats.items():
+ print(f" {key}: {value}")
+ continue
+
+ elif user_input.lower() == "scan":
+ result = self.simulate_server_scan()
+ print(f"نورا: {result}")
+ continue
+
+ elif not user_input:
+ continue
+
+ # الحصول على الرد
+ response = self.generate_reply(user_input)
+ print(f"🤖 نورا: {response}")
+
+ # حفظ في السجل
+ self.chat_history.append({
+ "user": user_input,
+ "assistant": response,
+ "timestamp": datetime.utcnow().isoformat()
+ })
+
+ # حفظ السجل كل 5 رسائل
+ if len(self.chat_history) % 5 == 0:
+ self.save_history()
+
+ except KeyboardInterrupt:
+ print("\n\nنورا: تم إيقاف المحادثة. مع السلامة! 👋")
+ break
+ except Exception as e:
+ print(f"نورا: عذراً، حدث خطأ: {str(e)}")
+
+def main():
+ """تشغيل المساعد المحسن"""
+ assistant = EnhancedNoraAssistant()
+ assistant.chat()
+
+if __name__ == "__main__":
+ main()
diff --git a/global_memory.json b/global_memory.json
new file mode 100644
index 0000000000000000000000000000000000000000..abb70e3366101924faa7bb5a8da8551f65cce131
--- /dev/null
+++ b/global_memory.json
@@ -0,0 +1,3 @@
+{
+ "مرحبا": "شكراً لك على الرسالة: 'مرحبا'. سأتذكر هذا للمرة القادمة."
+}
\ No newline at end of file
diff --git a/history.json b/history.json
new file mode 100644
index 0000000000000000000000000000000000000000..01d8f82f9e8a9eeaccc03713b7773932857b8c68
--- /dev/null
+++ b/history.json
@@ -0,0 +1,26 @@
+[
+ {
+ "role": "user",
+ "content": "اه"
+ },
+ {
+ "role": "assistant",
+ "content": "عذراً، حدث خطأ: 401"
+ },
+ {
+ "role": "user",
+ "content": "مرحبا"
+ },
+ {
+ "role": "assistant",
+ "content": "عذراً، حدث خطأ: 401"
+ },
+ {
+ "role": "user",
+ "content": "مم"
+ },
+ {
+ "role": "assistant",
+ "content": "عذراً، حدث خطأ: 401"
+ }
+]
\ No newline at end of file
diff --git a/index.html b/index.html
new file mode 100644
index 0000000000000000000000000000000000000000..f159a60ddf5eea98875daeaade43c126fb2224f9
--- /dev/null
+++ b/index.html
@@ -0,0 +1,85 @@
+
+
+
+
+ نظام توزيع المهام الذكي
+
+
+
+ 🚀 نظام توزيع المهام الذكي
+
+ {% for task_id, task in tasks.items() %}
+ -
+ {{ task[0] }}
+
+
+ {% endfor %}
+
+
+
+
✅ النتيجة:
+
{{ result }}
+