mindroot 9.2.0__py3-none-any.whl → 9.5.0__py3-none-any.whl

mindroot/coreplugins/l8n/utils.py

@@ -0,0 +1,232 @@
+# need to import Path
+from pathlib import Path
+from .l8n_constants import *
+import json
+import re
+import logging
+
+# Set up logging for l8n warnings
+logger = logging.getLogger('l8n')
+logger.setLevel(logging.WARNING)
+
+# Create console handler with formatting
+if not logger.handlers:
+    console_handler = logging.StreamHandler()
+    console_handler.setLevel(logging.WARNING)
+    formatter = logging.Formatter('\033[91m[L8N WARNING]\033[0m %(message)s')
+    console_handler.setFormatter(formatter)
+    logger.addHandler(console_handler)
+
+def extract_plugin_root(absolute_path: str) -> str:
+    """
+    Extract the plugin root from an absolute path.
+    
+    For core plugins: everything after 'coreplugins/'
+    For external plugins: everything after 'src/[plugin_name]/'
+    
+    Examples:
+    - /files/mindroot/src/mindroot/coreplugins/chat/templates/chat.jinja2 -> chat/templates/chat.jinja2
+    - /some/path/src/my_plugin/templates/page.jinja2 -> my_plugin/templates/page.jinja2
+    """
+    path = Path(absolute_path)
+    parts = path.parts
+    
+    # Find coreplugins in the path
+    if 'coreplugins' in parts:
+        coreplugins_idx = parts.index('coreplugins')
+        if coreplugins_idx + 1 < len(parts):
+            return '/'.join(parts[coreplugins_idx + 1:])
+    
+    # Find src/[plugin_name] pattern for external plugins
+    for i, part in enumerate(parts):
+        if part == 'src' and i + 1 < len(parts):
+            # Check if this looks like a plugin (has templates, static, etc.)
+            potential_plugin = parts[i + 1]
+            if i + 2 < len(parts):  # Has more path after src/plugin_name
+                return '/'.join(parts[i + 1:])
+    
+    # Fallback: return the filename
+    return path.name
+
+def extract_translation_keys(content: str) -> set:
+    """
+    Extract all __TRANSLATE_key__ placeholders from content.
+    
+    Args:
+        content: Content to scan for translation keys
+        
+    Returns:
+        Set of translation keys found in the content
+    """
+    pattern = r'__TRANSLATE_([a-z0-9_]+)__'
+    matches = re.findall(pattern, content)
+    return set(matches)
+
+def replace_placeholders(content: str, language: str, plugin_path: str = None) -> str:
+    """
+    Replace __TRANSLATE_key__ placeholders with actual translations.
+    
+    This function now validates that ALL required translations are available
+    for the specified language. If any translations are missing, it logs
+    a strong warning and returns None to indicate fallback is needed.
+    
+    Args:
+        content: Template content with placeholders
+        language: Language code for translations
+        plugin_path: Path to the localized file (used to determine which plugin's translations to use)
+    
+    Returns:
+        Content with placeholders replaced by translations, or None if translations are incomplete
+    """
+    if not plugin_path:
+        # No plugin path provided, return content unchanged
+        logger.warning("No plugin path provided for translation replacement.")
+        return content
+    
+    try:
+        # Extract all translation keys from the content
+        required_keys = extract_translation_keys(content)
+        
+        if not required_keys:
+            # No translation keys found, return content as-is
+            return content
+        
+        # Extract plugin name from the localized file path
+        # Path format: .../localized_files/[coreplugins|external_plugins]/[plugin_name]/...
+        path_parts = Path(plugin_path).parts
+        
+        # Find 'localized_files' in the path
+        if 'localized_files' in path_parts:
+            idx = path_parts.index('localized_files')
+            if idx + 2 < len(path_parts):
+                # Get plugin name (should be at idx+2)
+                plugin_type = path_parts[idx + 1]  # 'coreplugins' or 'external_plugins'
+                plugin_name = path_parts[idx + 2]
+                
+                # Load translations for this plugin
+                translations_path = TRANSLATIONS_DIR / plugin_type / plugin_name / "translations.json"
+                plugin_translations = {}
+                if translations_path.exists():
+                    try:
+                        with open(translations_path, 'r', encoding='utf-8') as f:
+                             plugin_translations = json.load(f)
+                    except Exception as e:
+                        logger.warning(f"Could not load translations from {translations_path}: {e}")
+                        return None  # Fallback to original file
+                
+                if language in plugin_translations:
+                    translations = plugin_translations[language]
+                    
+                    # Check if ALL required translations are available
+                    missing_keys = required_keys - set(translations.keys())
+                    
+                    if missing_keys:
+                        # Some translations are missing - log strong warning and return None
+                        missing_list = ', '.join(sorted(missing_keys))
+                        logger.warning(
+                            f"\n" +
+                            f"="*80 + "\n" +
+                            f"MISSING TRANSLATIONS DETECTED!\n" +
+                            f"Plugin: {plugin_name}\n" +
+                            f"Language: {language}\n" +
+                            f"File: {plugin_path}\n" +
+                            f"Missing keys: {missing_list}\n" +
+                            f"Falling back to original file to avoid showing placeholders.\n" +
+                            f"="*80
+                        )
+                        return None  # Signal that fallback is needed
+                    
+                    # All translations are available - proceed with replacement
+                    def replace_match(match):
+                        key = match.group(1)
+                        return translations.get(key, match.group(0))  # This shouldn't happen now
+                    
+                    return re.sub(r'__TRANSLATE_([a-z0-9_]+)__', replace_match, content)
+                else:
+                    # No translations for this language
+                    logger.warning(
+                        f"\n" +
+                        f"="*80 + "\n" +
+                        f"NO TRANSLATIONS FOR LANGUAGE!\n" +
+                        f"Plugin: {plugin_name}\n" +
+                        f"Language: {language}\n" +
+                        f"File: {plugin_path}\n" +
+                        f"Required keys: {', '.join(sorted(required_keys))}\n" +
+                        f"Falling back to original file.\n" +
+                        f"="*80
+                    )
+                    return None  # Signal that fallback is needed
+            else:
+                logger.warning(f"Could not extract plugin info from path: {plugin_path}")
+                return None
+        else:
+            logger.warning(f"Path does not contain 'localized_files': {plugin_path}")
+            return None
+        
+    except Exception as e:
+        logger.warning(f"Error in replace_placeholders: {e}")
+        return None  # Fallback to original file on any error
+       
+def get_localized_file_path(original_path: str) -> Path:
+    """
+    Convert an original file path to its localized version path.
+    
+    Examples:
+    - chat/templates/chat.jinja2 -> localized_files/coreplugins/chat/templates/chat.i18n.jinja2
+    - my_plugin/templates/page.jinja2 -> localized_files/external_plugins/my_plugin/templates/page.i18n.jinja2
+    """
+    plugin_root = extract_plugin_root(original_path)
+    path = Path(plugin_root)
+    
+    # Determine if this is a core plugin or external plugin based on the absolute path
+    if 'coreplugins' in original_path:
+        base_dir = LOCALIZED_FILES_DIR / "coreplugins"
+    else:
+        base_dir = LOCALIZED_FILES_DIR / "external_plugins"
+    
+    # Add .i18n before the file extension
+    stem = path.stem
+    suffix = path.suffix
+    new_filename = f"{stem}.i18n{suffix}"
+    
+    localized_path = base_dir / path.parent / new_filename
+    return localized_path
+
+
+def load_plugin_translations(plugin_path: str):
+    """Load translations for a specific plugin from disk."""
+
+    translations_file = get_plugin_translations_path(plugin_path)
+    
+    if translations_file.exists():
+        try:
+            with open(translations_file, 'r', encoding='utf-8') as f:
+                return json.load(f)
+        except Exception as e:
+            logger.warning(f"Could not load translations from {translations_file}: {e}")
+    else:
+        logger.warning(f"Translations file does not exist at {translations_file}")
+    return {}
+
+def get_plugin_translations_path(original_path: str) -> Path:
+    """
+    Get the path where translations should be stored for a given file.
+    
+    Example:
+    /files/mindroot/src/mindroot/coreplugins/check_list/inject/admin.jinja2
+    -> translations/coreplugins/check_list/translations.json
+    """
+    plugin_root = extract_plugin_root(original_path)
+    
+    # Determine if this is a core plugin or external plugin based on the absolute path
+    if 'coreplugins' in original_path:
+        base_dir = TRANSLATIONS_DIR / "coreplugins"
+    else:
+        base_dir = TRANSLATIONS_DIR / "external_plugins"
+    
+    # Get just the plugin name (first part of plugin_root)
+    plugin_name = Path(plugin_root).parts[0]
+    
+    return base_dir / plugin_name / "translations.json"
+
+

mindroot/coreplugins/mcp_/__init__.py

@@ -0,0 +1,14 @@
+# This import is required for the plugin to load properly
+from .mod import *
+
+# Import catalog features
+try:
+    from .catalog_commands import *
+except ImportError:
+    pass
+
+# Import additional commands
+try:
+    from .additional_commands import *
+except ImportError:
+    pass

mindroot/coreplugins/mcp_/catalog_commands.py

@@ -0,0 +1,328 @@
+import os
+import asyncio
+from typing import Dict, List, Optional, Any
+from lib.providers.commands import command
+from .catalog_manager import MCPCatalogManager
+from .mod import mcp_manager, MCPServer
+
+# Global catalog manager
+# Use current working directory for data files
+catalog_manager = MCPCatalogManager(working_dir=os.getcwd())
+
+
+@command()
+async def mcp_catalog_list(category: str = None, context=None):
+    """List MCP servers from catalog
+    
+    Example:
+    { "mcp_catalog_list": {} }
+    { "mcp_catalog_list": { "category": "utilities" } }
+    """
+    # Update running status first
+    catalog = catalog_manager.update_server_status()
+    
+    if category:
+        servers = catalog_manager.get_servers_by_category(category)
+    else:
+        servers = catalog.get("servers", {})
+    
+    # Format for display
+    result = []
+    for name, server in servers.items():
+        result.append({
+            "name": name,
+            "display_name": server.get("display_name", name),
+            "description": server.get("description", ""),
+            "category": server.get("category", "unknown"),
+            "install_method": server.get("install_method", "manual"),
+            "installed": server.get("installed", False),
+            "running": server.get("running", False),
+            "status": server.get("status", "unknown"),
+            "tools": server.get("tools", []),
+            "tags": server.get("tags", [])
+        })
+    
+    return {
+        "servers": result,
+        "count": len(result),
+        "categories": catalog_manager.get_categories()
+    }
+
+
+@command()
+async def mcp_catalog_search(query: str, context=None):
+    """Search MCP servers in catalog
+    
+    Example:
+    { "mcp_catalog_search": { "query": "calculator" } }
+    { "mcp_catalog_search": { "query": "database" } }
+    """
+    servers = catalog_manager.search_servers(query)
+    
+    result = []
+    for name, server in servers.items():
+        result.append({
+            "name": name,
+            "display_name": server.get("display_name", name),
+            "description": server.get("description", ""),
+            "category": server.get("category", "unknown"),
+            "installed": server.get("installed", False),
+            "running": server.get("running", False),
+            "tags": server.get("tags", [])
+        })
+    
+    return {
+        "query": query,
+        "results": result,
+        "count": len(result)
+    }
+
+
+@command()
+async def mcp_catalog_install(server_name: str, context=None):
+    """Install an MCP server from catalog
+    
+    Example:
+    { "mcp_catalog_install": { "server_name": "calculator" } }
+    """
+    server_info = catalog_manager.get_server_info(server_name)
+    if not server_info:
+        return f"Server {server_name} not found in catalog"
+    
+    # Create server config from catalog info
+    server = MCPServer(
+        name=server_info["name"],
+        description=server_info["description"],
+        command=server_info["command"],
+        args=server_info["args"],
+        env=server_info.get("env", {})
+    )
+    
+    # Add to manager
+    mcp_manager.add_server(server_name, server)
+    
+    # Install server if needed (for uvx/npx packages)
+    install_method = server_info.get("install_method", "manual")
+    install_package = server_info.get("install_package")
+    
+    if install_method in ["uvx", "npx"] and install_package:
+        try:
+            import subprocess
+            if install_method == "uvx":
+                result = subprocess.run(["uvx", "--help"], capture_output=True)
+                if result.returncode != 0:
+                    return f"uvx not available. Please install uv first."
+            elif install_method == "npx":
+                result = subprocess.run(["npx", "--version"], capture_output=True)
+                if result.returncode != 0:
+                    return f"npx not available. Please install Node.js first."
+        except Exception as e:
+            return f"Error checking {install_method}: {e}"
+    
+    # Mark as installed (basic implementation)
+    success = True  # For now, assume installation succeeds    
+    if success:
+        catalog_manager.mark_server_installed(server_name, True)
+        return f"Successfully installed {server_name}"
+    else:
+        return f"Failed to install {server_name}"
+
+
+@command()
+async def mcp_catalog_install_and_run(server_name: str, context=None):
+    """Install and run an MCP server from catalog
+    
+    Example:
+    { "mcp_catalog_install_and_run": { "server_name": "calculator" } }
+    """
+    try:
+        # Get server info from catalog
+        server_info = catalog_manager.get_server_info(server_name)
+        if not server_info:
+            return f"Server {server_name} not found in catalog"
+        
+        print(f"Installing and running {server_name}...")
+        
+        # Create server configuration
+        print(f"Creating server configuration for {server_name}...")
+        
+        server_config = MCPServer(
+            name=server_name,
+            description=server_info.get('description', f'MCP Server: {server_name}'),
+            command=server_info['command'],
+            args=server_info.get('args', []),
+            env=server_info.get('env', {}),
+            install_method=server_info.get('install_method', 'manual'),
+            install_package=server_info.get('install_package'),
+            auto_install=True,
+            installed=False
+        )
+        
+        # Add server to manager
+        mcp_manager.add_server(server_name, server_config)
+        
+        # Connect to the server
+        success = await mcp_manager.connect_server(server_name)
+        
+        if success:
+            # Get final server status
+            catalog_manager.update_server_status()
+            
+            # Import and call the refresh function to update dynamic commands
+            try:
+                from .mod import mcp_refresh_dynamic_commands
+                await mcp_refresh_dynamic_commands()
+            except Exception as e:
+                print(f"Warning: Could not refresh dynamic commands: {e}")
+            
+            return f"Successfully installed and connected to {server_name}. MCP tools are now available as commands."
+        else:
+            return f"Installed {server_name} but failed to connect. Check server configuration."
+            
+    except Exception as e:
+        print(f"Error in mcp_catalog_install_and_run: {e}")
+        return f"Error installing and running {server_name}: {str(e)}"
+
+
+@command()
+async def mcp_catalog_stop(server_name: str, context=None):
+    """Stop an MCP server
+    
+    Example:
+    { "mcp_catalog_stop": { "server_name": "calculator" } }
+    """
+    success = await mcp_manager.disconnect_server(server_name)
+    
+    if success:
+        catalog_manager.update_server_status()
+        return f"Successfully stopped {server_name}"
+    else:
+        return f"Failed to stop {server_name}"
+
+
+@command()
+async def mcp_catalog_status(context=None):
+    """Get status of all catalog servers
+    
+    Example:
+    { "mcp_catalog_status": {} }
+    """
+    catalog = catalog_manager.update_server_status()
+    servers = catalog.get("servers", {})
+    
+    status_summary = {
+        "total": len(servers),
+        "installed": 0,
+        "running": 0,
+        "available": 0
+    }
+    
+    server_status = []
+    
+    for name, server in servers.items():
+        installed = server.get("installed", False)
+        running = server.get("running", False)
+        
+        if installed:
+            status_summary["installed"] += 1
+        if running:
+            status_summary["running"] += 1
+        if server.get("status") == "available":
+            status_summary["available"] += 1
+        
+        server_status.append({
+            "name": name,
+            "display_name": server.get("display_name", name),
+            "installed": installed,
+            "running": running,
+            "category": server.get("category", "unknown")
+        })
+    
+    return {
+        "summary": status_summary,
+        "servers": server_status
+    }
+
+
+@command()
+async def mcp_catalog_info(server_name: str, context=None):
+    """Get detailed info about a catalog server
+    
+    Example:
+    { "mcp_catalog_info": { "server_name": "calculator" } }
+    """
+    server_info = catalog_manager.get_server_info(server_name)
+    
+    if not server_info:
+        return f"Server {server_name} not found in catalog"
+    
+    # Update running status
+    running_status = catalog_manager.detect_running_servers()
+    server_info["running"] = running_status.get(server_name, False)
+    
+    return server_info
+
+
+@command()
+async def mcp_catalog_categories(context=None):
+    """Get list of server categories
+    
+    Example:
+    { "mcp_catalog_categories": {} }
+    """
+    categories = catalog_manager.get_categories()
+    catalog = catalog_manager.load_catalog()
+    
+    # Count servers per category
+    category_counts = {}
+    for server in catalog.get("servers", {}).values():
+        category = server.get("category", "unknown")
+        category_counts[category] = category_counts.get(category, 0) + 1
+    
+    return {
+        "categories": categories,
+        "counts": category_counts
+    }
+
+
+@command()
+async def mcp_catalog_add_custom(server_info: Dict[str, Any], context=None):
+    """Add a custom server to the catalog
+    
+    Example:
+    { "mcp_catalog_add_custom": {
+        "server_info": {
+            "name": "my_server",
+            "display_name": "My Custom Server",
+            "description": "Custom MCP server",
+            "command": "python",
+            "args": ["-m", "my_mcp_server"],
+            "category": "custom",
+            "install_method": "manual"
+        }
+    }}
+    """
+    success = catalog_manager.add_custom_server(server_info)
+    
+    if success:
+        return f"Successfully added custom server {server_info.get('name')}"
+    else:
+        return "Failed to add custom server - missing required fields"
+
+
+@command()
+async def mcp_catalog_refresh(context=None):
+    """Refresh catalog and update server status
+    
+    Example:
+    { "mcp_catalog_refresh": {} }
+    """
+    catalog = catalog_manager.update_server_status()
+    running_count = sum(1 for server in catalog.get("servers", {}).values() 
+                       if server.get("running", False))
+    
+    return {
+        "message": "Catalog refreshed",
+        "total_servers": len(catalog.get("servers", {})),
+        "running_servers": running_count
+    }