Upload 9 files

build_mode_editor.py

@@ -0,0 +1,86 @@
+"""Build Mode Editor — управление режимами сборки"""
+import os
+import json
+import logging
+from datetime import datetime
+from typing import Dict
+from .config import BUILD_MODES_FILE
+
+class BuildModeEditor:
+    def __init__(self, state):
+        self.state = state
+        self.logger = logging.getLogger(__name__)
+
+    def list_modes(self) -> str:
+        modes = self._load_all_modes()
+        if not modes:
+            return (
+                "╭───────────────────╮\n"
+                " │ 🗃️ ᴀʀᴄʜɪᴠᴇ ᴏғ ʙᴜɪʟᴅ ᴍᴏᴅᴇs │\n"
+                "╰───────────────────╯\n\n"
+                "⊘ Empty...\n"
+                "Create your first mode: `/build mode save <name>`"
+            )
+        lines = ["╭───────────────────────────╮\n │ 🗃️ ᴀʀᴄʜɪᴠᴇ ᴏғ ʙᴜɪʟᴅ ᴍᴏᴅᴇs │\n╰───────────────────────────╯\n"]
+        for name, config in modes.items():
+            desc = config.get('description', 'No description')
+            lines.append(f"▸ {name}: {desc[:50]}...")
+        return "\n".join(lines)
+
+    def show_mode(self, mode_name: str) -> str:
+        modes = self._load_all_modes()
+        mode = modes.get(mode_name)
+        if not mode:
+            return f"▸ ✗ ᴇʀʀᴏʀ\n『{mode_name}』 not found in the archive.\nCheck spelling: `/build mode list`"
+        return (
+            f"╭───────────────────╮\n"
+            f" │ 📋 {mode_name.upper()} ᴍᴏᴅᴇ │\n"
+            "├───────────────────┤\n"
+            f"```json\n{json.dumps(mode, ensure_ascii=False, indent=2)}\n```"
+        )
+
+    def save_mode(self, mode_name: str, config: Dict = None) -> str:
+        modes = self._load_all_modes()
+        if config is None:
+            config = dict(self.state.build_context)
+        config["description"] = f"Mode created {datetime.now().isoformat()}"
+        modes[mode_name] = config
+        try:
+            with open(BUILD_MODES_FILE, "w", encoding="utf-8") as f:
+                json.dump(modes, f, ensure_ascii=False, indent=2)
+            return f"▸ ✓ ᴅɪᴅ sᴀᴠᴇ\n『{mode_name}』 saved to archive.\nLoad it anytime: `/build mode load {mode_name}`"
+        except Exception as e:
+            self.logger.error(f"Failed to save mode {mode_name}: {e}")
+            return f"▸ ⚠️ ᴇʀʀᴏʀ\n『{mode_name}』 save failed: {str(e)[:100]}..."
+
+    def load_mode(self, mode_name: str) -> str:
+        modes = self._load_all_modes()
+        mode = modes.get(mode_name)
+        if not mode:
+            return f"▸ ✗ ᴇʀʀᴏʀ\n『{mode_name}』 not found in the archive."
+        self.state.build_context.update(mode)
+        return f"▸ ✓ ᴍᴏᴅᴇ ʟᴏᴀᴅᴇᴅ\n『{mode_name}』 activated."
+
+    def delete_mode(self, mode_name: str) -> str:
+        modes = self._load_all_modes()
+        if mode_name not in modes:
+            return f"▸ ✗ ᴇʀʀᴏʀ\n『{mode_name}』 not found. Nothing to delete."
+        del modes[mode_name]
+        try:
+            with open(BUILD_MODES_FILE, "w", encoding="utf-8") as f:
+                json.dump(modes, f, ensure_ascii=False, indent=2)
+            return f"▸ ☢️ ᴅᴇʟᴇᴛᴇᴅ\n『{mode_name}』 removed from archive."
+        except Exception as e:
+            self.logger.error(f"Failed to delete mode {mode_name}: {e}")
+            return f"▸ ⚠️ ᴇʀʀᴏʀ\n『{mode_name}』 deletion failed: {str(e)[:100]}..."
+
+    def _load_all_modes(self) -> Dict:
+        if not os.path.exists(BUILD_MODES_FILE):
+            return {}
+        try:
+            with open(BUILD_MODES_FILE, "r", encoding="utf-8") as f:
+                return json.load(f)
+        except Exception as e:
+            self.logger.error(f"Failed to load build modes: {e}")
+            return {}
+

file_manager.py

@@ -0,0 +1,87 @@
+"""Работа с файлами"""
+import os
+import fnmatch
+import logging
+from typing import Dict, List, Tuple, Any
+
+class FileManager:
+    SUPPORTED_EXTENSIONS = {
+        '.txt': 'text', '.py': 'python', '.js': 'javascript', '.html': 'html',
+        '.css': 'css', '.json': 'json', '.yaml': 'yaml', '.yml': 'yaml',
+        '.md': 'markdown', '.csv': 'csv', '.xml': 'xml', '.log': 'log',
+        '.sql': 'sql', '.sh': 'bash', '.bat': 'batch', '.ps1': 'powershell',
+        '.ipynb': 'jupyter'
+    }
+
+    def __init__(self, base_dir: str = "projects"):
+        self.base_dir = os.path.abspath(base_dir)
+        self.logger = logging.getLogger(__name__)
+        os.makedirs(self.base_dir, exist_ok=True)
+        self.logger.info(f"FileManager initialized with base_dir: {self.base_dir}")
+
+    def read_file(self, file_path: str, max_size: int = 100000) -> Tuple[str, str]:
+        full_path = os.path.join(self.base_dir, file_path)
+        try:
+            real_path = os.path.realpath(full_path)
+            if not real_path.startswith(os.path.realpath(self.base_dir)):
+                self.logger.warning(f"Path traversal attempt: {file_path}")
+                return ("", "▸ ✗ ᴀᴄᴄᴇss ᴅᴇɴɪᴇᴅ\nPath traversal detected ‼️")
+        except Exception as e:
+            self.logger.error(f"Path resolution failed: {e}")
+            return ("", "▸ ⚠️ ᴇʀʀᴏʀ\nPath resolution failed")
+
+        if not os.path.exists(full_path):
+            return ("", f"▸ ✗ ғɪʟᴇ ɴᴏᴛ Ғᴏᴜɴᴅ\n`{file_path}`")
+
+        try:
+            size = os.path.getsize(full_path)
+            if size > max_size:
+                return ("", f"▸ ⚠️ ᴛᴏᴏ ʟᴀʀɢᴇ\n{size} bytes > {max_size} limit")
+
+            with open(full_path, 'r', encoding='utf-8', errors='ignore') as f:
+                content = f.read()
+
+            ext = os.path.splitext(file_path)[1].lower()
+            lang = self.SUPPORTED_EXTENSIONS.get(ext, 'text')
+            return (
+                content,
+                f"╭───────────────────╮\n"
+                f" │ 📖 {lang.upper()} ᴍᴏᴅᴇ │\n"
+                "├───────────────────┤\n"
+                f" │ `{file_path}` │\n"
+                f" │ {len(content)} chars read │\n"
+                "╰───────────────────╯"
+            )
+        except Exception as e:
+            self.logger.error(f"Read error for {file_path}: {e}")
+            return ("", f"▸ ⚠️ ʀᴇᴀᴅ ᴇʀʀᴏʀ\n{str(e)[:100]}")
+
+    def save_file(self, file_path: str, content: str) -> str:
+        full_path = os.path.join(self.base_dir, file_path)
+        try:
+            real_path = os.path.realpath(full_path)
+            if not real_path.startswith(os.path.realpath(self.base_dir)):
+                return "▸ ✗ ᴀᴄᴄᴇss ᴅᴇɴɪᴇᴅ\nPath traversal detected ‼️"
+        except Exception as e:
+            return f"▸ ⚠️ ᴘᴀᴛʜ ᴇʀʀᴏʀ\n{str(e)[:100]}"
+
+        try:
+            os.makedirs(os.path.dirname(full_path), exist_ok=True)
+            with open(full_path, 'w', encoding='utf-8') as f:
+                f.write(content)
+            return (
+                "╭───────────────────╮\n"
+                " │ 💾 Fɪʟᴇ ʀᴇᴄᴇɪᴠᴇᴅ │\n"
+                f" │ `{file_path}`   │\n"
+                "├───────────────────┤\n"
+                f" │ {len(content)} chars saved │\n"
+                "╰───────────────────╯\n\n"
+                "Send a command to process it:\n"
+                "`/build Analyze this file`"
+            )
+        except Exception as e:
+            self.logger.error(f"Save error for {file_path}: {e}")
+            return f"▸ ⚠️ ᴡʀɪᴛᴇ ᴇʀʀᴏʀ\n{str(e)[:100]}"
+
+FILE_MANAGER = FileManager()
+

internet_agent.py

@@ -0,0 +1,130 @@
+"""Бесплатный интернет-агент с минимум 3 способами поиска"""
+import re
+import logging
+import hashlib
+from datetime import datetime, timedelta
+from typing import Dict, List, Tuple, Any, Optional
+from collections import Counter
+import requests
+from requests.adapters import HTTPAdapter
+from urllib3.util.retry import Retry
+
+class FreeInternetAgent:
+    """Интернет-агент с бесплатными поисковыми системами"""
+
+    def __init__(self, cache_ttl: int = 3600):
+        self.session = requests.Session()
+        retry = Retry(total=3, backoff_factor=1, status_forcelist=[500, 502, 503, 504])
+        self.session.mount("https://", HTTPAdapter(max_retries=retry))
+        self.session.headers.update({
+            'User-Agent': 'PinkSky/7.0 (Linux; Research)'
+        })
+        self.cache: Dict[str, Tuple[Any, datetime]] = {}
+        self.cache_ttl = cache_ttl
+        self.logger = logging.getLogger(__name__)
+        self._has_bs4 = False
+        try:
+            import bs4
+            self._has_bs4 = True
+        except ImportError:
+            pass
+
+        # SearXNG инстансы
+        self.searxng_instances = [
+            "https://searx.be",
+            "https://search.bus-hit.me",
+            "https://searx.nixnet.xyz",
+            "https://searx.tuxcloud.net",
+            "https://searx.moe",
+        ]
+        # Асинхронная проверка доступности при старте
+        self.healthy_searxng = self._check_searxng_health()
+
+    def _check_searxng_health(self) -> List[str]:
+        healthy = []
+        for instance in self.searxng_instances:
+            try:
+                response = self.session.get(f"{instance}/health", timeout=5)
+                if response.status_code == 200:
+                    healthy.append(instance)
+            except Exception as e:
+                self.logger.warning(f"SearXNG health check failed for {instance}: {e}")
+        self.logger.info(f"Healthy SearXNG instances: {len(healthy)}/{len(self.searxng_instances)}")
+        return healthy
+
+    def _get_cache_key(self, *args, **kwargs) -> str:
+        key = f"{args}_{sorted(kwargs.items())}"
+        return hashlib.md5(key.encode()).hexdigest()
+
+    def _get_from_cache(self, key: str) -> Optional[Any]:
+        if key in self.cache:
+            data, timestamp = self.cache[key]
+            if datetime.now() - timestamp < timedelta(seconds=self.cache_ttl):
+                return data
+            else:
+                del self.cache[key]
+        return None
+
+    def _save_to_cache(self, key: str, data: Any) -> None:
+        self.cache[key] = (data, datetime.now())
+
+    def search_web(self, query: str, num_results: int = 5) -> List[Dict[str, str]]:
+        cache_key = self._get_cache_key('search', query, num_results)
+        cached = self._get_from_cache(cache_key)
+        if cached is not None:
+            return cached
+
+        results = []
+        # Способ 1: SearXNG (мета-поиск)
+        results = self._search_searxng(query, num_results)
+        # Способ 2: DuckDuckGo API
+        if not results:
+            results = self._search_duckduckgo(query, num_results)
+        # Способ 3: Google
+        if not results:
+            results = self._search_google(query, num_results)
+        # Способ 4: Яндекс
+        if not results and any(ord(c) > 1024 for c in query):
+            results = self._search_yandex(query, num_results)
+
+        self._save_to_cache(cache_key, results)
+        return results
+
+    def _search_searxng(self, query: str, num_results: int) -> List[Dict[str, str]]:
+        if not self.healthy_searxng:
+            self.healthy_searxng = self._check_searxng_health()
+            if not self.healthy_searxng:
+                self.logger.warning("No healthy SearXNG instances available")
+                return []
+
+        results = []
+        for instance in self.healthy_searxng:
+            try:
+                url = f"{instance}/search"
+                params = {
+                    "q": query,
+                    "format": "json",
+                    "categories": "general",
+                    "engines": "google,bing,duckduckgo,startpage",
+                    "language": "en",
+                    "pageno": 1
+                }
+                response = self.session.get(url, params=params, timeout=20)
+                response.raise_for_status()
+                data = response.json()
+                if 'results' in data:
+                    for item in data['results'][:num_results]:
+                        results.append({
+                            'title': item.get('title', '')[:100],
+                            'url': item.get('url', ''),
+                            'snippet': item.get('content', '')[:200],
+                            'source': 'searxng',
+                            'engine': item.get('engine', '')
+                        })
+                    self.logger.info(f"SearXNG ({instance}): {len(results)} results")
+                    break
+            except Exception as e:
+                self.logger.warning(f"SearXNG error for {instance}: {e}")
+                self.healthy_searxng.remove(instance)
+        return results
+

main.py

@@ -0,0 +1,72 @@
+"""Точка входа — запуск сервера"""
+import sys
+import signal
+import logging
+from http.server import HTTPServer
+from .config import PORT, TOKEN, API_KEY, ensure_folders
+from .state import STATE
+from .internet_agent import INTERNET_AGENT
+from .routes import WebhookHandler
+from .process_manager import PROCESS_MANAGER
+
+def handle_shutdown(signum, frame):
+    """Корректная остановка сервера"""
+    logging.info("Shutdown signal received")
+    PROCESS_MANAGER.cancel_all()
+    STATE.save_history()
+    logging.info("Server shutdown gracefully")
+
+def configure_logging():
+    """Настройка структурированного логирования"""
+    logging.basicConfig(
+        level=logging.INFO,
+        format="[%(asctime)s] [%(levelname)s] [%(name)s.%(funcName)s:%(lineno)d] %(message)s",
+        handlers=[
+            logging.StreamHandler()
+        ]
+    )
+    # Отключаем логирование urllib
+    logging.getLogger("urllib3").setLevel(logging.WARNING)
+
+def main():
+    configure_logging()
+    logger = logging.getLogger(__name__)
+
+    logger.info("=" * 60)
+    logger.info("🧠 PINKSKY v7.0 — МОДУЛЬНАЯ АРХИТЕКТУРА")
+    logger.info("=" * 60)
+
+    if not TOKEN:
+        logger.critical("TELEGRAM_BOT_TOKEN не найден!")
+        sys.exit(1)
+    if not API_KEY:
+        logger.warning("NVIDIA_API_KEY не найден")
+
+    ensure_folders()
+    logger.info(f"Загружено моделей: {len(STATE.models)}")
+    logger.info(f"Загружено ролей: {len(STATE.roles)}")
+    logger.info(f"Загружено кондукторов: {len(STATE.conductors)}")
+    logger.info(f"Интернет: {'✅' if STATE.build_context.get('internet_access', True) else '❌'}")
+    logger.info(f"Кэш поиска: {INTERNET_AGENT.get_cache_stats()}")
+
+    STATE.current_mode = "chat"
+    server = HTTPServer(("0.0.0.0", PORT), WebhookHandler)
+
+    # Настройка обработчиков сигналов
+    signal.signal(signal.SIGINT, handle_shutdown)
+    signal.signal(signal.SIGTERM, handle_shutdown)
+
+    logger.info(f"🚀 Сервер запущен на порту {PORT}")
+    logger.info("=" * 60)
+
+    try:
+        server.serve_forever()
+    except KeyboardInterrupt:
+        handle_shutdown(None, None)
+    finally:
+        server.server_close()
+        logger.info("Сервер остановлен")
+
+if __name__ == "__main__":
+    main()
+

mode_handlers.py

@@ -0,0 +1,123 @@
+"""Обработчики режимов: Chat, Skill, Build"""
+import threading
+import logging
+from datetime import datetime
+from typing import Dict, Any
+from .state import STATE
+from .config import API_KEY, API_BASE
+from .universal_agent import UniversalAgent
+from .conductor_engine import ConductorEngine
+from .skill_orchestrator import SkillOrchestrator
+from .process_manager import PROCESS_MANAGER
+from .notification_system import NOTIFICATIONS
+from .helpers import parse_skill_args, build_skill_prompt, parse_build_args
+from .telegram_utils import send_tg
+from .internet_agent import INTERNET_AGENT
+from .interpreter_config import configure_interpreter_for_model
+
+class RateLimiter:
+    def __init__(self):
+        self.user_requests = {}
+        self.max_requests = 5
+        self.time_window = 10  # seconds
+        self.logger = logging.getLogger(__name__)
+
+    def check_rate_limit(self, chat_id: str) -> bool:
+        now = datetime.now().timestamp()
+        requests = self.user_requests.get(chat_id, [])
+        # Remove old requests
+        requests = [t for t in requests if now - t < self.time_window]
+        if len(requests) >= self._get_limit(chat_id):
+            self.logger.warning(f"Rate limit exceeded for chat_id {chat_id}")
+            return False
+        requests.append(now)
+        self.user_requests[chat_id] = requests
+        return True
+
+    def _get_limit(self, chat_id: str) -> int:
+        # Allow higher limits for admin or premium users if needed
+        return self.max_requests
+
+rate_limiter = RateLimiter()
+logger = logging.getLogger(__name__)
+
+def configure_interpreter_for_model(model_name: str):
+    """Deprecated: Use from interpreter_config.py instead."""
+    return configure_interpreter_for_model(model_name, STATE, API_KEY, API_BASE)
+
+def run_chat_mode(chat_id: str, text: str, file_context: str = "") -> str:
+    if not rate_limiter.check_rate_limit(chat_id):
+        send_tg(chat_id, "╭───────────────────╮\n │ ⚠️ ʀᴀᴛᴇ ʟɪᴍɪᴛ │\n ├───────────────────┤\n │ Try again later ☕ │\n╰───────────────────╯")
+        return "Rate limited"
+
+    def chat_task():
+        STATE.cancel_flag = False
+        STATE.current_mode = "chat"
+        send_tg(
+            chat_id,
+            "╭───────────────────╮\n"
+            " │ 🧠 ᴄᴏɴᴅᴜᴄᴛᴏʀ ᴀᴄᴛɪᴠᴇ │\n"
+            "├───────────────────┤\n"
+            " │ Analyzing request │\n"
+            "╰───────────────────╯"
+        )
+        try:
+            conductor_engine = ConductorEngine(STATE)
+            result = conductor_engine.orchestrate(text + file_context, chat_id=chat_id)
+            if not STATE.cancel_flag:
+                send_tg(chat_id, result)
+                STATE.add_to_history("chat", "assistant", result)
+        except Exception as e:
+            if not STATE.cancel_flag:
+                send_tg(chat_id, f"▸ ⚠️ ᴄʜᴀᴛ ᴇʀʀᴏʀ\n{str(e)[:500]}")
+                logger.error(f"Chat mode error for {chat_id}: {e}", exc_info=True)
+
+    t = threading.Thread(target=chat_task)
+    PROCESS_MANAGER.register_thread(t)
+    t.start()
+    return "╭───────────────────╮\n │ ☕ ᴄʜᴀᴛ ᴍᴏᴅᴇ sᴛᴀʀᴛᴇᴅ │\n╰───────────────────╯"
+
+def run_skill_mode(chat_id: str, text: str, file_context: str = "") -> str:
+    if not rate_limiter.check_rate_limit(chat_id):
+        send_tg(chat_id, "▸ ⚠️ ʀᴀᴛᴇ ʟɪᴍɪᴛ\nTry again later.")
+        return "Rate limited"
+
+    params, clean_text = parse_skill_args(text)
+    agents = params.get("agents", [])
+    use_internet = params.get("internet", False)
+
+    def skill_task():
+        STATE.cancel_flag = False
+        STATE.current_mode = "skill"
+        send_tg(
+            chat_id,
+            "╭───────────────────╮\n"
+            " │ 🤖 sᴋɪʟʟ ᴍᴏᴅᴇ │\n"
+            "├───────────────────┤\n"
+            " │ Agents activated │\n"
+            "╰───────────────────╯"
+        )
+        if use_internet:
+            search_results = INTERNET_AGENT.search_web(clean_text[:200])
+            if search_results:
+                web_context = "\n\n🌐 ɪɴᴛᴇʀɴᴇᴛ ʀᴇsᴜʟᴛs（｡◕‿◕｡）\n" + "\n".join(
+                    f"▹ {r['title'][:50]}... → {r['snippet'][:100]}..."
+                    for r in search_results[:3]
+                )
+                file_context += web_context
+        try:
+            orchestrator = SkillOrchestrator(STATE)
+            result = orchestrator.execute_with_agents(chat_id, clean_text, file_context, agents)
+            if not STATE.cancel_flag:
+                send_tg(chat_id, result)
+                STATE.add_to_history("skill", "assistant", result)
+        except Exception as e:
+            if not STATE.cancel_flag:
+                send_tg(chat_id, f"▸ ⚠️ sᴋɪʟʟ ᴇʀʀᴏʀ\n{str(e)[:500]}")
+                logger.error(f"Skill mode error for {chat_id}: {e}", exc_info=True)
+
+    t = threading.Thread(target=skill_task)
+    PROCESS_MANAGER.register_thread(t)
+    t.start()
+    return "╭───────────────────╮\n │ 🧩 sᴋɪʟʟ ᴍᴏᴅᴇ sᴛᴀʀᴛᴇᴅ │\n╰───────────────────╯"
+

process_manager.py

@@ -0,0 +1,85 @@
+"""Управление потоками и отмена генерации"""
+import threading
+import uuid
+import logging
+from typing import List, Dict
+from concurrent.futures import ThreadPoolExecutor
+
+class ProcessManager:
+    def __init__(self):
+        self.active_threads: List[threading.Thread] = []
+        self.cancel_flags: Dict[str, bool] = {}
+        self.lock = threading.Lock()
+        self.executor = ThreadPoolExecutor(max_workers=10)
+        self.futures = []
+        self.logger = logging.getLogger(__name__)
+
+    def register_thread(self, thread: threading.Thread) -> None:
+        with self.lock:
+            self.active_threads.append(thread)
+            # Генерируем уникальный ID для потока
+            thread_id = str(uuid.uuid4())
+            self.cancel_flags[thread_id] = False
+            # Сохраняем ID в атрибуте потока для доступа
+            thread._cancel_id = thread_id
+
+    def register_future(self, future) -> None:
+        with self.lock:
+            self.futures.append(future)
+
+    def cancel_all(self) -> str:
+        with self.lock:
+            for future in self.futures:
+                if not future.done():
+                    future.cancel()
+            self.futures.clear()
+
+            cancelled_threads = []
+            for thread in self.active_threads:
+                thread_id = getattr(thread, "_cancel_id", None)
+                if thread_id is not None:
+                    self.cancel_flags[thread_id] = True
+                    cancelled_threads.append(thread.name)
+                if thread.is_alive():
+                    try:
+                        thread.join(timeout=0.5)
+                    except Exception as e:
+                        self.logger.warning(f"Failed to join thread {thread.name}: {e}")
+
+            self.active_threads.clear()
+            self.cancel_flags.clear()
+
+        try:
+            from interpreter import interpreter
+            if hasattr(interpreter, 'cancel'):
+                interpreter.cancel()
+        except Exception as e:
+            self.logger.error(f"Failed to cancel interpreter: {e}")
+
+        from .state import STATE
+        STATE.cancel_flag = True
+        STATE.current_mode = "paused"
+
+        return (
+            "╔════════════════════╗\n"
+            "║ ✅ ᴀʟʟ ᴘʀᴏᴄᴇssᴇs sᴛᴏᴘᴘᴇᴅ ║\n"
+            "║ Memory flushed     ║\n"
+            "║ Threads terminated ║\n"
+            "╚════════════════════╝"
+        )
+
+    def is_cancelled(self, thread_id: str = None) -> bool:
+        if thread_id is None:
+            current_thread = threading.current_thread()
+            thread_id = getattr(current_thread, "_cancel_id", None)
+        with self.lock:
+            return self.cancel_flags.get(thread_id, False)
+
+    def clear(self) -> None:
+        with self.lock:
+            self.active_threads = [t for t in self.active_threads if t.is_alive()]
+
+    def get_active_count(self) -> int:
+        with self.lock:
+            return len([t for t in self.active_threads if t.is_alive()])
+

state.py

@@ -0,0 +1,497 @@
+"""Глобальное состояние PinkSky"""
+import os
+import json
+import threading
+import logging
+from datetime import datetime
+from typing import Dict, List, Any, Optional
+from .models import ModelConfig, Role, Conductor
+from .model_ranking import MODEL_RANKING
+from .config import ROLES_FILE, MODELS_FILE, CONDUCTORS_FILE, HISTORY_FILE
+
+class PinkSkyState:
+    _instance = None
+    _initialized = False
+    _lock = threading.Lock()
+
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+        return cls._instance
+
+    def __init__(self):
+        if PinkSkyState._initialized:
+            return
+        PinkSkyState._initialized = True
+        self.logger = logging.getLogger(__name__)
+        self.models: Dict[str, ModelConfig] = {}
+        self.roles: Dict[str, Role] = {}
+        self.conductors: Dict[str, Conductor] = {}
+        self.current_mode: str = "chat"
+        self.current_conductor: str = "default"
+        self.current_role: str = "universal"
+        self.current_model: str = "deepseek-v4-pro"
+        self.chat_history: List[Dict[str, str]] = []
+        self.skill_history: List[Dict[str, str]] = []
+        self.build_history: List[Dict[str, str]] = []
+        self.build_context: Dict[str, Any] = {
+            "spec": "",
+            "agents": 3,
+            "models_tier": "tier1",
+            "skills_count": 2,
+            "files_count": 3,
+            "role": "universal",
+            "strategy": "parallel",
+            "use_interpreter": True,
+            "notifications": True,
+            "internet_access": True
+        }
+        self.cancel_flag: bool = False
+        self.last_history_save: Optional[datetime] = None
+        self.load_all()
+
+    def add_to_history(self, mode: str, role: str, content: str):
+        with PinkSkyState._lock:
+            entry = {
+                "role": role,
+                "content": content,
+                "timestamp": datetime.now().isoformat()
+            }
+            history_attr = f"{mode}_history"
+            history = getattr(self, history_attr, [])
+            history.append(entry)
+            setattr(self, history_attr, history)
+
+            # Сохраняем не чаще раза в 30 секунд
+            now = datetime.now()
+            if (self.last_history_save is None or
+                (now - self.last_history_save).total_seconds() > 30):
+                self.save_history()
+                self.last_history_save = now
+
+    def _build_model_config(self, name: str, data: dict) -> ModelConfig:
+        return ModelConfig(
+            name=name, provider="openai", endpoint=data["endpoint"],
+            api_key_env="NVIDIA_API_KEY",
+            context_window=data.get("context_window", 32000),
+            max_tokens=data.get("max_tokens", 8000),
+            cost_per_1k_input=data.get("cost_per_1k_input", 0.0),
+            cost_per_1k_output=data.get("cost_per_1k_output", 0.0),
+            coding_rank=data.get("coding_rank", 50),
+            speed_rank=data.get("speed_rank", 50),
+            reasoning_rank=data.get("reasoning_rank", 50),
+            tags=data.get("tags", [])
+        )
+
+    def _load_models(self):
+        defaults = {name: self._build_model_config(name, data) for name, data in MODEL_RANKING.items()}
+        if os.path.exists(MODELS_FILE):
+            try:
+                with open(MODELS_FILE, "r", encoding="utf-8") as f:
+                    custom = json.load(f)
+                    for k, v in custom.items():
+                        if k not in defaults:
+                            defaults[k] = ModelConfig(**v)
+            except Exception as e:
+                print(f"⚠️ Ошибка загрузки models.json: {e}")
+        self.models = defaults
+
+    def _load_roles(self):
+        defaults = {
+            "universal": Role(
+                name="universal",
+                prompt="You are PinkSky -- a universal AI assistant and autonomous developer. You help users with any tasks, scripts, theory, and project creation from scratch.",
+                description="Universal assistant for any tasks",
+                preferred_models=["deepseek-v4-pro", "kimi-k2.6", "qwen3.5-397b"],
+                complexity="medium",
+                tags=["general"]
+            ),
+            "guru": Role(
+                name="guru",
+                prompt="You are Guru Programmer PinkSky. 15+ years experience. Write elegant, production-ready code. Principles: KISS, explicit > implicit, composition > inheritance, PEP8, type hints, docstrings. Format: analysis -> code -> explanations -> edge cases.",
+                description="Guru programmer. Elegant code with deep explanations.",
+                preferred_models=["deepseek-v4-pro", "kimi-k2.6", "mistral-large-3", "gpt-oss-120b"],
+                complexity="high",
+                tags=["coding", "senior", "mentor", "python"]
+            ),
+            "hacker": Role(
+                name="hacker",
+                prompt="You are Hacker PinkSky. Code virtuoso. Find elegant and unconventional solutions. Use __slots__, descriptors, metaclasses. Optimize time complexity, memory layout. Love functional: itertools, functools, operator.",
+                description="Hacker-coder. Optimization and unconventional solutions.",
+                preferred_models=["deepseek-v4-pro", "deepseek-v4-flash", "llama-4-maverick", "nemotron-super-49b"],
+                complexity="high",
+                tags=["coding", "optimization", "hacks", "performance"]
+            ),
+            "architect": Role(
+                name="architect",
+                prompt="You are Software Architect PinkSky. Design systems that last years. Bounded contexts, aggregates, CQRS, Event Sourcing. API: REST, gRPC, GraphQL, WebSocket. Observability: logs, metrics, tracing from the start.",
+                description="Software Architect. High-level system design.",
+                preferred_models=["deepseek-v4-pro", "kimi-k2.6", "nemotron-3-super", "qwen3.5-397b"],
+                complexity="high",
+                tags=["architecture", "design", "system", "ddd"]
+            ),
+            "principal": Role(
+                name="principal",
+                prompt="You are Principal Engineer PinkSky. Solve problems no one else can. Refactor legacy without downtime. Platform-level: CI/CD, observability, service mesh. Engineering culture: code review, RFC process. ADR for all decisions.",
+                description="Principal engineer. Strategy, mentorship, hard problems.",
+                preferred_models=["deepseek-v4-pro", "kimi-k2.6", "mistral-large-3", "gpt-oss-120b"],
+                complexity="high",
+                tags=["leadership", "strategy", "mentoring", "legacy"]
+            ),
+            "evangelist": Role(
+                name="evangelist",
+                prompt="You are Quality Evangelist PinkSky. TDD, BDD, property-based testing, mutation testing. pytest, hypothesis, coverage, mypy, ruff, bandit. Test pyramid: unit -> integration -> e2e. CI/CD gates: coverage threshold, mutation score.",
+                description="Quality evangelist. Testing and quality culture.",
+                preferred_models=["kimi-k2.6", "deepseek-v4-pro", "mistral-medium-3.5"],
+                complexity="high",
+                tags=["quality", "testing", "tdd", "ci-cd"]
+            ),
+            "techlead": Role(
+                name="techlead",
+                prompt="You are Tech Lead PinkSky. Code review: correctness, readability, maintainability, security, performance. Find race conditions, memory leaks, injection points, N+1. must-fix vs should-fix vs nitpick. Code review = teaching, not tribunal.",
+                description="Tech Lead. Code review and team direction.",
+                preferred_models=["deepseek-v4-pro", "kimi-k2.6", "mistral-large-3", "gpt-oss-120b"],
+                complexity="high",
+                tags=["review", "leadership", "team", "mentoring"]
+            ),
+            "qa": Role(
+                name="qa",
+                prompt="You are QA Engineer PinkSky. Test cases: positive, negative, boundary, exploratory. Equivalence partitioning, boundary value analysis. Automation: Selenium, Playwright, Postman. Performance: k6, Locust. Security: OWASP Top 10.",
+                description="QA engineer. Bug hunting and test strategy.",
+                preferred_models=["mistral-small-4", "step-3.7-flash", "llama-3.3-70b", "deepseek-v4-flash"],
+                complexity="medium",
+                tags=["qa", "testing", "automation", "manual"]
+            ),
+            "sdet": Role(
+                name="sdet",
+                prompt="You are SDET PinkSky. Test frameworks: pytest plugins, custom matchers. CI/CD: parallel execution, test sharding. Test data: factories, fixtures, seeding, cleanup. Mocks/stubs/fakes: wiremock, mockserver. Test code = production code.",
+                description="SDET. Autotests and test infrastructure at dev level.",
+                preferred_models=["deepseek-v4-pro", "kimi-k2.6", "llama-4-maverick", "mistral-medium-3.5"],
+                complexity="high",
+                tags=["sdet", "automation", "framework", "infrastructure"]
+            ),
+            "qe": Role(
+                name="qe",
+                prompt="You are Quality Engineer (QE) PinkSky. Analyze SDLC: where quality is lost. Shift-left testing: quality gates at every stage. Metrics: DORA, SPACE, custom KPIs. Root cause analysis: 5 Whys, Fishbone, FMEA. Every production bug = learning opportunity.",
+                description="Quality engineer. Processes, metrics, and quality culture.",
+                preferred_models=["deepseek-v4-pro", "kimi-k2.6", "nemotron-3-super"],
+                complexity="high",
+                tags=["qe", "process", "metrics", "culture", "sdlc"]
+            ),
+            "researcher": Role(
+                name="researcher",
+                prompt="You are Researcher PinkSky. Deep topic analysis. Compare approaches: trade-offs, limitations. Structure: executive summary -> details -> sources. Identify trends. Evidence > opinions. Numbers > words.",
+                description="Researcher and analyst. Deep topic analysis.",
+                preferred_models=["deepseek-v4-pro", "qwen3.5-397b", "kimi-k2.6", "gpt-oss-120b"],
+                complexity="high",
+                tags=["research", "analysis", "comparison"]
+            ),
+            "critic": Role(
+                name="critic",
+                prompt="You are Critic and Auditor PinkSky. correctness, security, performance, maintainability. race conditions, injection points, memory leaks, N+1. code smells, technical debt, architecture risks. Every issue with severity. Suggest fixes.",
+                description="Critic and auditor. Bug and issue hunting.",
+                preferred_models=["deepseek-v4-pro", "kimi-k2.6", "mistral-large-3", "gpt-oss-120b"],
+                complexity="medium",
+                tags=["audit", "security", "review", "critic"]
+            ),
+        }
+        if os.path.exists(ROLES_FILE):
+            try:
+                with open(ROLES_FILE, "r", encoding="utf-8") as f:
+                    custom = json.load(f)
+                    for k, v in custom.items():
+                        if k not in defaults:
+                            defaults[k] = Role(**v)
+            except Exception as e:
+                print(f"⚠️ Ошибка загрузки roles.json: {e}")
+        self.roles = defaults
+
+    def _load_conductors(self):
+        defaults = {
+            "default": Conductor(
+                name="default",
+                prompt="""You are Conductor PinkSky (Default). Analyze request and choose optimal roles and models.
+
+RULES:
+1. Simple questions -- 1 role, 1 model.
+2. Complex tasks -- decompose, assign roles.
+3. Consider cost: cheap for simple, powerful for complex.
+4. If code -- add critic.
+5. If architecture -- add architect.
+
+AVAILABLE ROLES: guru, hacker, architect, principal, evangelist, techlead, qa, sdet, qe, researcher, critic, universal.
+
+AVAILABLE MODELS (by coding rank, best to worst):
+TIER 1 (Elite): deepseek-v4-pro, kimi-k2.6, qwen3.5-397b, mistral-large-3, gpt-oss-120b
+TIER 2 (Strong): deepseek-v4-flash, llama-4-maverick, nemotron-3-super, mistral-medium-3.5, dracarys-llama-70b, llama-3.3-70b, nemotron-super-49b
+TIER 3 (Good): step-3.7-flash, mistral-small-4, minimax-m2.7, nemotron-super-49b-v1, llama-3.2-90b-vision
+TIER 4 (Fast): nemotron-nano-12b, nemotron-3-nano-30b, nemotron-nano-9b, nemotron-content-safety
+TIER 5 (Specialized): nemotron-3-nano-omni, diffusiongemma
+
+FORMAT (STRICT JSON):
+{"strategy": "single|sequential|parallel", "tasks": [{"role": "role_name", "model": "model_name", "prompt": "subtask"}], "synthesis_prompt": "how to combine"}""",
+                description="Standard conductor -- balance of quality and speed",
+                strategy="selective",
+                max_agents=3,
+                cost_aware=True,
+                auto_rank_by="balanced"
+            ),
+            "strict": Conductor(
+                name="strict",
+                prompt="""You are Strict Conductor PinkSky. Minimum agents, maximum efficiency.
+
+RULES:
+1. ONLY one role and one model.
+2. Cheapest model capable of solving the task.
+3. Only sequential.
+
+FORMAT (STRICT JSON):
+{"strategy": "single", "tasks": [{"role": "name", "model": "name", "prompt": "task"}], "synthesis_prompt": ""}""",
+                description="Minimum agents, minimum cost",
+                strategy="single",
+                max_agents=1,
+                cost_aware=True,
+                auto_rank_by="coding"
+            ),
+            "creative": Conductor(
+                name="creative",
+                prompt="""You are Creative Conductor PinkSky. Maximum perspectives, brainstorm.
+
+RULES:
+1. Multiple roles from different angles.
+2. Parallel strategy.
+3. guru + hacker + researcher + critic.
+4. Do not save on models -- use the best.
+
+FORMAT (STRICT JSON):
+{"strategy": "parallel", "tasks": [...], "synthesis_prompt": "synthesize creative ideas"}""",
+                description="Maximum roles, creative brainstorm",
+                strategy="parallel",
+                max_agents=5,
+                cost_aware=False,
+                auto_rank_by="coding"
+            ),
+            "economy": Conductor(
+                name="economy",
+                prompt="""You are Economy Conductor PinkSky. Solve task for minimum cost.
+
+RULES:
+1. Start with TIER 4 (fast/cheap): nemotron-nano-9b, nemotron-nano-12b, nemotron-3-nano-30b.
+2. Only if it fails -- escalate to TIER 3/2.
+3. One role, one model.
+
+FORMAT (STRICT JSON):
+{"strategy": "single", "tasks": [{"role": "name", "model": "name", "prompt": "task"}], "synthesis_prompt": ""}""",
+                description="Cheap models, budget saving",
+                strategy="single",
+                max_agents=1,
+                cost_aware=True,
+                auto_rank_by="speed"
+            ),
+            "review": Conductor(
+                name="review",
+                prompt="""You are Code Review Conductor PinkSky. Maximum quality code review.
+
+RULES:
+1. techlead (architectural review) + critic (bugs/vulnerabilities) + guru (best practices).
+2. Parallel review.
+3. Synthesize into structured report.
+
+FORMAT (STRICT JSON):
+{"strategy": "parallel", "tasks": [{"role": "techlead", "model": "deepseek-v4-pro", "prompt": "architectural review"}, {"role": "critic", "model": "kimi-k2.6", "prompt": "bug hunting"}, {"role": "guru", "model": "mistral-large-3", "prompt": "best practices"}], "synthesis_prompt": "structured report with severity"}""",
+                description="Focus on code review. Multi-angle code check.",
+                strategy="parallel",
+                max_agents=4,
+                cost_aware=True,
+                auto_rank_by="coding"
+            ),
+            "build": Conductor(
+                name="build",
+                prompt="""You are Project Build Conductor PinkSky. Build full project from spec.
+
+RULES:
+1. Sequential: architect -> guru/hacker -> sdet -> critic.
+2. Each stage -- separate call.
+
+FORMAT (STRICT JSON):
+{"strategy": "sequential", "tasks": [{"role": "architect", "model": "deepseek-v4-pro", "prompt": "architecture"}, {"role": "guru", "model": "kimi-k2.6", "prompt": "code"}, {"role": "sdet", "model": "mistral-medium-3.5", "prompt": "tests"}, {"role": "critic", "model": "gpt-oss-120b", "prompt": "audit"}], "synthesis_prompt": "assemble into single project"}""",
+                description="Project build. Architecture -> code -> tests -> audit.",
+                strategy="sequential",
+                max_agents=5,
+                cost_aware=True,
+                auto_rank_by="coding"
+            ),
+        }
+        if os.path.exists(CONDUCTORS_FILE):
+            try:
+                with open(CONDUCTORS_FILE, "r", encoding="utf-8") as f:
+                    custom = json.load(f)
+                    for k, v in custom.items():
+                        if k not in defaults:
+                            defaults[k] = Conductor(**v)
+            except Exception as e:
+                print(f"⚠️ Ошибка загрузки conductors.json: {e}")
+        self.conductors = defaults
+
+    def _load_history(self):
+        if os.path.exists(HISTORY_FILE):
+            try:
+                with open(HISTORY_FILE, "r", encoding="utf-8") as f:
+                    data = json.load(f)
+                    self.chat_history = data.get("chat", [])
+                    self.skill_history = data.get("skill", [])
+                    self.build_history = data.get("build", [])
+            except Exception as e:
+                print(f"⚠️ Ошибка загрузки истории: {e}")
+
+    def save_roles(self):
+        data = {k: {"name": v.name, "prompt": v.prompt, "description": v.description,
+                    "preferred_models": v.preferred_models, "complexity": v.complexity, "tags": v.tags}
+                for k, v in self.roles.items()}
+        with open(ROLES_FILE, "w", encoding="utf-8") as f:
+            json.dump(data, f, ensure_ascii=False, indent=2)
+
+    def save_models(self):
+        data = {k: {"name": v.name, "provider": v.provider, "endpoint": v.endpoint,
+                    "api_key_env": v.api_key_env, "context_window": v.context_window,
+                    "max_tokens": v.max_tokens, "cost_per_1k_input": v.cost_per_1k_input,
+                    "cost_per_1k_output": v.cost_per_1k_output,
+                    "coding_rank": v.coding_rank, "speed_rank": v.speed_rank, "reasoning_rank": v.reasoning_rank,
+                    "tags": v.tags}
+                for k, v in self.models.items()}
+        with open(MODELS_FILE, "w", encoding="utf-8") as f:
+            json.dump(data, f, ensure_ascii=False, indent=2)
+
+    def save_conductors(self):
+        data = {k: {"name": v.name, "prompt": v.prompt, "description": v.description,
+                    "strategy": v.strategy, "max_agents": v.max_agents, "cost_aware": v.cost_aware,
+                    "auto_rank_by": v.auto_rank_by}
+                for k, v in self.conductors.items()}
+        with open(CONDUCTORS_FILE, "w", encoding="utf-8") as f:
+            json.dump(data, f, ensure_ascii=False, indent=2)
+
+    def save_history(self):
+        data = {"chat": self.chat_history, "skill": self.skill_history, "build": self.build_history}
+        with open(HISTORY_FILE, "w", encoding="utf-8") as f:
+            json.dump(data, f, ensure_ascii=False, indent=2)
+
+    def add_to_history(self, mode: str, role: str, content: str):
+        entry = {"role": role, "content": content, "timestamp": datetime.now().isoformat()}
+        if mode == "chat":
+            self.chat_history.append(entry)
+        elif mode == "skill":
+            self.skill_history.append(entry)
+        elif mode == "build":
+            self.build_history.append(entry)
+        self.save_history()
+
+    def get_best_model(self, rank_by: str = "coding", min_tier: int = 1, max_tier: int = 5, exclude: List[str] = None) -> str:
+        exclude = exclude or []
+        candidates = []
+        for name, model in self.models.items():
+            if name in exclude or name == "hf_fallback":
+                continue
+            tier = 5
+            if model.coding_rank <= 5: tier = 1
+            elif model.coding_rank <= 12: tier = 2
+            elif model.coding_rank <= 18: tier = 3
+            elif model.coding_rank <= 24: tier = 4
+            if min_tier <= tier <= max_tier:
+                candidates.append((name, model))
+        if not candidates:
+            return "deepseek-v4-pro"
+        if rank_by == "coding":
+            candidates.sort(key=lambda x: x[1].coding_rank)
+        elif rank_by == "speed":
+            candidates.sort(key=lambda x: x[1].speed_rank)
+        elif rank_by == "reasoning":
+            candidates.sort(key=lambda x: x[1].reasoning_rank)
+        elif rank_by == "balanced":
+            candidates.sort(key=lambda x: (x[1].coding_rank + x[1].speed_rank + x[1].reasoning_rank) / 3)
+        else:
+            candidates.sort(key=lambda x: x[1].coding_rank)
+        return candidates[0][0]
+
+    def get_model_for_role(self, role_name: str, preference: str = None, rank_by: str = None) -> str:
+        role = self.roles.get(role_name)
+        if not role:
+            return preference or self.current_model
+        conductor = self.conductors.get(self.current_conductor, self.conductors["default"])
+        rank_criteria = rank_by or conductor.auto_rank_by
+        max_tier = 5
+        if role.complexity == "high":
+            max_tier = 2
+        elif role.complexity == "medium":
+            max_tier = 3
+        if preference and preference in self.models:
+            return preference
+        available = [m for m in role.preferred_models if m in self.models and m != "hf_fallback"]
+        if available:
+            if conductor.cost_aware and rank_criteria != "coding":
+                available.sort(key=lambda m: self.models[m].cost_per_1k_output)
+            else:
+                if rank_criteria == "coding":
+                    available.sort(key=lambda m: self.models[m].coding_rank)
+                elif rank_criteria == "speed":
+                    available.sort(key=lambda m: self.models[m].speed_rank)
+                elif rank_criteria == "reasoning":
+                    available.sort(key=lambda m: self.models[m].reasoning_rank)
+                else:
+                    available.sort(key=lambda m: (self.models[m].coding_rank + self.models[m].speed_rank + self.models[m].reasoning_rank) / 3)
+            return available[0]
+        return self.get_best_model(rank_by=rank_criteria, max_tier=max_tier)
+
+    def get_models_by_tier(self, tier: int) -> List[str]:
+        result = []
+        for name, model in self.models.items():
+            if name == "hf_fallback":
+                continue
+            model_tier = 5
+            if model.coding_rank <= 5: model_tier = 1
+            elif model.coding_rank <= 12: model_tier = 2
+            elif model.coding_rank <= 18: model_tier = 3
+            elif model.coding_rank <= 24: model_tier = 4
+            if model_tier == tier:
+                result.append(name)
+        return result
+
+    def get_next_tier_model(self, current_model_name: str) -> Optional[str]:
+        if current_model_name not in self.models:
+            return None
+        current = self.models[current_model_name]
+        current_tier = 5
+        if current.coding_rank <= 5: current_tier = 1
+        elif current.coding_rank <= 12: current_tier = 2
+        elif current.coding_rank <= 18: current_tier = 3
+        elif current.coding_rank <= 24: current_tier = 4
+        next_tier = current_tier + 1
+        if next_tier > 5:
+            return None
+        models_in_tier = self.get_models_by_tier(next_tier)
+        if models_in_tier:
+            return models_in_tier[0]
+        return None
+
+    def export_history_json(self) -> str:
+        return json.dumps({"exported_at": datetime.now().isoformat(), "chat": self.chat_history, "skill": self.skill_history, "build": self.build_history}, ensure_ascii=False, indent=2)
+
+    def export_history_md(self) -> str:
+        lines = ["# PinkSky History Export", ""]
+        lines.append("*Exported: " + datetime.now().strftime("%Y-%m-%d %H:%M:%S") + "*")
+        lines.append("")
+        for mode, history in [("Chat", self.chat_history), ("Skill", self.skill_history), ("Build", self.build_history)]:
+            lines.append("## " + mode + " Mode")
+            lines.append("")
+            for entry in history:
+                ts = entry.get("timestamp", "unknown")
+                role = entry.get("role", "unknown")
+                content = entry.get("content", "")
+                lines.append("### " + role + " (" + ts + ")")
+                lines.append("")
+                lines.append("```")
+                lines.append(content[:500])
+                lines.append("```")
+                lines.append("")
+        return "\n".join(lines)
+
+STATE = PinkSkyState()

telegram_utils.py

@@ -0,0 +1,96 @@
+"""Telegram утилиты: отправка сообщений и файлов"""
+import os
+import json
+import urllib.request
+import time
+import logging
+import certifi
+import requests
+from requests.adapters import HTTPAdapter
+from urllib3.util.retry import Retry
+from .config import CF_URL, TOKEN
+
+class TelegramUtils:
+    def __init__(self):
+        self.logger = logging.getLogger(__name__)
+        self.session = requests.Session()
+        retry = Retry(
+            total=3,
+            backoff_factor=1,
+            status_forcelist=[500, 502, 503, 504]
+        )
+        self.session.mount("https://", HTTPAdapter(max_retries=retry))
+
+    def send_tg(self, chat_id, text):
+        if not CF_URL or not TOKEN:
+            self.logger.warning("TG send aborted: CF_URL or TOKEN not set")
+            return
+        safe_text = str(text)[-4000:]
+        url = f"{CF_URL}/bot{TOKEN}/sendMessage"
+        data = json.dumps({
+            "chat_id": chat_id,
+            "text": safe_text,
+            "parse_mode": "Markdown"
+        }).encode('utf-8')
+        headers = {
+            "Content-Type": "application/json",
+            "User-Agent": "PinkSky/7.0 (Linux; Python)"
+        }
+        try:
+            response = self.session.post(url, data=data, headers=headers, timeout=15, verify=certifi.where())
+            response.raise_for_status()
+        except Exception as e:
+            self.logger.error(f"TG send error: {e}")
+
+    def download_tg_file(self, file_id, file_name, retries=3):
+        if not TOKEN:
+            self.logger.warning("TG download aborted: TOKEN not set")
+            return None
+        base_api = CF_URL if CF_URL else "https://api.telegram.org"
+        get_file_url = f"{base_api}/bot{TOKEN}/getFile?file_id={file_id}"
+        for attempt in range(retries):
+            try:
+                response = self.session.get(get_file_url, timeout=15, verify=certifi.where())
+                response.raise_for_status()
+                res = response.json()
+                if not res.get("ok"):
+                    return None
+                file_path = res["result"]["file_path"]
+                dl_url = f"{base_api}/file/bot{TOKEN}/{file_path}"
+                os.makedirs("downloads", exist_ok=True)
+                safe_name = os.path.basename(file_name)
+                local_path = os.path.join("downloads", safe_name)
+
+                response = self.session.get(dl_url, stream=True, timeout=60, verify=certifi.where())
+                response.raise_for_status()
+                with open(local_path, "wb") as f:
+                    for chunk in response.iter_content(chunk_size=8192):
+                        if chunk:
+                            f.write(chunk)
+                return local_path
+            except Exception as e:
+                self.logger.warning(f"TG download attempt {attempt + 1} failed: {e}")
+                time.sleep(2)
+        return None
+
+    def send_tg_file(self, chat_id, file_path):
+        if not os.path.exists(file_path):
+            self.send_tg(chat_id, f"▸ ✗ ᴇʀʀᴏʀ\nFile not found: `{file_path}`")
+            return
+        base_api = CF_URL if CF_URL else "https://api.telegram.org"
+        url = f"{base_api}/bot{TOKEN}/sendDocument"
+        self.send_tg(chat_id, f"╭───────────────────╮\n │ 📤 ꜰɪʟᴇ ᴜᴘʟᴏᴀᴅɪɴɢ │\n ├───────────────────┤\n │ `{os.path.basename(file_path)}` │\n╰───────────────────╯")
+        try:
+            with open(file_path, 'rb') as f:
+                files = {'document': f}
+                response = self.session.post(url, data={'chat_id': chat_id}, files=files, timeout=60, verify=certifi.where())
+                response.raise_for_status()
+        except Exception as e:
+            self.send_tg(chat_id, f"▸ ⚠️ ꜰɪʟᴇ ɪssᴜᴇ\n{str(e)[:200]}")
+
+# Singleton instance
+TG_UTILS = TelegramUtils()
+send_tg = TG_UTILS.send_tg
+download_tg_file = TG_UTILS.download_tg_file
+send_tg_file = TG_UTILS.send_tg_file
+

universal_agent.py

@@ -0,0 +1,148 @@
+"""Универсальный агент с поддержкой Open Interpreter"""
+import json
+import logging
+import urllib.request
+import re
+from datetime import datetime
+from typing import Dict, List, Optional, Any
+from .models import Role, ModelConfig
+from .config import API_KEY, API_BASE, HF_TOKEN
+from .file_manager import FILE_MANAGER
+from .internet_agent import INTERNET_AGENT
+from .notification_system import NOTIFICATIONS
+from .process_manager import PROCESS_MANAGER
+from .state import STATE
+from .interpreter_config import configure_interpreter_for_model
+
+class UniversalAgent:
+    def __init__(self, role: Role, model: ModelConfig, use_interpreter: bool = False):
+        self.role = role
+        self.model = model
+        self.use_interpreter = use_interpreter
+        self.conversation_history: List[Dict[str, str]] = []
+        self.file_manager = FILE_MANAGER
+        self.internet = INTERNET_AGENT
+        self.notifications = NOTIFICATIONS
+        self.logger = logging.getLogger(__name__)
+        self.tools = {
+            "search_web": self.internet.search_web,
+            "fetch_page": self.internet.fetch_page,
+            "analyze_website": self.internet.analyze_website,
+            "read_file": self.file_manager.read_file,
+            "save_file": self.file_manager.save_file,
+            "list_files": self.file_manager.list_files,
+            "analyze_file": self.file_manager.analyze_file,
+        }
+
+    def _add_tools_to_task(self, task: str) -> str:
+        tools_desc = "\n\n🔧 ᴀᴠᴀɪʟᴀʙʟᴇ ᴛᴏᴏʟs（｡◕‿◕｡）:\n"
+        for name, func in self.tools.items():
+            tools_desc += f"▹ {name}: {func.__doc__ or 'No description'}\n"
+        return task + tools_desc
+
+    def execute(self, task: str, sys_prompt_override: str = None, chat_id: str = None,
+                history: List[Dict[str, str]] = None, mode: str = "chat") -> str:
+        start_time = datetime.now()
+        self.logger.info(f"Executing task in {mode} mode with role {self.role.name} and model {self.model.name}")
+
+        if self.use_interpreter and mode in ("skill", "build"):
+            result = self._execute_with_interpreter(task, chat_id, mode)
+        else:
+            result = self._execute_with_api(task, sys_prompt_override, chat_id, history, mode)
+
+        duration = (datetime.now() - start_time).total_seconds()
+        self.logger.info(f"Task completed in {duration:.2f}s. Tokens: {len(result)} chars")
+        return result
+
+    def _execute_with_interpreter(self, task: str, chat_id: str = None, mode: str = "chat") -> str:
+        if not configure_interpreter_for_model(self.model.name, STATE, API_KEY, API_BASE):
+            return "▸ ⚠️ ɪɴᴛᴇʀᴘʀᴇᴛᴇʀ ᴅɪsᴀʙʟᴇᴅ\nFalling back to API..."
+        try:
+            from interpreter import interpreter
+            base_instructions = interpreter.custom_instructions or ""
+            interpreter.custom_instructions = (
+                f"{base_instructions}\n\n"
+                f"🎭 ᴄᴜʀʀᴇɴᴛ ʀᴏʟᴇ\n{self.role.prompt[:1000]}"
+            )
+            messages = interpreter.chat(task, display=False)
+            interpreter.custom_instructions = base_instructions
+            if messages and len(messages) > 0:
+                return f"╭───────────────────╮\n │ ✅ ᴛᴀsᴋ ᴄᴏᴍᴘʟᴇᴛᴇᴅ │\n ├───────────────────┤\n{str(messages[-1].get('content', ''))[-2000:]}\n╰───────────────────╯"
+            return "▸ ⚠️ ɪɴᴛᴇʀᴘʀᴇᴛᴇʀ: No response."
+        except Exception as e:
+            self.logger.error(f"Interpreter error: {e}")
+            return f"▸ ⚠️ ɪɴᴛᴇʀᴘʀᴇᴛᴇʀ ᴇʀʀᴏʀ\n{str(e)[:500]}\nFalling back to API..."
+
+    def _execute_with_api(self, task: str, sys_prompt_override: str = None, chat_id: str = None,
+                          history: List[Dict[str, str]] = None, mode: str = "chat") -> str:
+        system_prompt = sys_prompt_override or self.role.prompt
+        messages = [{"role": "system", "content": system_prompt}]
+        if history:
+            for h in history[-10:]:
+                messages.append({"role": h.get("role", "user"), "content": h.get("content", "")})
+        messages.append({"role": "user", "content": task})
+
+        if self.model.provider == "hf":
+            return self._call_hf(messages, chat_id)
+        return self._call_openai_compatible(messages, chat_id)
+
+    def _call_openai_compatible(self, messages: List[Dict], chat_id: str = None) -> str:
+        url = f"{API_BASE}/chat/completions"
+        data = json.dumps({
+            "model": self.model.endpoint,
+            "messages": messages,
+            "temperature": 0.7,
+            "max_tokens": self.model.max_tokens
+        }).encode('utf-8')
+        headers = {
+            "Authorization": f"Bearer {API_KEY}",
+            "Content-Type": "application/json"
+        }
+        req = urllib.request.Request(url, data=data, headers=headers)
+        try:
+            with urllib.request.urlopen(req, timeout=45) as response:
+                res = json.loads(response.read().decode('utf-8'))
+                content = res['choices'][0]['message']['content']
+                return (
+                    "╭───────────────────╮\n"
+                    " │ 🤖 ᴀɢᴇɴᴛ ʀᴇsᴘᴏɴsᴇ │\n"
+                    "├───────────────────┤\n"
+                    f"{content[:2000]}\n"
+                    "╰───────────────────╯"
+                )
+        except Exception as e:
+            self.logger.error(f"Primary API failed: {e}")
+            return self._tiered_fallback(messages, e, chat_id)
+
+    def _tiered_fallback(self, messages: List[Dict], primary_error, chat_id: str = None) -> str:
+        if chat_id:
+            from .telegram_utils import send_tg
+            send_tg(chat_id, "▸ ⚠️ ᴍᴏᴅᴇʟ ᴇʀʀᴏʀ\nFallback to cheaper tier...")
+        tried = [self.model.name]
+        current = self.model.name
+        while True:
+            next_model = STATE.get_next_tier_model(current)
+            if not next_model or next_model in tried:
+                break
+            tried.append(next_model)
+            model_cfg = STATE.models.get(next_model)
+            if not model_cfg:
+                break
+            try:
+                agent = UniversalAgent(self.role, model_cfg)
+                if model_cfg.provider == "hf":
+                    result = agent._call_hf(messages, chat_id)
+                else:
+                    result = agent._call_openai_compatible(messages, chat_id)
+                return (
+                    f"{result}\n\n"
+                    "╭───────────────────╮\n"
+                    " │ ✅ ᴛɪᴇʀᴇᴅ ꜰᴀʟʟʙᴀᴄᴋ │\n"
+                    f" ├───────────────────┤\n"
+                    f" │ {next_model} │\n"
+                    "╰───────────────────╯"
+                )
+            except Exception as e:
+                current = next_model
+        return self._fallback_hf(messages, primary_error, chat_id, tried)
+