mcli-framework 7.5.1__tar.gz → 7.6.0__tar.gz

{mcli_framework-7.5.1 → mcli_framework-7.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcli-framework
-Version: 7.5.1
+Version: 7.6.0
 Summary: 🚀 High-performance CLI framework with Rust extensions, AI chat, and stunning visuals
 Author-email: Luis Fernandez de la Vara <luis@lefv.io>
 Maintainer-email: Luis Fernandez de la Vara <luis@lefv.io>

{mcli_framework-7.5.1 → mcli_framework-7.6.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "mcli-framework"
-version = "7.5.1"
+version = "7.6.0"
 description = "🚀 High-performance CLI framework with Rust extensions, AI chat, and stunning visuals"
 readme = "README.md"
 requires-python = ">=3.9"

{mcli_framework-7.5.1 → mcli_framework-7.6.0}/src/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_framework-7.5.1 → mcli_framework-7.6.0}/src/mcli/app/main.py

@@ -255,9 +255,11 @@ 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 +311,11 @@ 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 +338,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 +378,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 +385,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_framework-7.5.1 → mcli_framework-7.6.0}/src/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:
+        from fastapi import FastAPI
+        from fastapi.middleware.cors import CORSMiddleware
+        import uvicorn
+
+        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_framework-7.5.1 → mcli_framework-7.6.0}/src/mcli/lib/custom_commands.py

@@ -274,12 +274,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

{mcli_framework-7.5.1/src/mcli/app → mcli_framework-7.6.0/src/mcli/self}/completion_cmd.py

@@ -27,7 +27,7 @@ def bash_completion(ctx):
 
     # Get the root CLI app
     app = ctx.find_root().command
-    complete = BashComplete(app, {}, "mcli", "complete")
+    complete = BashComplete(app, {}, "mcli", "_MCLI_COMPLETE")
     script = complete.source()
 
     click.echo("# Bash completion script for MCLI")
@@ -44,7 +44,7 @@ def zsh_completion(ctx):
 
     # Get the root CLI app
     app = ctx.find_root().command
-    complete = ZshComplete(app, {}, "mcli", "complete")
+    complete = ZshComplete(app, {}, "mcli", "_MCLI_COMPLETE")
     script = complete.source()
 
     click.echo("# Zsh completion script for MCLI")
@@ -61,7 +61,7 @@ def fish_completion(ctx):
 
     # Get the root CLI app
     app = ctx.find_root().command
-    complete = FishComplete(app, {}, "mcli", "complete")
+    complete = FishComplete(app, {}, "mcli", "_MCLI_COMPLETE")
     script = complete.source()
 
     click.echo("# Fish completion script for MCLI")
@@ -101,7 +101,7 @@ def install_completion(ctx, shell):
         if shell == "bash":
             from click.shell_completion import BashComplete
 
-            complete = BashComplete(app, {}, "mcli", "complete")
+            complete = BashComplete(app, {}, "mcli", "_MCLI_COMPLETE")
             script = complete.source()
 
             # Install to bash completion directory
@@ -130,7 +130,7 @@ def install_completion(ctx, shell):
         elif shell == "zsh":
             from click.shell_completion import ZshComplete
 
-            complete = ZshComplete(app, {}, "mcli", "complete")
+            complete = ZshComplete(app, {}, "mcli", "_MCLI_COMPLETE")
             script = complete.source()
 
             # Install to zsh completion directory
@@ -161,7 +161,7 @@ def install_completion(ctx, shell):
         elif shell == "fish":
             from click.shell_completion import FishComplete
 
-            complete = FishComplete(app, {}, "mcli", "complete")
+            complete = FishComplete(app, {}, "mcli", "_MCLI_COMPLETE")
             script = complete.source()
 
             # Install to fish completion directory

{mcli_framework-7.5.1 → mcli_framework-7.6.0}/src/mcli/self/self_cmd.py

@@ -1265,6 +1265,35 @@ def update(check: bool, pre: bool, yes: bool, skip_ci_check: bool):
 # Register the plugin group with self_app
 self_app.add_command(plugin)
 
+# Import and register new commands that have been moved to self
+try:
+    from mcli.self.completion_cmd import completion
+    self_app.add_command(completion, name="completion")
+    logger.debug("Added completion command to self group")
+except ImportError as e:
+    logger.debug(f"Could not load completion command: {e}")
+
+try:
+    from mcli.self.logs_cmd import logs_group
+    self_app.add_command(logs_group, name="logs")
+    logger.debug("Added logs command to self group")
+except ImportError as e:
+    logger.debug(f"Could not load logs command: {e}")
+
+try:
+    from mcli.self.redis_cmd import redis_group
+    self_app.add_command(redis_group, name="redis")
+    logger.debug("Added redis command to self group")
+except ImportError as e:
+    logger.debug(f"Could not load redis command: {e}")
+
+try:
+    from mcli.self.visual_cmd import visual
+    self_app.add_command(visual, name="visual")
+    logger.debug("Added visual command to self group")
+except ImportError as e:
+    logger.debug(f"Could not load visual command: {e}")
+
 # This part is important to make the command available to the CLI
 if __name__ == "__main__":
     self_app()

mcli_framework-7.6.0/src/mcli/test/test_cmd.py

@@ -0,0 +1,30 @@
+"""
+Test command group for mcli.
+Contains testing and validation utilities.
+"""
+
+import click
+
+from mcli.lib.logger.logger import get_logger
+
+logger = get_logger(__name__)
+
+
+@click.group(name="test")
+def test_group():
+    """Testing and validation commands"""
+    pass
+
+
+# Import and register subcommands
+try:
+    from mcli.test.cron_test_cmd import cron_test
+
+    test_group.add_command(cron_test, name="cron")
+    logger.debug("Added cron test command to test group")
+except ImportError as e:
+    logger.debug(f"Could not load cron test command: {e}")
+
+
+if __name__ == "__main__":
+    test_group()