mcli-framework 7.5.1__py3-none-any.whl → 7.6.1__py3-none-any.whl

mcli/app/commands_cmd.py

@@ -290,7 +290,9 @@ def {name}_command(name: str = "World"):
     return template
 
 
-def open_editor_for_command(command_name: str, command_group: str, description: str) -> Optional[str]:
+def open_editor_for_command(
+    command_name: str, command_group: str, description: str
+) -> Optional[str]:
     """
     Open the user's default editor to allow them to write command logic.
 
@@ -306,16 +308,18 @@ def open_editor_for_command(command_name: str, command_group: str, description:
     import sys
 
     # Get the user's default editor
-    editor = os.environ.get('EDITOR')
+    editor = os.environ.get("EDITOR")
     if not editor:
         # Try common editors in order of preference
-        for common_editor in ['vim', 'nano', 'code', 'subl', 'atom', 'emacs']:
-            if subprocess.run(['which', common_editor], capture_output=True).returncode == 0:
+        for common_editor in ["vim", "nano", "code", "subl", "atom", "emacs"]:
+            if subprocess.run(["which", common_editor], capture_output=True).returncode == 0:
                 editor = common_editor
                 break
 
     if not editor:
-        click.echo("No editor found. Please set the EDITOR environment variable or install vim/nano.")
+        click.echo(
+            "No editor found. Please set the EDITOR environment variable or install vim/nano."
+        )
         return None
 
     # Create a temporary file with the template
@@ -337,7 +341,7 @@ Example Click command structure:
 @click.command()
 @click.argument('name', default='World')
 def my_command(name):
-    \"""My custom command.\"""
+    """My custom command."""
     click.echo(f"Hello, {{name}}!")
 """
 import click
@@ -363,14 +367,16 @@ logger = get_logger()
 '''
 
     # Create temporary file
-    with tempfile.NamedTemporaryFile(mode='w', suffix='.py', delete=False) as temp_file:
+    with tempfile.NamedTemporaryFile(mode="w", suffix=".py", delete=False) as temp_file:
         temp_file.write(enhanced_template)
         temp_file_path = temp_file.name
 
     try:
         # Check if we're in an interactive environment
         if not sys.stdin.isatty() or not sys.stdout.isatty():
-            click.echo("Editor requires an interactive terminal. Use --template flag for non-interactive mode.")
+            click.echo(
+                "Editor requires an interactive terminal. Use --template flag for non-interactive mode."
+            )
             return None
 
         # Open editor
@@ -386,7 +392,7 @@ logger = get_logger()
             return None
 
         # Read the edited content
-        with open(temp_file_path, 'r') as f:
+        with open(temp_file_path, "r") as f:
             edited_code = f.read()
 
         # Check if the file was actually edited (not just the template)
@@ -395,12 +401,12 @@ logger = get_logger()
             return None
 
         # Extract the actual command code (remove the instructions)
-        lines = edited_code.split('\n')
+        lines = edited_code.split("\n")
         code_lines = []
         in_code_section = False
 
         for line in lines:
-            if line.strip().startswith('# Your command implementation goes here:'):
+            if line.strip().startswith("# Your command implementation goes here:"):
                 in_code_section = True
                 continue
             if in_code_section:
@@ -410,7 +416,7 @@ logger = get_logger()
             # Fallback: use the entire file content
             code_lines = lines
 
-        final_code = '\n'.join(code_lines).strip()
+        final_code = "\n".join(code_lines).strip()
 
         if not final_code:
             click.echo("No command code found. Command creation cancelled.")
@@ -436,11 +442,12 @@ logger = get_logger()
 @commands.command("add")
 @click.argument("command_name", required=True)
 @click.option("--group", "-g", help="Command group (defaults to 'workflow')", default="workflow")
+@click.option("--description", "-d", help="Description for the command", default="Custom command")
 @click.option(
-    "--description", "-d", help="Description for the command", default="Custom command"
-)
-@click.option(
-    "--template", "-t", is_flag=True, help="Use template mode (skip editor and use predefined template)"
+    "--template",
+    "-t",
+    is_flag=True,
+    help="Use template mode (skip editor and use predefined template)",
 )
 def add_command(command_name, group, description, template):
     """
@@ -734,13 +741,13 @@ def edit_command(command_name, editor):
         return 1
 
     try:
-        with open(command_file, 'r') as f:
+        with open(command_file, "r") as f:
             command_data = json.load(f)
     except Exception as e:
         console.print(f"[red]Failed to load command: {e}[/red]")
         return 1
 
-    code = command_data.get('code', '')
+    code = command_data.get("code", "")
 
     if not code:
         console.print(f"[red]Command has no code: {command_name}[/red]")
@@ -748,13 +755,14 @@ def edit_command(command_name, editor):
 
     # Determine editor
     if not editor:
-        editor = os.environ.get('EDITOR', 'vim')
+        editor = os.environ.get("EDITOR", "vim")
 
     console.print(f"Opening command in {editor}...")
 
     # Create temp file with the code
-    with tempfile.NamedTemporaryFile(mode='w', suffix='.py', delete=False,
-                                      prefix=f"{command_name}_") as tmp:
+    with tempfile.NamedTemporaryFile(
+        mode="w", suffix=".py", delete=False, prefix=f"{command_name}_"
+    ) as tmp:
         tmp.write(code)
         tmp_path = tmp.name
 
@@ -766,7 +774,7 @@ def edit_command(command_name, editor):
             console.print(f"[yellow]Editor exited with code {result.returncode}[/yellow]")
 
         # Read edited content
-        with open(tmp_path, 'r') as f:
+        with open(tmp_path, "r") as f:
             new_code = f.read()
 
         # Check if code changed
@@ -776,20 +784,18 @@ def edit_command(command_name, editor):
 
         # Validate syntax
         try:
-            compile(new_code, '<string>', 'exec')
+            compile(new_code, "<string>", "exec")
         except SyntaxError as e:
             console.print(f"[red]Syntax error in edited code: {e}[/red]")
-            should_save = Prompt.ask(
-                "Save anyway?", choices=["y", "n"], default="n"
-            )
+            should_save = Prompt.ask("Save anyway?", choices=["y", "n"], default="n")
             if should_save.lower() != "y":
                 return 1
 
         # Update the command
-        command_data['code'] = new_code
-        command_data['updated_at'] = datetime.now().isoformat()
+        command_data["code"] = new_code
+        command_data["updated_at"] = datetime.now().isoformat()
 
-        with open(command_file, 'w') as f:
+        with open(command_file, "w") as f:
             json.dump(command_data, f, indent=2)
 
         # Update lockfile
@@ -832,7 +838,7 @@ def import_script(script_path, name, group, description, interactive):
 
     # Read the script content
     try:
-        with open(script_file, 'r') as f:
+        with open(script_file, "r") as f:
             code = f.read()
     except Exception as e:
         console.print(f"[red]Failed to read script: {e}[/red]")
@@ -849,11 +855,11 @@ def import_script(script_path, name, group, description, interactive):
 
     # Interactive editing
     if interactive:
-        editor = os.environ.get('EDITOR', 'vim')
+        editor = os.environ.get("EDITOR", "vim")
         console.print(f"Opening in {editor} for review...")
 
         # Create temp file with the code
-        with tempfile.NamedTemporaryFile(mode='w', suffix='.py', delete=False) as tmp:
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".py", delete=False) as tmp:
             tmp.write(code)
             tmp_path = tmp.name
 
@@ -861,7 +867,7 @@ def import_script(script_path, name, group, description, interactive):
             subprocess.run([editor, tmp_path], check=True)
 
             # Read edited content
-            with open(tmp_path, 'r') as f:
+            with open(tmp_path, "r") as f:
                 code = f.read()
         finally:
             Path(tmp_path).unlink(missing_ok=True)
@@ -870,6 +876,7 @@ def import_script(script_path, name, group, description, interactive):
     if not description:
         # Try to extract from docstring
         import ast
+
         try:
             tree = ast.parse(code)
             description = ast.get_docstring(tree) or f"Imported from {script_file.name}"
@@ -887,8 +894,8 @@ def import_script(script_path, name, group, description, interactive):
         metadata={
             "source": "import-script",
             "original_file": str(script_file),
-            "imported_at": datetime.now().isoformat()
-        }
+            "imported_at": datetime.now().isoformat(),
+        },
     )
 
     console.print(f"[green]Imported script as command: {name}[/green]")
@@ -902,7 +909,12 @@ def import_script(script_path, name, group, description, interactive):
 @commands.command("export-script")
 @click.argument("command_name")
 @click.option("--output", "-o", type=click.Path(), help="Output file path")
-@click.option("--standalone", "-s", is_flag=True, help="Make script standalone (add if __name__ == '__main__')")
+@click.option(
+    "--standalone",
+    "-s",
+    is_flag=True,
+    help="Make script standalone (add if __name__ == '__main__')",
+)
 def export_script(command_name, output, standalone):
     """
     Export a JSON command to a Python script.
@@ -923,14 +935,14 @@ def export_script(command_name, output, standalone):
         return 1
 
     try:
-        with open(command_file, 'r') as f:
+        with open(command_file, "r") as f:
             command_data = json.load(f)
     except Exception as e:
         console.print(f"[red]Failed to load command: {e}[/red]")
         return 1
 
     # Get the code
-    code = command_data.get('code', '')
+    code = command_data.get("code", "")
 
     if not code:
         console.print(f"[red]Command has no code: {command_name}[/red]")
@@ -950,7 +962,7 @@ def export_script(command_name, output, standalone):
 
     # Write the script
     try:
-        with open(output_file, 'w') as f:
+        with open(output_file, "w") as f:
             f.write(code)
     except Exception as e:
         console.print(f"[red]Failed to write script: {e}[/red]")

mcli/app/completion_helpers.py

@@ -183,22 +183,13 @@ class CompletionAwareLazyGroup(click.Group):
         group = self._load_group()
         return group.list_commands(ctx)
 
-    def shell_complete(self, ctx, incomplete):
+    def shell_complete(self, ctx, param, incomplete):
         """Provide shell completion using static data when possible."""
-        # For workflow group, provide static subcommand completions
-        if self.name in LAZY_COMMAND_COMPLETIONS:
-            data = LAZY_COMMAND_COMPLETIONS[self.name]
-            if "subcommands" in data:
-                items = []
-                for subcommand in data["subcommands"]:
-                    if subcommand.startswith(incomplete):
-                        items.append(CompletionItem(subcommand))
-                return items
-
-        # Fallback to loading the actual group
+        # Load the actual group to get proper completion for nested commands
+        # This ensures file path completion works for subcommands
         group = self._load_group()
         if hasattr(group, "shell_complete"):
-            return group.shell_complete(ctx, incomplete)
+            return group.shell_complete(ctx, param, incomplete)
         return []
 
     def get_params(self, ctx):

mcli/app/main.py

@@ -255,9 +255,15 @@ class LazyCommand(click.Command):
     def shell_complete(self, ctx, param, incomplete):
         """Provide shell completion for the lazily loaded command."""
         cmd = self._load_command()
+        # Delegate to the loaded command's completion
         if hasattr(cmd, "shell_complete"):
             return cmd.shell_complete(ctx, param, incomplete)
-        return []
+        # Fallback to default Click completion
+        return (
+            super().shell_complete(ctx, param, incomplete)
+            if hasattr(super(), "shell_complete")
+            else []
+        )
 
 
 class LazyGroup(click.Group):
@@ -309,9 +315,15 @@ class LazyGroup(click.Group):
     def shell_complete(self, ctx, param, incomplete):
         """Provide shell completion for the lazily loaded group."""
         group = self._load_group()
+        # Delegate to the loaded group's completion
         if hasattr(group, "shell_complete"):
             return group.shell_complete(ctx, param, incomplete)
-        return []
+        # Fallback to default Click completion
+        return (
+            super().shell_complete(ctx, param, incomplete)
+            if hasattr(super(), "shell_complete")
+            else []
+        )
 
 
 def _add_lazy_commands(app: click.Group):
@@ -334,14 +346,14 @@ def _add_lazy_commands(app: click.Group):
     except Exception as e:
         logger.debug(f"Could not load self commands: {e}")
 
-    # Shell completion - load immediately as it's lightweight and useful
+    # Test group - load immediately for testing commands
     try:
-        from mcli.app.completion_cmd import completion
+        from mcli.test.test_cmd import test_group
 
-        app.add_command(completion, name="completion")
-        logger.debug("Added completion commands")
-    except ImportError as e:
-        logger.debug(f"Could not load completion commands: {e}")
+        app.add_command(test_group, name="test")
+        logger.debug("Added test group commands")
+    except Exception as e:
+        logger.debug(f"Could not load test commands: {e}")
 
     # Add workflow with completion-aware lazy loading
     try:
@@ -374,22 +386,6 @@ def _add_lazy_commands(app: click.Group):
             "import_path": "mcli.app.model_cmd.model",
             "help": "Model management commands for offline and online model usage",
         },
-        "cron-test": {
-            "import_path": "mcli.app.cron_test_cmd.cron_test",
-            "help": "🕒 Validate and test MCLI cron/scheduler functionality with comprehensive tests.",
-        },
-        "visual": {
-            "import_path": "mcli.app.visual_cmd.visual",
-            "help": "🎨 Visual effects and enhancements showcase",
-        },
-        "redis": {
-            "import_path": "mcli.app.redis_cmd.redis_group",
-            "help": "🗄️  Manage Redis cache service for performance optimization",
-        },
-        "logs": {
-            "import_path": "mcli.app.logs_cmd.logs_group",
-            "help": "📋 Stream and manage MCLI log files with real-time updates",
-        },
     }
 
     for cmd_name, cmd_info in lazy_commands.items():
@@ -397,7 +393,7 @@ def _add_lazy_commands(app: click.Group):
         if cmd_name == "workflow":
             continue
 
-        if cmd_name in ["model", "redis", "logs"]:
+        if cmd_name in ["model"]:
             # Use completion-aware LazyGroup for commands that have subcommands
             try:
                 from mcli.app.completion_helpers import create_completion_aware_lazy_group

mcli/app/model_cmd.py

@@ -18,6 +18,86 @@ from mcli.workflow.model_service.lightweight_model_server import (
 logger = get_logger(__name__)
 
 
+def _start_openai_server(server, host: str, port: int, api_key: Optional[str], model: str):
+    """Start FastAPI server with OpenAI compatibility"""
+    try:
+        import uvicorn
+        from fastapi import FastAPI
+        from fastapi.middleware.cors import CORSMiddleware
+
+        from mcli.workflow.model_service.openai_adapter import create_openai_adapter
+
+        # Create FastAPI app
+        app = FastAPI(
+            title="MCLI Model Service (OpenAI Compatible)",
+            description="OpenAI-compatible API for MCLI lightweight models",
+            version="1.0.0",
+        )
+
+        # Add CORS middleware
+        app.add_middleware(
+            CORSMiddleware,
+            allow_origins=["*"],
+            allow_credentials=True,
+            allow_methods=["*"],
+            allow_headers=["*"],
+        )
+
+        # Create OpenAI adapter
+        require_auth = api_key is not None
+        adapter = create_openai_adapter(server, require_auth=require_auth)
+
+        # Add API key if provided
+        if api_key:
+            adapter.api_key_manager.add_key(api_key, name="default")
+            click.echo(f"🔐 API key authentication enabled")
+
+        # Include OpenAI routes
+        app.include_router(adapter.router)
+
+        # Add health check endpoint
+        @app.get("/health")
+        async def health():
+            return {"status": "healthy", "model": model}
+
+        # Display server info
+        click.echo(f"\n📝 Server running at:")
+        click.echo(f"   - Base URL: http://{host}:{port}")
+        click.echo(f"   - OpenAI API: http://{host}:{port}/v1")
+        click.echo(f"   - Models: http://{host}:{port}/v1/models")
+        click.echo(f"   - Chat: http://{host}:{port}/v1/chat/completions")
+        click.echo(f"   - Health: http://{host}:{port}/health")
+
+        if require_auth:
+            click.echo(f"\n🔐 Authentication: Required")
+            click.echo(f"   Use: Authorization: Bearer {api_key}")
+        else:
+            click.echo(f"\n⚠️  Authentication: Disabled (not recommended for public access)")
+
+        if host == "0.0.0.0":
+            click.echo(f"\n⚠️  Server is publicly accessible on all interfaces!")
+
+        click.echo(f"\n📚 For aider, use:")
+        if require_auth:
+            click.echo(f"   export OPENAI_API_KEY={api_key}")
+        click.echo(f"   export OPENAI_API_BASE=http://{host}:{port}/v1")
+        click.echo(f"   aider --model {model}")
+
+        click.echo(f"\n   Press Ctrl+C to stop the server")
+
+        # Start server
+        uvicorn.run(app, host=host, port=port, log_level="info")
+
+    except ImportError as e:
+        click.echo(f"❌ Missing dependencies for OpenAI-compatible server: {e}")
+        click.echo(f"   Install with: pip install fastapi uvicorn")
+        sys.exit(1)
+    except Exception as e:
+        click.echo(f"❌ Failed to start OpenAI-compatible server: {e}")
+        logger.error(f"Server error: {e}", exc_info=True)
+        sys.exit(1)
+
+
 @click.group()
 def model():
     """Model management commands for offline and online model usage."""
@@ -103,13 +183,34 @@ def download(model_name: str):
 @click.option(
     "--port", "-p", default=None, help="Port to run server on (default: from config or 51234)"
 )
+@click.option(
+    "--host", "-h", default="localhost", help="Host to bind to (use 0.0.0.0 for public access)"
+)
 @click.option(
     "--auto-download",
     is_flag=True,
     default=True,
     help="Automatically download model if not available",
 )
-def start(model: Optional[str], port: Optional[int], auto_download: bool):
+@click.option(
+    "--openai-compatible",
+    is_flag=True,
+    default=False,
+    help="Enable OpenAI-compatible API endpoints",
+)
+@click.option(
+    "--api-key",
+    default=None,
+    help="API key for authentication (if not set, auth is disabled)",
+)
+def start(
+    model: Optional[str],
+    port: Optional[int],
+    host: str,
+    auto_download: bool,
+    openai_compatible: bool,
+    api_key: Optional[str],
+):
     """Start the lightweight model server."""
     # Load port from config if not specified
     if port is None:
@@ -155,15 +256,24 @@ def start(model: Optional[str], port: Optional[int], auto_download: bool):
             click.echo(f"❌ Failed to load {model}")
             sys.exit(1)
 
-    # Start server
-    click.echo(f"🚀 Starting lightweight server on port {port}...")
-    server.start_server()
+    # Start server with OpenAI compatibility if requested
+    if openai_compatible:
+        click.echo(f"🚀 Starting OpenAI-compatible server on {host}:{port}...")
+        _start_openai_server(server, host, port, api_key, model)
+    else:
+        click.echo(f"🚀 Starting lightweight server on {host}:{port}...")
+        server.start_server()
+
+        click.echo(f"\n📝 Server running at:")
+        click.echo(f"   - API: http://{host}:{port}")
+        click.echo(f"   - Health: http://{host}:{port}/health")
+        click.echo(f"   - Models: http://{host}:{port}/models")
+
+        if host == "0.0.0.0":
+            click.echo(f"\n⚠️  Server is publicly accessible!")
+            click.echo(f"   Consider using --openai-compatible with --api-key for security")
 
-    click.echo(f"\n📝 Server running at:")
-    click.echo(f"   - API: http://localhost:{port}")
-    click.echo(f"   - Health: http://localhost:{port}/health")
-    click.echo(f"   - Models: http://localhost:{port}/models")
-    click.echo(f"\n   Press Ctrl+C to stop the server")
+        click.echo(f"\n   Press Ctrl+C to stop the server")
 
     try:
         # Keep server running

mcli/lib/custom_commands.py

@@ -5,8 +5,8 @@ This module provides functionality to store user-created commands in a portable
 format in ~/.mcli/commands/ and automatically load them at startup.
 """
 
-import json
 import importlib.util
+import json
 import sys
 import tempfile
 from datetime import datetime
@@ -259,9 +259,7 @@ class CustomCommandManager:
             module_name = f"mcli_custom_{name}"
 
             # Create a temporary file to store the code
-            with tempfile.NamedTemporaryFile(
-                mode="w", suffix=".py", delete=False
-            ) as temp_file:
+            with tempfile.NamedTemporaryFile(mode="w", suffix=".py", delete=False) as temp_file:
                 temp_file.write(code)
                 temp_file_path = temp_file.name
 
@@ -274,12 +272,23 @@ class CustomCommandManager:
                     spec.loader.exec_module(module)
 
                     # Look for a command or command group in the module
+                    # Prioritize Groups over Commands to handle commands with subcommands correctly
                     command_obj = None
+                    found_commands = []
+
                     for attr_name in dir(module):
                         attr = getattr(module, attr_name)
-                        if isinstance(attr, (click.Command, click.Group)):
+                        if isinstance(attr, click.Group):
+                            # Found a group - this takes priority
                             command_obj = attr
                             break
+                        elif isinstance(attr, click.Command):
+                            # Store command for fallback
+                            found_commands.append(attr)
+
+                    # If no group found, use the first command
+                    if not command_obj and found_commands:
+                        command_obj = found_commands[0]
 
                     if command_obj:
                         # Register with the target group
@@ -288,9 +297,7 @@ class CustomCommandManager:
                         logger.info(f"Registered custom command: {name}")
                         return True
                     else:
-                        logger.warning(
-                            f"No Click command found in custom command: {name}"
-                        )
+                        logger.warning(f"No Click command found in custom command: {name}")
                         return False
             finally:
                 # Clean up temporary file
@@ -320,9 +327,7 @@ class CustomCommandManager:
             logger.error(f"Failed to export commands: {e}")
             return False
 
-    def import_commands(
-        self, import_path: Path, overwrite: bool = False
-    ) -> Dict[str, bool]:
+    def import_commands(self, import_path: Path, overwrite: bool = False) -> Dict[str, bool]:
         """
         Import commands from a JSON file.
 

mcli/ml/api/app.py

@@ -16,11 +16,7 @@ from mcli.ml.config import settings
 from mcli.ml.database.session import init_db
 from mcli.ml.logging import get_logger, setup_logging
 
-from .middleware import (
-    ErrorHandlingMiddleware,
-    RateLimitMiddleware,
-    RequestLoggingMiddleware,
-)
+from .middleware import ErrorHandlingMiddleware, RateLimitMiddleware, RequestLoggingMiddleware
 from .routers import (
     admin_router,
     auth_router,

mcli/ml/dashboard/app.py

@@ -14,6 +14,8 @@ from plotly.subplots import make_subplots
 
 from mcli.ml.cache import cache_manager
 from mcli.ml.config import settings
+from mcli.ml.dashboard.common import setup_page_config
+from mcli.ml.dashboard.styles import apply_dashboard_styles
 from mcli.ml.database.models import (
     BacktestResult,
     Model,
@@ -25,8 +27,6 @@ from mcli.ml.database.models import (
     User,
 )
 from mcli.ml.database.session import SessionLocal
-from mcli.ml.dashboard.common import setup_page_config
-from mcli.ml.dashboard.styles import apply_dashboard_styles
 
 # Page config - must be first
 setup_page_config(page_title="MCLI ML Dashboard")