#!/usr/bin/env python3
"""
NMP_Plus MCP Server - полная версия
Поддержка 36 команд через MCP для интеграции с Cursor
"""

import asyncio
import json
import logging
import sys
import os
from datetime import datetime
from typing import Dict, List, Optional, Any
import urllib.request
import urllib.parse

# Настраиваем логирование
log_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'logs')
os.makedirs(log_dir, exist_ok=True)

logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - 🗄️ ARCHIVE - %(levelname)s - %(message)s',
    handlers=[
        logging.FileHandler(os.path.join(log_dir, 'mcp_python.log'))
    ]
)

class NMPMCPServer:
    """Полный MCP сервер для NMP_Plus с 36 командами"""
    
    def __init__(self):
        # Приоритетный список серверов для подключения с другими таймаутами
        self.server_hosts = [
            "localhost",
            "127.0.0.1",
            "192.168.88.21"
        ]
        self.server_port = "8001"
        self.base_url = None
        self.connection_tested = False
        logging.info("🧠 NMP_Plus MCP сервер инициализирован")
    
    def test_connection(self) -> bool:
        """Тестирует соединение с разными API серверами с увеличенными таймаутами"""
        if self.connection_tested:
            return True
            
        logging.info("🔍 Тестирование соединения с API серверами...")
        
        for host in self.server_hosts:
            try:
                url = f"http://{host}:{self.server_port}/api/status"
                logging.info(f"Попытка подключения к {url}")
                
                req = urllib.request.Request(url)
                # Увеличенный таймаут для предотвращения ошибок
                with urllib.request.urlopen(req, timeout=30) as response:
                    result = json.loads(response.read().decode('utf-8'))
                    logging.info(f"Ответ от {url}: {result}")
                    
                    # Важно: проверяем success: true, а не status: ok
                    if result and result.get('success') == True:
                        self.base_url = f"http://{host}:{self.server_port}"
                        logging.info(f"✅ Соединение установлено с {self.base_url}")
                        self.connection_tested = True
                        return True
            except Exception as e:
                logging.warning(f"Не удалось подключиться к {host}: {str(e)}")
        
        logging.error("❌ Не удалось подключиться ни к одному API серверу")
        # Устанавливаем базовый URL на первый хост в списке в случае неудачи
        self.base_url = f"http://{self.server_hosts[0]}:{self.server_port}"
        return False
    
    def make_request(self, endpoint: str, data: Dict = None) -> Dict:
        """HTTP запрос к API серверу с увеличенными таймаутами"""
        # Проверяем соединение, если еще не сделали
        if not self.connection_tested:
            self.test_connection()
            
        try:
            url = f"{self.base_url}/{endpoint}"
            logging.info(f"🔍 Запрос к API: {url}")
            
            # Статус эндпойнт использует GET, остальные POST
            if endpoint == "api/status":
                req = urllib.request.Request(url)
            else:
                # Все остальные запросы к API делаем POST с JSON данными
                if data is None:
                    data = {}
                json_data = json.dumps(data).encode('utf-8')
                req = urllib.request.Request(
                    url, 
                    data=json_data,
                    headers={'Content-Type': 'application/json'}
                )
            
            # Увеличенный таймаут для предотвращения ошибок
            with urllib.request.urlopen(req, timeout=30) as response:
                result = json.loads(response.read().decode('utf-8'))
                return result
                
        except Exception as e:
            logging.error(f"HTTP request failed: {str(e)}")
            return {"error": f"Server connection failed: {str(e)}"}
    
    # ============ CORE TOOLS ============
    
    def nmp_status(self, params: Dict) -> Dict:
        """Статус системы NMP"""
        return self.make_request("api/status", {})
    
    def nmp_memory_save(self, params: Dict) -> Dict:
        """Сохранить информацию в память"""
        return self.make_request("api/memory/save", params)
    
    def nmp_memory_search(self, params: Dict) -> Dict:
        """Поиск в памяти"""
        return self.make_request("api/memory/search", params)
    
    def nmp_memory_list(self, params: Dict) -> Dict:
        """Список коллекций"""
        return self.make_request("api/memory/list", {})
    
    def nmp_memory_create(self, params: Dict) -> Dict:
        """Создать коллекцию"""
        return self.make_request("api/memory/create", params)
    
    def nmp_memory_delete(self, params: Dict) -> Dict:
        """Удалить коллекцию"""
        return self.make_request("api/memory/delete", params)
    
    def nmp_memory_stats(self, params: Dict) -> Dict:
        """Статистика системы"""
        return self.make_request("api/memory/stats", {})
    
    # ============ CODE TOOLS ============
    
    def nmp_code_error_save(self, params: Dict) -> Dict:
        """Сохранить ошибку + решение"""
        return self.make_request("api/code/error/save", params)
    
    def nmp_code_pattern_save(self, params: Dict) -> Dict:
        """Сохранить паттерн кода"""
        return self.make_request("api/code/pattern/save", params)
    
    def nmp_refactor_track(self, params: Dict) -> Dict:
        """Отслеживание рефакторинга"""
        return self.make_request("api/code/refactor/track", params)
    
    def nmp_solution_pattern(self, params: Dict) -> Dict:
        """Паттерны решений"""
        return self.make_request("api/code/solution/pattern", params)
    
    def nmp_debug_journey(self, params: Dict) -> Dict:
        """История отладки"""
        return self.make_request("api/code/debug/journey", params)
    
    def nmp_code_snippet_save(self, params: Dict) -> Dict:
        """Сохранить полезный код"""
        return self.make_request("api/code/snippet/save", params)
    
    # ============ ARCHITECTURE TOOLS ============
    
    def nmp_architecture_decision(self, params: Dict) -> Dict:
        """Сохранить архитектурное решение"""
        return self.make_request("api/architecture/decision", params)
    
    def nmp_dependency_map(self, params: Dict) -> Dict:
        """Карта зависимостей"""
        return self.make_request("api/architecture/dependency/map", params)
    
    def nmp_config_snapshot(self, params: Dict) -> Dict:
        """Снимок конфигурации"""
        return self.make_request("api/architecture/config/snapshot", params)
    
    def nmp_tech_choice_log(self, params: Dict) -> Dict:
        """Лог технических решений"""
        return self.make_request("api/architecture/tech/choice", params)
    
    def nmp_design_pattern(self, params: Dict) -> Dict:
        """Паттерн дизайна"""
        return self.make_request("api/architecture/design/pattern", params)
    
    # ============ WORKFLOW TOOLS ============
    
    def nmp_session_context(self, params: Dict) -> Dict:
        """Контекст сессии"""
        return self.make_request("api/workflow/session/context", params)
    
    def nmp_file_relations(self, params: Dict) -> Dict:
        """Связи файлов"""
        return self.make_request("api/workflow/file/relations", params)
    
    def nmp_todo_extract(self, params: Dict) -> Dict:
        """Извлечь TODO"""
        return self.make_request("api/workflow/todo/extract", params)
    
    def nmp_hotspot_analysis(self, params: Dict) -> Dict:
        """Анализ горячих точек"""
        return self.make_request("api/workflow/hotspot/analysis", params)
    
    def nmp_productivity_track(self, params: Dict) -> Dict:
        """Отслеживание продуктивности"""
        return self.make_request("api/workflow/productivity/track", params)
    
    def nmp_task_completion(self, params: Dict) -> Dict:
        """Завершение задачи"""
        return self.make_request("api/workflow/task/completion", params)
    
    # ============ GIT TOOLS ============
    
    def nmp_git_commit_analyze(self, params: Dict) -> Dict:
        """Анализ коммита"""
        return self.make_request("api/git/commit/analyze", params)
    
    def nmp_git_pattern_extract(self, params: Dict) -> Dict:
        """Извлечь паттерны из git"""
        return self.make_request("api/git/pattern/extract", params)
    
    def nmp_commit_wisdom(self, params: Dict) -> Dict:
        """Мудрость коммитов"""
        return self.make_request("api/git/commit/wisdom", params)
    
    def nmp_branch_strategy(self, params: Dict) -> Dict:
        """Стратегия ветвления"""
        return self.make_request("api/git/branch/strategy", params)
    
    # ============ CHAT TOOLS ============
    
    def nmp_chat_save(self, params: Dict) -> Dict:
        """Сохранить чат"""
        return self.make_request("api/chat/save", params)
    
    def nmp_chat_search(self, params: Dict) -> Dict:
        """Поиск в чатах"""
        return self.make_request("api/chat/search", params)
    
    def nmp_chat_global(self, params: Dict) -> Dict:
        """Глобальный чат"""
        return self.make_request("api/chat/global", params)
    
    def nmp_learning_capture(self, params: Dict) -> Dict:
        """Захват обучения"""
        return self.make_request("api/chat/learning/capture", params)
    
    def nmp_insight_save(self, params: Dict) -> Dict:
        """Сохранить инсайт"""
        return self.make_request("api/chat/insight/save", params)
    
    def nmp_knowledge_link(self, params: Dict) -> Dict:
        """Связь знаний"""
        return self.make_request("api/chat/knowledge/link", params)
    
    # ============ ANALYTICS TOOLS ============
    
    def nmp_pattern_analyze(self, params: Dict) -> Dict:
        """Анализ паттернов"""
        return self.make_request("api/analytics/pattern/analyze", params)
    
    def nmp_trend_detect(self, params: Dict) -> Dict:
        """Определение трендов"""
        return self.make_request("api/analytics/trend/detect", params)
    
    def nmp_skill_progress(self, params: Dict) -> Dict:
        """Прогресс навыков"""
        return self.make_request("api/analytics/skill/progress", params)
    
    def nmp_recommendation(self, params: Dict) -> Dict:
        """Рекомендации"""
        return self.make_request("api/analytics/recommendation", params)
    
    # ============ WEB TOOLS ============
    
    # ============ WORKFLOW ADANCED TOOLS ============
    
    def nmp_workflow_discover(self, params: Dict) -> Dict:
        """Анализ проекта и поиск похожих"""
        return self.make_request("api/workflow/discover", params)
    
    def nmp_workflow_plan(self, params: Dict) -> Dict:
        """Планирование с опытом"""
        return self.make_request("api/workflow/plan", params)

    # ============ MCP Protocol Handlers ============
    
    def list_tools(self) -> Dict:
        """Список всех доступных инструментов для MCP"""
        logging.info("Предоставление списка инструментов для MCP")
        return {
            "tools": [
                # CORE TOOLS
                { 
                    "name": "mcp_nmp_memory_save", 
                    "description": "Save information to NMP memory",
                    "inputSchema": {
                        "type": "object",
                        "properties": {
                            "content": {"type": "string", "description": "Content to save"},
                            "collection": {"type": "string", "description": "Collection name"},
                            "tags": {"type": "array", "items": {"type": "string"}, "description": "Tags"}
                        },
                        "required": ["content", "collection"],
                        "additionalProperties": False
                    }
                },
                { 
                    "name": "mcp_nmp_memory_search", 
                    "description": "Search in NMP memory",
                    "inputSchema": {
                        "type": "object",
                        "properties": {
                            "query": {"type": "string", "description": "Search query"},
                            "collection": {"type": "string", "description": "Collection name"},
                            "limit": {"type": "number", "description": "Max results"}
                        },
                        "required": ["query", "collection"],
                        "additionalProperties": False
                    }
                },
                { 
                    "name": "mcp_nmp_memory_list", 
                    "description": "List NMP collections",
                    "inputSchema": {
                        "type": "object",
                        "properties": {},
                        "required": [],
                        "additionalProperties": False
                    }
                },
                { 
                    "name": "mcp_nmp_memory_create", 
                    "description": "Create NMP collection",
                    "inputSchema": {
                        "type": "object",
                        "properties": {
                            "name": {"type": "string", "description": "Collection name"}
                        },
                        "required": ["name"],
                        "additionalProperties": False
                    }
                },
                { 
                    "name": "mcp_nmp_memory_delete", 
                    "description": "Delete NMP collection",
                    "inputSchema": {
                        "type": "object",
                        "properties": {
                            "name": {"type": "string", "description": "Collection name"}
                        },
                        "required": ["name"],
                        "additionalProperties": False
                    }
                },
                { 
                    "name": "mcp_nmp_memory_stats", 
                    "description": "NMP system statistics",
                    "inputSchema": {
                        "type": "object",
                        "properties": {},
                        "required": [],
                        "additionalProperties": False
                    }
                },
                
                # CODE TOOLS
                { 
                    "name": "mcp_nmp_code_error_save", 
                    "description": "Save code error + solution",
                    "inputSchema": {
                        "type": "object",
                        "properties": {
                            "error": {"type": "string", "description": "Error description"},
                            "solution": {"type": "string", "description": "Solution description"},
                            "context": {"type": "string", "description": "Error context"},
                            "tags": {"type": "array", "items": {"type": "string"}, "description": "Tags"}
                        },
                        "required": ["error", "solution"],
                        "additionalProperties": False
                    }
                },
                { 
                    "name": "mcp_nmp_code_pattern_save", 
                    "description": "Save code pattern",
                    "inputSchema": {
                        "type": "object",
                        "properties": {
                            "pattern": {"type": "string", "description": "Code pattern"},
                            "description": {"type": "string", "description": "Pattern description"},
                            "language": {"type": "string", "description": "Programming language"}
                        },
                        "required": ["pattern"],
                        "additionalProperties": False
                    }
                },
                { 
                    "name": "mcp_nmp_refactor_track", 
                    "description": "Track refactoring",
                    "inputSchema": {
                        "type": "object",
                        "properties": {
                            "before": {"type": "string", "description": "Code before refactoring"},
                            "after": {"type": "string", "description": "Code after refactoring"},
                            "reason": {"type": "string", "description": "Refactoring reason"}
                        },
                        "required": ["before", "after"],
                        "additionalProperties": False
                    }
                },
                { 
                    "name": "mcp_nmp_solution_pattern", 
                    "description": "Solution patterns",
                    "inputSchema": {
                        "type": "object",
                        "properties": {
                            "problem": {"type": "string", "description": "Problem description"},
                            "solution": {"type": "string", "description": "Solution pattern"}
                        },
                        "required": ["problem", "solution"],
                        "additionalProperties": False
                    }
                },
                { 
                    "name": "mcp_nmp_debug_journey", 
                    "description": "Debug journey history",
                    "inputSchema": {
                        "type": "object",
                        "properties": {
                            "steps": {"type": "string", "description": "Debug steps"},
                            "outcome": {"type": "string", "description": "Debug outcome"}
                        },
                        "required": ["steps"],
                        "additionalProperties": False
                    }
                },
                { 
                    "name": "mcp_nmp_code_snippet_save", 
                    "description": "Save useful code snippet",
                    "inputSchema": {
                        "type": "object",
                        "properties": {
                            "code": {"type": "string", "description": "Code snippet"},
                            "description": {"type": "string", "description": "What this code does"},
                            "language": {"type": "string", "description": "Programming language"}
                        },
                        "required": ["code"],
                        "additionalProperties": False
                    }
                },
                
                # ARCHITECTURE TOOLS  
                { 
                    "name": "mcp_nmp_architecture_decision", 
                    "description": "Architecture decisions",
                    "inputSchema": {
                        "type": "object",
                        "properties": {
                            "decision": {"type": "string", "description": "Architecture decision"},
                            "rationale": {"type": "string", "description": "Decision rationale"},
                            "alternatives": {"type": "string", "description": "Alternatives considered"}
                        },
                        "required": ["decision"],
                        "additionalProperties": False
                    }
                },
                { 
                    "name": "mcp_nmp_dependency_map", 
                    "description": "Dependency mapping",
                    "inputSchema": {
                        "type": "object",
                        "properties": {
                            "component": {"type": "string", "description": "Component name"},
                            "dependencies": {"type": "string", "description": "Dependencies list"}
                        },
                        "required": ["component"],
                        "additionalProperties": False
                    }
                },
                { 
                    "name": "mcp_nmp_config_snapshot", 
                    "description": "Configuration snapshot",
                    "inputSchema": {
                        "type": "object",
                        "properties": {
                            "config": {"type": "string", "description": "Configuration data"},
                            "environment": {"type": "string", "description": "Environment"}
                        },
                        "required": ["config"],
                        "additionalProperties": False
                    }
                },
                { 
                    "name": "mcp_nmp_tech_choice_log", 
                    "description": "Technology choice logging",
                    "inputSchema": {
                        "type": "object",
                        "properties": {
                            "technology": {"type": "string", "description": "Technology chosen"},
                            "reason": {"type": "string", "description": "Choice reason"}
                        },
                        "required": ["technology"],
                        "additionalProperties": False
                    }
                },
                { 
                    "name": "mcp_nmp_design_pattern", 
                    "description": "Design patterns",
                    "inputSchema": {
                        "type": "object",
                        "properties": {
                            "pattern": {"type": "string", "description": "Pattern name"},
                            "usage": {"type": "string", "description": "How it's used"}
                        },
                        "required": ["pattern"],
                        "additionalProperties": False
                    }
                },
                
                # WORKFLOW TOOLS
                { 
                    "name": "mcp_nmp_session_context", 
                    "description": "Work session context",
                    "inputSchema": {
                        "type": "object",
                        "properties": {
                            "session": {"type": "string", "description": "Session description"},
                            "context": {"type": "string", "description": "Session context"}
                        },
                        "required": ["session"],
                        "additionalProperties": False
                    }
                },
                { 
                    "name": "mcp_nmp_file_relations", 
                    "description": "File relations",
                    "inputSchema": {
                        "type": "object",
                        "properties": {
                            "file": {"type": "string", "description": "File path"},
                            "relations": {"type": "string", "description": "Related files"}
                        },
                        "required": ["file"],
                        "additionalProperties": False
                    }
                },
                { 
                    "name": "mcp_nmp_todo_extract", 
                    "description": "Extract TODO items",
                    "inputSchema": {
                        "type": "object",
                        "properties": {
                            "content": {"type": "string", "description": "Content to extract TODOs from"}
                        },
                        "required": ["content"],
                        "additionalProperties": False
                    }
                },
                { 
                    "name": "mcp_nmp_hotspot_analysis", 
                    "description": "Hotspot analysis",
                    "inputSchema": {
                        "type": "object",
                        "properties": {
                            "data": {"type": "string", "description": "Data for analysis"}
                        },
                        "required": ["data"],
                        "additionalProperties": False
                    }
                },
                { 
                    "name": "mcp_nmp_productivity_track", 
                    "description": "Track productivity",
                    "inputSchema": {
                        "type": "object",
                        "properties": {
                            "activity": {"type": "string", "description": "Activity description"},
                            "time": {"type": "string", "description": "Time spent"}
                        },
                        "required": ["activity"],
                        "additionalProperties": False
                    }
                },
                { 
                    "name": "mcp_nmp_task_completion", 
                    "description": "Task completion",
                    "inputSchema": {
                        "type": "object",
                        "properties": {
                            "task": {"type": "string", "description": "Task description"},
                            "status": {"type": "string", "description": "Completion status"}
                        },
                        "required": ["task"],
                        "additionalProperties": False
                    }
                },
                
                # GIT TOOLS
                { 
                    "name": "mcp_nmp_git_commit_analyze", 
                    "description": "Analyze git commit",
                    "inputSchema": {
                        "type": "object",
                        "properties": {
                            "commit": {"type": "string", "description": "Commit hash or diff"}
                        },
                        "required": ["commit"],
                        "additionalProperties": False
                    }
                },
                { 
                    "name": "mcp_nmp_git_pattern_extract", 
                    "description": "Extract patterns from git history",
                    "inputSchema": {
                        "type": "object",
                        "properties": {
                            "repository": {"type": "string", "description": "Repository path"}
                        },
                        "required": ["repository"],
                        "additionalProperties": False
                    }
                },
                { 
                    "name": "mcp_nmp_commit_wisdom", 
                    "description": "Wisdom from commits",
                    "inputSchema": {
                        "type": "object",
                        "properties": {
                            "commits": {"type": "string", "description": "Commit history"}
                        },
                        "required": ["commits"],
                        "additionalProperties": False
                    }
                },
                { 
                    "name": "mcp_nmp_branch_strategy", 
                    "description": "Branch strategies",
                    "inputSchema": {
                        "type": "object",
                        "properties": {
                            "strategy": {"type": "string", "description": "Branch strategy"}
                        },
                        "required": ["strategy"],
                        "additionalProperties": False
                    }
                },
                
                # CHAT TOOLS
                { 
                    "name": "mcp_nmp_chat_save", 
                    "description": "Save chat",
                    "inputSchema": {
                        "type": "object",
                        "properties": {
                            "conversation": {"type": "string", "description": "Chat conversation"},
                            "project": {"type": "string", "description": "Project name"},
                            "tags": {"type": "array", "items": {"type": "string"}, "description": "Tags"}
                        },
                        "required": ["conversation"],
                        "additionalProperties": False
                    }
                },
                { 
                    "name": "mcp_nmp_chat_search", 
                    "description": "Search in chats",
                    "inputSchema": {
                        "type": "object",
                        "properties": {
                            "query": {"type": "string", "description": "Search query"},
                            "project": {"type": "string", "description": "Project filter"}
                        },
                        "required": ["query"],
                        "additionalProperties": False
                    }
                },
                { 
                    "name": "mcp_nmp_chat_global", 
                    "description": "Global chat search",
                    "inputSchema": {
                        "type": "object",
                        "properties": {
                            "query": {"type": "string", "description": "Search query"},
                            "limit": {"type": "number", "description": "Max results"}
                        },
                        "required": ["query"],
                        "additionalProperties": False
                    }
                },
                { 
                    "name": "mcp_nmp_learning_capture", 
                    "description": "Capture learning moments",
                    "inputSchema": {
                        "type": "object",
                        "properties": {
                            "learning": {"type": "string", "description": "Learning content"}
                        },
                        "required": ["learning"],
                        "additionalProperties": False
                    }
                },
                { 
                    "name": "mcp_nmp_insight_save", 
                    "description": "Save insight",
                    "inputSchema": {
                        "type": "object",
                        "properties": {
                            "insight": {"type": "string", "description": "Insight content"}
                        },
                        "required": ["insight"],
                        "additionalProperties": False
                    }
                },
                { 
                    "name": "mcp_nmp_knowledge_link", 
                    "description": "Link knowledge",
                    "inputSchema": {
                        "type": "object",
                        "properties": {
                            "source": {"type": "string", "description": "Source knowledge"},
                            "target": {"type": "string", "description": "Target knowledge"}
                        },
                        "required": ["source", "target"],
                        "additionalProperties": False
                    }
                },
                
                # ANALYTICS TOOLS
                { 
                    "name": "mcp_nmp_pattern_analyze", 
                    "description": "Analyze patterns",
                    "inputSchema": {
                        "type": "object",
                        "properties": {
                            "data": {"type": "string", "description": "Data to analyze"}
                        },
                        "required": ["data"],
                        "additionalProperties": False
                    }
                },
                { 
                    "name": "mcp_nmp_trend_detect", 
                    "description": "Detect trends",
                    "inputSchema": {
                        "type": "object",
                        "properties": {
                            "data": {"type": "string", "description": "Data for trend analysis"}
                        },
                        "required": ["data"],
                        "additionalProperties": False
                    }
                },
                { 
                    "name": "mcp_nmp_skill_progress", 
                    "description": "Skill progress",
                    "inputSchema": {
                        "type": "object",
                        "properties": {
                            "skill": {"type": "string", "description": "Skill name"},
                            "progress": {"type": "string", "description": "Progress description"}
                        },
                        "required": ["skill"],
                        "additionalProperties": False
                    }
                },
                { 
                    "name": "mcp_nmp_recommendation", 
                    "description": "Recommendations",
                    "inputSchema": {
                        "type": "object",
                        "properties": {
                            "context": {"type": "string", "description": "Context for recommendations"}
                        },
                        "required": ["context"],
                        "additionalProperties": False
                    }
                }
            ]
        }
    
    def call_tool(self, name: str, arguments: Dict) -> Dict:
        """Вызов инструмента по имени и аргументам"""
        logging.info(f"Вызов инструмента: {name}")
        
        # Удаляем префикс mcp_
        clean_name = name.replace("mcp_", "")
        
        # Находим метод по имени
        method = getattr(self, clean_name, None)
        if method:
            try:
                result = method(arguments)
                # Правильный формат ответа согласно MCP 2024-11-05
                return {
                    "content": [
                        {
                            "type": "text",
                            "text": json.dumps(result, ensure_ascii=False, indent=2)
                        }
                    ]
                }
            except Exception as e:
                logging.error(f"Ошибка при вызове {clean_name}: {str(e)}")
                return {
                    "content": [
                        {
                            "type": "text", 
                            "text": f"Error: {str(e)}"
                        }
                    ]
                }
        else:
            logging.error(f"Инструмент не найден: {clean_name}")
            return {
                "content": [
                    {
                        "type": "text",
                        "text": f"Error: Tool {clean_name} not found"
                    }
                ]
            }
    
    async def handle_request(self, request: Dict) -> Dict:
        """Обработка MCP запроса"""
        method = request.get('method')
        params = request.get('params', {})
        
        logging.info(f"Получен MCP запрос: {method}")
        
        if method == 'initialize':
            return {
                "protocolVersion": "2024-11-05",
                "capabilities": { "tools": {} },
                "serverInfo": {
                    "name": "nmp-plus-mcp",
                    "version": "1.0.0"
                }
            }
        
        elif method == 'tools/list':
            return self.list_tools()
        
        elif method == 'tools/call':
            return self.call_tool(params.get('name', ''), params.get('arguments', {}))
        
        else:
            logging.warning(f"Неизвестный метод: {method}")
            return {"error": f"Unknown method: {method}"}
    
    async def run(self):
        """Запуск MCP сервера"""
        logging.info("🧠 NMP_Plus MCP Server запущен и ожидает запросы")
        
        while True:
            request = None
            try:
                line = await asyncio.get_event_loop().run_in_executor(None, sys.stdin.readline)
                if not line:
                    break
                    
                request = json.loads(line)
                response = await self.handle_request(request)
                
                out = {
                    "jsonrpc": "2.0",
                    "result": response
                }
                # MCP требует, чтобы ID не был null и всегда присутствовал в ответе
                request_id = request.get("id")
                if request_id is not None:
                    out["id"] = request_id
                else:
                    # Если ID отсутствует, это уведомление - не отправляем ответ
                    continue

                print(json.dumps(out))
                sys.stdout.flush()
                
            except Exception as e:
                logging.error(f"Ошибка обработки запроса: {str(e)}")
                err_obj = {
                    "jsonrpc": "2.0",
                    "error": {"code": -1, "message": str(e)}
                }
                if request and request.get("id") is not None:
                    err_obj["id"] = request["id"]
                    print(json.dumps(err_obj))
                    sys.stdout.flush()

async def main():
    """Основная функция"""
    logging.info("Запуск NMP_Plus MCP Server")
    server = NMPMCPServer()
    await server.run()

if __name__ == "__main__":
    asyncio.run(main())