Upload 2 files

routes.py

@@ -0,0 +1,30 @@
+"""HTTP маршруты"""
+
+from http.server import BaseHTTPRequestHandler
+import json
+from .telegram_handlers import BotHandler
+
+class WebhookHandler(BotHandler, BaseHTTPRequestHandler):
+    """Обработчик вебхуков Telegram"""
+
+    def __init__(self, request, client_address, server):
+        # Сначала инициализируем BotHandler (без аргументов)
+        BotHandler.__init__(self)
+        # Затем BaseHTTPRequestHandler (с аргументами)
+        BaseHTTPRequestHandler.__init__(self, request, client_address, server)
+
+    def do_GET(self):
+        self.send_response(200)
+        self.end_headers()
+        self.wfile.write(b"PinkSky v7.0 is running!")
+
+    def do_POST(self):
+        length = int(self.headers.get('Content-Length', 0))
+        data = json.loads(self.rfile.read(length))
+        self.send_response(200)
+        self.end_headers()
+        self.wfile.write(b"OK")
+        self.handle_message(data)
+
+    def log_message(self, format, *args):
+        pass

telegram_handlers.py

@@ -0,0 +1,318 @@
+"""Обработчики команд Telegram"""
+
+import json
+import threading
+from datetime import datetime
+from .config import ALLOWED_USER
+from .state import STATE
+from .process_manager import PROCESS_MANAGER
+from .internet_agent import INTERNET_AGENT
+from .file_manager import FILE_MANAGER
+from .notification_system import NOTIFICATIONS
+from .conductor_engine import ConductorEngine
+from .skill_orchestrator import SkillOrchestrator
+from .build_mode_editor import BuildModeEditor
+from .mode_handlers import run_chat_mode, run_skill_mode, run_build_mode
+from .telegram_utils import send_tg, download_tg_file, send_tg_file
+from .helpers import parse_skill_agents, parse_build_args, get_current_mode_info
+
+class BotHandler:
+    HELP_TEXT = """PinkSky v7.0 — МОДУЛЬНАЯ АРХИТЕКТУРА
+
+🎛️ Режимы:
+Chat — отправь сообщение
+/skill [задача] — Open Interpreter
+/build [спек] — сборка через кондуктор
+
+🎭 Роли:
+/role [guru|hacker|architect|principal|evangelist|techlead|qa|sdet|qe|researcher|critic|universal]
+/role list — список ролей
+
+🧠 Кондукторы:
+/conductor [default|strict|creative|economy|review|build]
+/conductor list — список
+
+🤖 Модели:
+/model [имя] — переключить модель
+/model list — список моделей
+
+📁 Файлы:
+/get [путь] — скачать файл
+/stop — остановить все процессы
+
+🌐 Интернет:
+/search [запрос] — поиск в интернете
+/cache — статистика кэша
+/cache clear — очистить кэш
+
+📊 Система:
+/status — текущий статус
+/history — история
+/export [json|md] — экспорт истории
+/mode — текущий режим"""
+
+    def __init__(self, *args, **kwargs):
+        # Принимаем args/kwargs для совместимости с BaseHTTPRequestHandler.__init__
+        # BotHandler не использует их напрямую
+        self.mode_editor = BuildModeEditor(STATE)
+        self.skill_orchestrator = SkillOrchestrator(STATE)
+
+    def handle_message(self, data: dict):
+        if "message" not in data:
+            return
+
+        message = data["message"]
+        chat_id = str(message.get("chat", {}).get("id", ""))
+        if ALLOWED_USER and chat_id != ALLOWED_USER:
+            return
+
+        NOTIFICATIONS.set_chat_id(chat_id)
+
+        text = message.get("text", message.get("caption", "")).strip()
+
+        file_id, file_name = None, None
+        target_msg = message
+        if "reply_to_message" in message:
+            if "document" in message["reply_to_message"] or "photo" in message["reply_to_message"]:
+                target_msg = message["reply_to_message"]
+        if "document" in target_msg:
+            file_id = target_msg["document"]["file_id"]
+            file_name = target_msg["document"].get("file_name", "document.file")
+        elif "photo" in target_msg:
+            file_id = target_msg["photo"][-1]["file_id"]
+            file_name = "photo.jpg"
+
+        file_context = ""
+        if file_id:
+            dl_path = download_tg_file(file_id, file_name)
+            if dl_path:
+                file_context = f"\n\n[SYSTEM: User attached file: ./{dl_path}]"
+                if not text:
+                    send_tg(chat_id, f"📁 Файл `{file_name}` сохранён. Ответь командой, например: `/build Что в этом файле?`")
+                    return
+
+        if not text:
+            return
+
+        parts = text.split(maxsplit=1)
+        command = parts[0].lower()
+        args = parts[1].strip() if len(parts) > 1 else ""
+
+        # === HELP ===
+        if command in ["/help", "/start"]:
+            send_tg(chat_id, self.HELP_TEXT)
+            return
+
+        # === STOP ===
+        if command == "/stop":
+            result = PROCESS_MANAGER.cancel_all()
+            send_tg(chat_id, f"{result}\n\n{self.HELP_TEXT}")
+            return
+
+        # === STATUS ===
+        if command == "/status":
+            info = get_current_mode_info()
+            stats = f"""{info}
+
+📊 Моделей: {len(STATE.models)}
+📊 Ролей: {len(STATE.roles)}
+📊 Кондукторов: {len(STATE.conductors)}
+🌐 Интернет: {'✅' if STATE.build_context.get('internet_access', True) else '❌'}
+🗑️ Кэш: {INTERNET_AGENT.get_cache_stats()}
+🧵 Активных потоков: {PROCESS_MANAGER.get_active_count()}"""
+            send_tg(chat_id, stats)
+            return
+
+        # === MODE ===
+        if command == "/mode":
+            send_tg(chat_id, get_current_mode_info())
+            return
+
+        # === CONDUCTOR ===
+        if command == "/conductor":
+            if args == "list":
+                lines = ["🧠 Доступные кондукторы:"]
+                for name, cond in STATE.conductors.items():
+                    marker = " [ACTIVE]" if name == STATE.current_conductor else ""
+                    lines.append(f"- {name}{marker}: {cond.description} [rank_by={cond.auto_rank_by}]")
+                send_tg(chat_id, "\n".join(lines))
+                return
+            if args in STATE.conductors:
+                STATE.current_conductor = args
+                send_tg(chat_id, f"🧠 Кондуктор: {args.upper()}\n{STATE.conductors[args].description}")
+            else:
+                available = ", ".join(STATE.conductors.keys())
+                send_tg(chat_id, f"Текущий: {STATE.current_conductor}\nДоступные: {available}")
+            return
+
+        # === ROLE ===
+        if command == "/role":
+            role_parts = args.split(maxsplit=1)
+            subcmd = role_parts[0].lower() if role_parts else ""
+            subargs = role_parts[1] if len(role_parts) > 1 else ""
+
+            if subcmd == "list":
+                lines = ["🎭 Доступные роли:"]
+                for name, role in STATE.roles.items():
+                    marker = " [ACTIVE]" if name == STATE.current_role else ""
+                    lines.append(f"- {name}{marker}: {role.description} (complexity: {role.complexity})")
+                send_tg(chat_id, "\n".join(lines))
+                return
+
+            if subcmd == "info" and subargs:
+                role = STATE.roles.get(subargs)
+                if role:
+                    send_tg(chat_id, f"🎭 Роль {subargs}:\n\n{role.description}\n\nComplexity: {role.complexity}\nPreferred: {', '.join(role.preferred_models)}\n\nPrompt:\n```\n{role.prompt[:500]}...\n```")
+                else:
+                    send_tg(chat_id, f"❌ Роль {subargs} не найдена")
+                return
+
+            if subcmd == "add" and subargs:
+                add_parts = subargs.split(maxsplit=1)
+                if len(add_parts) < 2:
+                    send_tg(chat_id, "Формат: /role add <name> <prompt>")
+                    return
+                new_name, new_prompt = add_parts[0], add_parts[1]
+                from .models import Role
+                STATE.roles[new_name] = Role(
+                    name=new_name, prompt=new_prompt,
+                    description=f"Custom role (added {datetime.now().strftime('%Y-%m-%d')})",
+                    complexity="medium"
+                )
+                STATE.save_roles()
+                send_tg(chat_id, f"✅ Роль {new_name} добавлена!")
+                return
+
+            if subcmd in STATE.roles:
+                STATE.current_role = subcmd
+                send_tg(chat_id, f"🎭 Роль: {subcmd.upper()}\n{STATE.roles[subcmd].description}")
+            else:
+                available = ", ".join(STATE.roles.keys())
+                send_tg(chat_id, f"Текущая: {STATE.current_role}\nДоступные: {available}")
+            return
+
+        # === MODEL ===
+        if command == "/model":
+            model_parts = args.split(maxsplit=1)
+            subcmd = model_parts[0].lower() if model_parts else ""
+            subargs = model_parts[1] if len(model_parts) > 1 else ""
+
+            if subcmd == "list":
+                lines = ["🤖 Модели (по coding rank):"]
+                for name, model in sorted(STATE.models.items(), key=lambda x: x[1].coding_rank):
+                    if name == "hf_fallback":
+                        continue
+                    marker = " [ACTIVE]" if name == STATE.current_model else ""
+                    tier = 1
+                    if model.coding_rank > 5: tier = 2
+                    if model.coding_rank > 12: tier = 3
+                    if model.coding_rank > 18: tier = 4
+                    if model.coding_rank > 24: tier = 5
+                    cost = f"${model.cost_per_1k_output}/1k" if model.cost_per_1k_output > 0 else "free"
+                    lines.append(f"- {name}{marker} -- TIER {tier} | coding={model.coding_rank} speed={model.speed_rank} reasoning={model.reasoning_rank} | {cost}")
+                send_tg(chat_id, "\n".join(lines))
+                return
+
+            if subcmd == "add" and subargs:
+                add_parts = subargs.split()
+                if len(add_parts) < 2:
+                    send_tg(chat_id, "Формат: /model add <name> <endpoint>")
+                    return
+                new_name, new_endpoint = add_parts[0], add_parts[1]
+                from .models import ModelConfig
+                STATE.models[new_name] = ModelConfig(
+                    name=new_name, provider="openai", endpoint=new_endpoint,
+                    api_key_env="NVIDIA_API_KEY"
+                )
+                STATE.save_models()
+                send_tg(chat_id, f"✅ Модель {new_name} добавлена!")
+                return
+
+            if subcmd in STATE.models:
+                STATE.current_model = subcmd
+                send_tg(chat_id, f"🤖 Модель: {subcmd.upper()}\n{STATE.models[subcmd].endpoint}")
+            else:
+                available = ", ".join([k for k in STATE.models.keys() if k != "hf_fallback"])
+                send_tg(chat_id, f"Текущая: {STATE.current_model}\nДоступные: {available}")
+            return
+
+        # === GET FILE ===
+        if command == "/get":
+            if not args:
+                send_tg(chat_id, "Использование: /get ./projects/test.py")
+            else:
+                send_tg_file(chat_id, args)
+            return
+
+        # === SEARCH ===
+        if command == "/search":
+            if not args:
+                send_tg(chat_id, "Использование: /search запрос")
+                return
+            results = INTERNET_AGENT.search_web(args)
+            if results:
+                lines = [f"🔍 Результаты поиска: {args}\n"]
+                for i, r in enumerate(results[:5], 1):
+                    lines.append(f"{i}. [{r['title']}]({r['url']})\n{r['snippet'][:150]}...\n")
+                send_tg(chat_id, "\n".join(lines))
+            else:
+                send_tg(chat_id, "❌ Ничего не найдено")
+            return
+
+        # === CACHE ===
+        if command == "/cache":
+            if args == "clear":
+                result = INTERNET_AGENT.clear_cache()
+                send_tg(chat_id, result)
+            else:
+                send_tg(chat_id, INTERNET_AGENT.get_cache_stats())
+            return
+
+        # === HISTORY ===
+        if command == "/history":
+            mode = args if args in ("chat", "skill", "build") else "chat"
+            history = getattr(STATE, f"{mode}_history", [])
+            if not history:
+                send_tg(chat_id, f"📋 История {mode} пуста")
+                return
+            lines = [f"📋 История {mode} (последние 5):"]
+            for entry in history[-5:]:
+                ts = entry.get("timestamp", "unknown")
+                role = entry.get("role", "unknown")
+                content = entry.get("content", "")[:200]
+                lines.append(f"\n[{ts}] {role}:\n{content}...")
+            send_tg(chat_id, "\n".join(lines))
+            return
+
+        # === EXPORT ===
+        if command == "/export":
+            fmt = args if args in ("json", "md") else "json"
+            if fmt == "json":
+                data = STATE.export_history_json()
+                FILE_MANAGER.save_file("exports/history.json", data)
+                send_tg_file(chat_id, "exports/history.json")
+            else:
+                data = STATE.export_history_md()
+                FILE_MANAGER.save_file("exports/history.md", data)
+                send_tg_file(chat_id, "exports/history.md")
+            return
+
+        # === BUILD MODE ===
+        if command == "/build":
+            if not args:
+                send_tg(chat_id, "Укажите спецификацию проекта.")
+                return
+            params, clean_args = parse_build_args(args)
+            run_build_mode(chat_id, clean_args, file_context, params)
+            return
+
+        # === SKILL MODE ===
+        if command == "/skill":
+            if not args:
+                send_tg(chat_id, "Укажите задачу.")
+                return
+            run_skill_mode(chat_id, args, file_context)
+            return
+
+        # === DEFAULT: CHAT MODE ===
+        run_chat_mode(chat_id, text, file_context)