mcli-framework 7.0.0__py3-none-any.whl

mcli/app/chat_cmd.py

@@ -0,0 +1,42 @@
+import click
+
+from mcli.chat.chat import ChatClient
+from mcli.chat.enhanced_chat import EnhancedChatClient
+
+
+@click.command()
+@click.option(
+    "--remote", is_flag=True, help="Use remote online models instead of local lightweight models"
+)
+@click.option("--model", "-m", help="Specific model to use (overrides default behavior)")
+@click.option(
+    "--enhanced",
+    is_flag=True,
+    default=True,
+    help="Use enhanced chat with RAG-based command search (default: enabled)",
+)
+@click.option("--classic", is_flag=True, help="Use classic chat interface without command search")
+def chat(remote: bool, model: str, enhanced: bool, classic: bool):
+    """Start an interactive chat session with the MCLI Chat Assistant.
+
+    🤖 Enhanced Mode (Default):
+    - Self-referential command discovery and suggestions
+    - RAG-based semantic search of available MCLI commands
+    - Intelligent intent analysis and contextual recommendations
+    - Real-time system status awareness
+
+    💬 Classic Mode:
+    - Traditional chat interface
+    - Basic system integration
+
+    By default, uses lightweight local models for privacy and speed.
+    Use --remote to connect to online models like OpenAI or Anthropic.
+    """
+    # Choose chat client based on options
+    if classic:
+        client = ChatClient(use_remote=remote, model_override=model)
+        client.start_interactive_session()
+    else:
+        # Use enhanced client by default
+        client = EnhancedChatClient(use_remote=remote, model_override=model)
+        client.start_interactive_session()

mcli/app/commands_cmd.py

@@ -0,0 +1,226 @@
+import json
+from typing import Optional
+
+import click
+
+from mcli.lib.api.daemon_client import get_daemon_client
+from mcli.lib.discovery.command_discovery import get_command_discovery
+from mcli.lib.ui.styling import console
+
+
+@click.group()
+def commands():
+    """Manage and execute available commands."""
+    pass
+
+
+@commands.command("list")
+@click.option("--include-groups", is_flag=True, help="Include command groups in listing")
+@click.option("--daemon-only", is_flag=True, help="Show only daemon database commands")
+@click.option("--json", "as_json", is_flag=True, help="Output as JSON")
+def list_commands(include_groups: bool, daemon_only: bool, as_json: bool):
+    """List all available commands"""
+    try:
+        if daemon_only:
+            # Show only daemon database commands
+            client = get_daemon_client()
+            result = client.list_commands(all=True)
+
+            if isinstance(result, dict):
+                commands_data = result.get("commands", [])
+            elif isinstance(result, list):
+                commands_data = result
+            else:
+                commands_data = []
+        else:
+            # Show all discovered Click commands
+            discovery = get_command_discovery()
+            commands_data = discovery.get_commands(include_groups=include_groups)
+
+        if as_json:
+            click.echo(
+                json.dumps({"commands": commands_data, "total": len(commands_data)}, indent=2)
+            )
+            return
+
+        if not commands_data:
+            console.print("No commands found")
+            return
+
+        console.print(f"[bold]Available Commands ({len(commands_data)}):[/bold]")
+        for cmd in commands_data:
+            # Handle different command sources
+            if daemon_only:
+                status = "[red][INACTIVE][/red] " if not cmd.get("is_active", True) else ""
+                console.print(
+                    f"{status}• [green]{cmd['name']}[/green] ({cmd.get('language', 'python')})"
+                )
+            else:
+                group_indicator = "[blue][GROUP][/blue] " if cmd.get("is_group") else ""
+                console.print(f"{group_indicator}• [green]{cmd['full_name']}[/green]")
+
+            if cmd.get("description"):
+                console.print(f"  {cmd['description']}")
+            if cmd.get("module"):
+                console.print(f"  Module: {cmd['module']}")
+            if cmd.get("tags"):
+                console.print(f"  Tags: {', '.join(cmd['tags'])}")
+            console.print()
+
+    except Exception as e:
+        console.print(f"[red]Error: {e}[/red]")
+
+
+@commands.command("search")
+@click.argument("query")
+@click.option("--daemon-only", is_flag=True, help="Search only daemon database commands")
+@click.option("--json", "as_json", is_flag=True, help="Output as JSON")
+def search_commands(query: str, daemon_only: bool, as_json: bool):
+    """Search commands by name, description, or tags"""
+    try:
+        if daemon_only:
+            # Search only daemon database commands
+            client = get_daemon_client()
+            result = client.list_commands(all=True)
+
+            if isinstance(result, dict):
+                all_commands = result.get("commands", [])
+            elif isinstance(result, list):
+                all_commands = result
+            else:
+                all_commands = []
+
+            # Filter commands that match the query
+            matching_commands = [
+                cmd
+                for cmd in all_commands
+                if (
+                    query.lower() in cmd["name"].lower()
+                    or query.lower() in (cmd["description"] or "").lower()
+                    or any(query.lower() in tag.lower() for tag in cmd.get("tags", []))
+                )
+            ]
+        else:
+            # Search all discovered Click commands
+            discovery = get_command_discovery()
+            matching_commands = discovery.search_commands(query)
+
+        if as_json:
+            click.echo(
+                json.dumps(
+                    {
+                        "commands": matching_commands,
+                        "total": len(matching_commands),
+                        "query": query,
+                    },
+                    indent=2,
+                )
+            )
+            return
+
+        if not matching_commands:
+            console.print(f"No commands found matching '[yellow]{query}[/yellow]'")
+            return
+
+        console.print(f"[bold]Commands matching '{query}' ({len(matching_commands)}):[/bold]")
+        for cmd in matching_commands:
+            if daemon_only:
+                status = "[red][INACTIVE][/red] " if not cmd.get("is_active", True) else ""
+                console.print(
+                    f"{status}• [green]{cmd['name']}[/green] ({cmd.get('language', 'python')})"
+                )
+            else:
+                group_indicator = "[blue][GROUP][/blue] " if cmd.get("is_group") else ""
+                console.print(f"{group_indicator}• [green]{cmd['full_name']}[/green]")
+
+            console.print(f"  [italic]{cmd['description']}[/italic]")
+            if cmd.get("module"):
+                console.print(f"  Module: {cmd['module']}")
+            console.print()
+
+    except Exception as e:
+        console.print(f"[red]Error: {e}[/red]")
+
+
+@commands.command("execute")
+@click.argument("command_name")
+@click.argument("args", nargs=-1)
+@click.option("--json", "as_json", is_flag=True, help="Output as JSON")
+@click.option("--timeout", type=int, help="Execution timeout in seconds")
+def execute_command(command_name: str, args: tuple, as_json: bool, timeout: Optional[int]):
+    """Execute a command by name"""
+    try:
+        client = get_daemon_client()
+        result = client.execute_command(command_name=command_name, args=list(args), timeout=timeout)
+
+        if as_json:
+            click.echo(json.dumps(result, indent=2))
+            return
+
+        if result.get("success"):
+            if result.get("output"):
+                console.print(f"[green]Output:[/green]\n{result['output']}")
+            else:
+                console.print("[green]Command executed successfully[/green]")
+
+            if result.get("execution_time_ms"):
+                console.print(f"[dim]Execution time: {result['execution_time_ms']}ms[/dim]")
+        else:
+            console.print(f"[red]Error:[/red] {result.get('error', 'Unknown error')}")
+
+    except Exception as e:
+        console.print(f"[red]Error: {e}[/red]")
+
+
+@commands.command("info")
+@click.argument("command_name")
+@click.option("--json", "as_json", is_flag=True, help="Output as JSON")
+def command_info(command_name: str, as_json: bool):
+    """Show detailed information about a command"""
+    try:
+        client = get_daemon_client()
+        result = client.list_commands(all=True)
+
+        if isinstance(result, dict):
+            all_commands = result.get("commands", [])
+        elif isinstance(result, list):
+            all_commands = result
+        else:
+            all_commands = []
+
+        # Find the command
+        command = None
+        for cmd in all_commands:
+            if cmd["name"].lower() == command_name.lower():
+                command = cmd
+                break
+
+        if not command:
+            console.print(f"[red]Command '{command_name}' not found[/red]")
+            return
+
+        if as_json:
+            click.echo(json.dumps(command, indent=2))
+            return
+
+        console.print(f"[bold]Command: {command['name']}[/bold]")
+        console.print(f"Language: {command['language']}")
+        console.print(f"Description: {command.get('description', 'No description')}")
+        console.print(f"Group: {command.get('group', 'None')}")
+        console.print(f"Tags: {', '.join(command.get('tags', []))}")
+        console.print(f"Active: {'Yes' if command.get('is_active', True) else 'No'}")
+        console.print(f"Execution Count: {command.get('execution_count', 0)}")
+
+        if command.get("created_at"):
+            console.print(f"Created: {command['created_at']}")
+        if command.get("last_executed"):
+            console.print(f"Last Executed: {command['last_executed']}")
+
+        if command.get("code"):
+            console.print(f"\n[bold]Code:[/bold]")
+            console.print(f"```{command['language']}")
+            console.print(command["code"])
+            console.print("```")
+
+    except Exception as e:
+        console.print(f"[red]Error: {e}[/red]")

mcli/app/completion_cmd.py

@@ -0,0 +1,216 @@
+"""
+Shell completion commands for MCLI
+
+Provides commands to generate and install shell completion scripts
+for bash, zsh, and fish shells.
+"""
+
+import os
+import click
+from pathlib import Path
+from mcli.lib.ui.styling import success
+
+
+@click.group(name="completion")
+def completion():
+    """Shell completion utilities"""
+    pass
+
+
+@completion.command(name="bash")
+@click.pass_context
+def bash_completion(ctx):
+    """Generate bash completion script"""
+    from click.shell_completion import BashComplete
+    
+    # Get the root CLI app
+    app = ctx.find_root().command
+    complete = BashComplete(app, {}, "mcli", "complete")
+    script = complete.source()
+    
+    click.echo("# Bash completion script for MCLI")
+    click.echo("# Add this to your ~/.bashrc or ~/.bash_profile:")
+    click.echo()
+    click.echo(script)
+
+
+@completion.command(name="zsh") 
+@click.pass_context
+def zsh_completion(ctx):
+    """Generate zsh completion script"""
+    from click.shell_completion import ZshComplete
+    
+    # Get the root CLI app
+    app = ctx.find_root().command
+    complete = ZshComplete(app, {}, "mcli", "complete")
+    script = complete.source()
+    
+    click.echo("# Zsh completion script for MCLI")
+    click.echo("# Add this to your ~/.zshrc:")
+    click.echo()
+    click.echo(script)
+
+
+@completion.command(name="fish")
+@click.pass_context
+def fish_completion(ctx):
+    """Generate fish completion script"""
+    from click.shell_completion import FishComplete
+    
+    # Get the root CLI app
+    app = ctx.find_root().command
+    complete = FishComplete(app, {}, "mcli", "complete")
+    script = complete.source()
+    
+    click.echo("# Fish completion script for MCLI")
+    click.echo("# Add this to ~/.config/fish/completions/mcli.fish:")
+    click.echo()
+    click.echo(script)
+
+
+@completion.command(name="install")
+@click.option("--shell", type=click.Choice(['bash', 'zsh', 'fish']), 
+              help="Shell to install for (auto-detected if not specified)")
+@click.pass_context
+def install_completion(ctx, shell):
+    """Install shell completion for the current user"""
+    import subprocess
+    
+    # Auto-detect shell if not specified
+    if not shell:
+        shell_path = os.environ.get('SHELL', '')
+        if 'bash' in shell_path:
+            shell = 'bash'
+        elif 'zsh' in shell_path:
+            shell = 'zsh'
+        elif 'fish' in shell_path:
+            shell = 'fish'
+        else:
+            click.echo("❌ Could not auto-detect shell. Please specify --shell")
+            return
+    
+    # Get the root CLI app
+    app = ctx.find_root().command
+    
+    try:
+        if shell == 'bash':
+            from click.shell_completion import BashComplete
+            complete = BashComplete(app, {}, "mcli", "complete")
+            script = complete.source()
+            
+            # Install to bash completion directory
+            bash_completion_dir = Path.home() / ".bash_completion.d"
+            bash_completion_dir.mkdir(exist_ok=True)
+            completion_file = bash_completion_dir / "mcli"
+            completion_file.write_text(script)
+            
+            # Add sourcing to .bashrc if needed
+            bashrc = Path.home() / ".bashrc"
+            source_line = f"[ -f {completion_file} ] && source {completion_file}"
+            
+            if bashrc.exists():
+                content = bashrc.read_text()
+                if source_line not in content:
+                    with bashrc.open("a") as f:
+                        f.write(f"\n# MCLI completion\n{source_line}\n")
+                    click.echo("✅ Added completion sourcing to ~/.bashrc")
+                else:
+                    click.echo("ℹ️  Completion already configured in ~/.bashrc")
+            else:
+                click.echo(f"✅ Completion installed to {completion_file}")
+                click.echo("💡 Add this to your ~/.bashrc:")
+                click.echo(source_line)
+                
+        elif shell == 'zsh':
+            from click.shell_completion import ZshComplete  
+            complete = ZshComplete(app, {}, "mcli", "complete")
+            script = complete.source()
+            
+            # Install to zsh completion directory
+            zsh_completion_dir = Path.home() / ".config" / "zsh" / "completions"
+            zsh_completion_dir.mkdir(parents=True, exist_ok=True)
+            completion_file = zsh_completion_dir / "_mcli"
+            completion_file.write_text(script)
+            
+            # Add to fpath in .zshrc if needed
+            zshrc = Path.home() / ".zshrc"
+            fpath_line = f'fpath=("{zsh_completion_dir}" $fpath)'
+            
+            if zshrc.exists():
+                content = zshrc.read_text()
+                if str(zsh_completion_dir) not in content:
+                    with zshrc.open("a") as f:
+                        f.write(f"\n# MCLI completion\n{fpath_line}\nautoload -U compinit && compinit\n")
+                    click.echo("✅ Added completion to ~/.zshrc") 
+                else:
+                    click.echo("ℹ️  Completion already configured in ~/.zshrc")
+            else:
+                click.echo(f"✅ Completion installed to {completion_file}")
+                click.echo("💡 Add this to your ~/.zshrc:")
+                click.echo(f"{fpath_line}\nautoload -U compinit && compinit")
+                
+        elif shell == 'fish':
+            from click.shell_completion import FishComplete
+            complete = FishComplete(app, {}, "mcli", "complete")
+            script = complete.source()
+            
+            # Install to fish completion directory
+            fish_completion_dir = Path.home() / ".config" / "fish" / "completions"
+            fish_completion_dir.mkdir(parents=True, exist_ok=True)
+            completion_file = fish_completion_dir / "mcli.fish"
+            completion_file.write_text(script)
+            click.echo(f"✅ Completion installed to {completion_file}")
+        
+        click.echo(f"🎉 Shell completion for {shell} installed successfully!")
+        click.echo("💡 Restart your shell or source your profile to enable completions")
+        
+    except Exception as e:
+        click.echo(f"❌ Failed to install completion: {e}")
+
+
+@completion.command(name="status")
+def completion_status():
+    """Check current shell completion status"""
+    current_shell = os.environ.get('SHELL', 'unknown')
+    shell_name = Path(current_shell).name if current_shell != 'unknown' else 'unknown'
+    
+    click.echo(f"🐚 Current shell: {shell_name} ({current_shell})")
+    click.echo()
+    
+    # Check for existing completions
+    completions_found = []
+    
+    # Check bash
+    bash_completion = Path.home() / ".bash_completion.d" / "mcli"
+    if bash_completion.exists():
+        completions_found.append(f"✅ Bash completion: {bash_completion}")
+    else:
+        completions_found.append("❌ Bash completion: Not installed")
+    
+    # Check zsh
+    zsh_completion = Path.home() / ".config" / "zsh" / "completions" / "_mcli"  
+    if zsh_completion.exists():
+        completions_found.append(f"✅ Zsh completion: {zsh_completion}")
+    else:
+        completions_found.append("❌ Zsh completion: Not installed")
+    
+    # Check fish
+    fish_completion = Path.home() / ".config" / "fish" / "completions" / "mcli.fish"
+    if fish_completion.exists():
+        completions_found.append(f"✅ Fish completion: {fish_completion}")
+    else:
+        completions_found.append("❌ Fish completion: Not installed")
+    
+    for status in completions_found:
+        click.echo(status)
+    
+    click.echo()
+    click.echo("💡 To install completion for your shell:")
+    click.echo("   mcli completion install")
+    click.echo()
+    click.echo("💡 To generate completion script manually:")
+    click.echo(f"   mcli completion {shell_name}")
+
+
+# Export the CLI group for registration  
+cli = completion