llmshell-cli 0.0.1__py3-none-any.whl

gpt_shell/llm_manager.py

@@ -0,0 +1,225 @@
+"""LLM backend manager with fallback support."""
+
+from typing import Optional, List, Tuple
+from pathlib import Path
+
+from gpt_shell.config import Config
+from gpt_shell.llm_client import (
+    LLMClient,
+    GPT4AllClient,
+    OpenAIClient,
+    OllamaClient,
+    CustomClient,
+)
+
+
+class LLMManager:
+    """Manages LLM backends and provides fallback logic."""
+
+    def __init__(self, config: Config):
+        """
+        Initialize LLM manager.
+
+        Args:
+            config: Configuration object
+        """
+        self.config = config
+        self.current_client: Optional[LLMClient] = None
+        self.backend_name: Optional[str] = None
+
+    def get_client(self, backend: Optional[str] = None) -> LLMClient:
+        """
+        Get LLM client for specified backend.
+
+        Args:
+            backend: Backend name. If None, uses config default
+
+        Returns:
+            LLM client instance
+
+        Raises:
+            RuntimeError: If no backends are available
+        """
+        if backend is None:
+            backend = self.config.get("llm_backend", "gpt4all")
+
+        # Try requested backend first
+        client = self._create_client(backend)
+        if client and client.is_available():
+            self.current_client = client
+            self.backend_name = backend
+            return client
+
+        # If requested backend not available, try fallback order
+        fallback_order = self._get_fallback_order(backend)
+        for fallback_backend in fallback_order:
+            client = self._create_client(fallback_backend)
+            if client and client.is_available():
+                self.current_client = client
+                self.backend_name = fallback_backend
+                return client
+
+        # No backends available
+        raise RuntimeError(
+            "No LLM backends available. Please configure at least one backend:\n"
+            "  - GPT4All: run 'llmshell model install' to download model\n"
+            "  - OpenAI: set API key with 'llmshell config set backends.openai.api_key YOUR_KEY'\n"
+            "  - Ollama: ensure Ollama is running locally\n"
+            "  - Custom: configure custom API endpoint"
+        )
+
+    def _create_client(self, backend: str) -> Optional[LLMClient]:
+        """
+        Create client for specific backend.
+
+        Args:
+            backend: Backend name
+
+        Returns:
+            LLM client instance or None if configuration invalid
+        """
+        backend_config = self.config.get_backend_config(backend)
+
+        try:
+            if backend == "gpt4all":
+                model_name = backend_config.get("model", "mistral-7b-instruct-v0.2.Q4_0.gguf")
+                model_path = backend_config.get("model_path")
+                
+                # If no explicit path, check models directory
+                if not model_path:
+                    models_dir = self.config.get_models_dir()
+                    potential_path = models_dir / model_name
+                    if potential_path.exists():
+                        model_path = str(models_dir)
+                
+                return GPT4AllClient(model_name=model_name, model_path=model_path)
+
+            elif backend == "openai":
+                api_key = backend_config.get("api_key")
+                if not api_key:
+                    return None
+                model = backend_config.get("model", "gpt-4-turbo")
+                base_url = backend_config.get("base_url")
+                return OpenAIClient(api_key=api_key, model=model, base_url=base_url)
+
+            elif backend == "ollama":
+                model = backend_config.get("model", "llama3")
+                api_url = backend_config.get("api_url", "http://localhost:11434")
+                return OllamaClient(model=model, api_url=api_url)
+
+            elif backend == "custom":
+                api_url = backend_config.get("api_url")
+                if not api_url:
+                    return None
+                headers = backend_config.get("headers", {})
+                return CustomClient(api_url=api_url, headers=headers)
+
+            else:
+                return None
+
+        except Exception:
+            return None
+
+    def _get_fallback_order(self, preferred: str) -> List[str]:
+        """
+        Get fallback order for backends.
+
+        Args:
+            preferred: Preferred backend (to exclude from fallbacks)
+
+        Returns:
+            List of backend names in fallback order
+        """
+        # Default fallback order: gpt4all -> ollama -> openai -> custom
+        all_backends = ["gpt4all", "ollama", "openai", "custom"]
+        
+        # Remove preferred backend from fallbacks
+        fallbacks = [b for b in all_backends if b != preferred]
+        
+        return fallbacks
+
+    def check_backends(self) -> List[Tuple[str, bool, str]]:
+        """
+        Check status of all configured backends.
+
+        Returns:
+            List of tuples (backend_name, is_available, status_message)
+        """
+        results = []
+        
+        for backend in self.config.list_backends():
+            client = self._create_client(backend)
+            if client is None:
+                results.append((backend, False, "Not configured"))
+            elif client.is_available():
+                results.append((backend, True, "Available"))
+            else:
+                error_msg = getattr(client, "error", "Not available")
+                results.append((backend, False, error_msg))
+        
+        return results
+
+    def generate_command(self, prompt: str, explain: bool = False, backend: Optional[str] = None) -> str:
+        """
+        Generate command using LLM.
+
+        Args:
+            prompt: Natural language prompt
+            explain: Whether to include explanation
+            backend: Specific backend to use (optional)
+
+        Returns:
+            Generated command
+        """
+        client = self.get_client(backend)
+        return client.generate_command(prompt, explain)
+
+    def get_current_backend(self) -> Optional[str]:
+        """
+        Get name of currently active backend.
+
+        Returns:
+            Backend name or None
+        """
+        return self.backend_name
+
+    def download_gpt4all_model(self, model_name: Optional[str] = None) -> Path:
+        """
+        Download GPT4All model.
+
+        Args:
+            model_name: Model name to download. If None, uses config default
+
+        Returns:
+            Path to downloaded model
+
+        Raises:
+            RuntimeError: If download fails
+        """
+        if model_name is None:
+            model_name = self.config.get("backends.gpt4all.model", "mistral-7b-instruct-v0.2.Q4_0.gguf")
+
+        models_dir = self.config.get_models_dir()
+
+        try:
+            from gpt4all import GPT4All
+            
+            # GPT4All will download to its default location, then we can use it
+            print(f"Downloading {model_name}...")
+            print("This may take a few minutes depending on your internet connection.")
+            
+            model = GPT4All(
+                model_name=model_name,
+                model_path=str(models_dir),
+                allow_download=True,
+            )
+            
+            model_path = models_dir / model_name
+            
+            # Update config with model path
+            self.config.set("backends.gpt4all.model_path", str(models_dir))
+            
+            return model_path
+
+        except Exception as e:
+            raise RuntimeError(f"Failed to download model: {e}")

gpt_shell/main.py

@@ -0,0 +1,327 @@
+"""Main CLI interface for llmshell using Typer."""
+
+import typer
+from typing import Optional
+from pathlib import Path
+
+from gpt_shell import __version__
+from gpt_shell.config import Config
+from gpt_shell.llm_manager import LLMManager
+from gpt_shell.utils import (
+    print_success,
+    print_error,
+    print_warning,
+    print_info,
+    print_command,
+    print_config_table,
+    print_backend_status,
+    confirm_execution,
+    execute_command,
+    print_execution_result,
+    is_dangerous_command,
+    print_danger_warning,
+    console,
+)
+
+app = typer.Typer(
+    name="llmshell",
+    help="Convert natural language to shell commands using LLMs",
+    add_completion=False,
+)
+
+
+def get_manager() -> LLMManager:
+    """Get LLM manager instance."""
+    config = Config()
+    return LLMManager(config)
+
+
+@app.command(name="run")
+def run_command(
+    prompt: str = typer.Argument(..., help="Natural language description of command"),
+    execute: bool = typer.Option(False, "--execute", "-e", help="Execute command without confirmation"),
+    dry_run: bool = typer.Option(False, "--dry-run", "-d", help="Show command but don't execute"),
+    explain: bool = typer.Option(False, "--explain", "-x", help="Include explanation with command"),
+    backend: Optional[str] = typer.Option(None, "--backend", "-b", help="Specific backend to use"),
+):
+    """Generate and optionally execute shell commands from natural language."""
+    try:
+        manager = get_manager()
+        
+        # Generate command
+        with console.status("[cyan]Thinking...", spinner="dots"):
+            command = manager.generate_command(prompt, explain=explain, backend=backend)
+        
+        # Display generated command
+        if explain:
+            console.print("\n[bold cyan]Response:[/bold cyan]")
+            console.print(command)
+        else:
+            print_command(command)
+        
+        # Show which backend was used
+        current_backend = manager.get_current_backend()
+        if current_backend:
+            print_info(f"Using backend: {current_backend}")
+        
+        # Check for dangerous commands
+        is_dangerous = is_dangerous_command(command)
+        if is_dangerous:
+            print_danger_warning(command)
+        
+        # Handle execution
+        if not dry_run and not explain:
+            should_execute = execute
+            
+            # For dangerous commands, ALWAYS ask for confirmation
+            if is_dangerous:
+                should_execute = False  # Force confirmation for dangerous commands
+                print_warning("Dangerous command detected - confirmation required regardless of --execute flag")
+            
+            if not should_execute:
+                # Ask for confirmation
+                config = Config()
+                if not config.get("execution.confirmation_required", True) and not is_dangerous:
+                    should_execute = True
+                else:
+                    should_execute = confirm_execution(command)
+            
+            if should_execute:
+                console.print()
+                returncode, stdout, stderr = execute_command(command)
+                print_execution_result(returncode, stdout, stderr)
+        elif dry_run:
+            print_info("Dry run mode - command not executed")
+    
+    except RuntimeError as e:
+        print_error(str(e))
+        raise typer.Exit(code=1)
+    except KeyboardInterrupt:
+        print_warning("Interrupted by user")
+        raise typer.Exit(code=130)
+    except Exception as e:
+        print_error(f"Unexpected error: {e}")
+        raise typer.Exit(code=1)
+
+
+@app.command(name="config")
+def config_command(
+    action: Optional[str] = typer.Argument(None, help="Action: show, set, get"),
+    key: Optional[str] = typer.Argument(None, help="Configuration key"),
+    value: Optional[str] = typer.Argument(None, help="Configuration value"),
+):
+    """Manage llmshell configuration."""
+    config = Config()
+    
+    if action is None or action == "show":
+        # Show current configuration
+        print_config_table(config.to_dict())
+        console.print(f"\n[dim]Config file: {config.config_path}[/dim]")
+    
+    elif action == "set":
+        if not key or value is None:
+            print_error("Usage: llmshell config set KEY VALUE")
+            raise typer.Exit(code=1)
+        
+        # Set configuration value
+        try:
+            # Try to parse as boolean or number
+            if value.lower() in ["true", "false"]:
+                value = value.lower() == "true"
+            elif value.isdigit():
+                value = int(value)
+            elif value.replace(".", "", 1).isdigit():
+                value = float(value)
+            
+            config.set(key, value)
+            print_success(f"Set {key} = {value}")
+            print_info(f"Config saved to {config.config_path}")
+        except Exception as e:
+            print_error(f"Failed to set config: {e}")
+            raise typer.Exit(code=1)
+    
+    elif action == "get":
+        if not key:
+            print_error("Usage: llmshell config get KEY")
+            raise typer.Exit(code=1)
+        
+        # Get configuration value
+        value = config.get(key)
+        if value is not None:
+            console.print(f"[cyan]{key}[/cyan] = {value}")
+        else:
+            print_warning(f"Key '{key}' not found")
+            raise typer.Exit(code=1)
+    
+    else:
+        print_error(f"Unknown action: {action}")
+        print_info("Available actions: show, set, get")
+        raise typer.Exit(code=1)
+
+
+@app.command(name="model")
+def model_command(
+    action: str = typer.Argument(..., help="Action: install, list, show-available"),
+    model_name: Optional[str] = typer.Option(None, "--name", "-n", help="Model name to install"),
+):
+    """Manage GPT4All models."""
+    if action == "install":
+        try:
+            manager = get_manager()
+            
+            if model_name:
+                print_info(f"Installing model: {model_name}")
+            else:
+                config = Config()
+                model_name = config.get("backends.gpt4all.model", "mistral-7b-instruct-v0.2.Q4_0.gguf")
+                print_info(f"Installing default model: {model_name}")
+            
+            model_path = manager.download_gpt4all_model(model_name)
+            print_success(f"Model installed successfully: {model_path}")
+            
+        except Exception as e:
+            print_error(f"Failed to install model: {e}")
+            raise typer.Exit(code=1)
+    
+    elif action == "list":
+        config = Config()
+        models_dir = config.get_models_dir()
+        
+        if models_dir.exists():
+            models = list(models_dir.glob("*.gguf"))
+            if models:
+                console.print("\n[bold cyan]Installed Models:[/bold cyan]")
+                for model in models:
+                    console.print(f"  • {model.name}")
+            else:
+                print_warning("No models installed")
+                print_info("Run 'llmshell model install' to download a model")
+        else:
+            print_warning("Models directory not found")
+            print_info("Run 'llmshell model install' to download a model")
+    
+    elif action == "show-available":
+        # List popular available models from GPT4All
+        console.print("\n[bold cyan]Popular GPT4All Models:[/bold cyan]\n")
+        
+        popular_models = [
+            ("Meta-Llama-3-8B-Instruct.Q4_0.gguf", "4.7GB", "Meta's Llama 3 8B - Fast, accurate, recommended"),
+            ("Mistral-7B-Instruct-v0.2.Q4_0.gguf", "4.1GB", "Mistral AI's 7B model - Good for code"),
+            ("Phi-3-mini-4k-instruct.Q4_0.gguf", "2.3GB", "Microsoft's compact model - Very fast"),
+            ("orca-mini-3b-gguf2-q4_0.gguf", "1.9GB", "Smaller model - Low resource usage"),
+            ("gpt4all-falcon-newbpe-q4_0.gguf", "3.9GB", "Falcon 7B - Good general purpose"),
+        ]
+        
+        from rich.table import Table
+        table = Table(show_header=True, header_style="bold cyan")
+        table.add_column("Model Name", style="yellow", no_wrap=False)
+        table.add_column("Size", style="green", justify="right")
+        table.add_column("Description", style="white")
+        
+        for name, size, desc in popular_models:
+            table.add_row(name, size, desc)
+        
+        console.print(table)
+        console.print("\n[bold]To install a model:[/bold]")
+        console.print("  [cyan]llmshell model install --name MODEL_NAME[/cyan]")
+        console.print("\n[bold]Example:[/bold]")
+        console.print("  [cyan]llmshell model install --name Meta-Llama-3-8B-Instruct.Q4_0.gguf[/cyan]")
+        console.print("\n[dim]Note: Models are downloaded from GPT4All's official repository[/dim]")
+    
+    else:
+        print_error(f"Unknown action: {action}")
+        print_info("Available actions: install, list, show-available")
+        raise typer.Exit(code=1)
+
+
+@app.command(name="doctor")
+def doctor_command():
+    """Diagnose llmshell setup and check backend availability."""
+    console.print("[bold cyan]Running diagnostics...[/bold cyan]\n")
+    
+    # Check config
+    config = Config()
+    console.print(f"[green]✓[/green] Config file: {config.config_path}")
+    
+    if not config.config_path.exists():
+        print_warning("Config file does not exist (will be created on first run)")
+    
+    # Check models directory
+    models_dir = config.get_models_dir()
+    console.print(f"[green]✓[/green] Models directory: {models_dir}")
+    
+    # Check for GPT4All models
+    if models_dir.exists():
+        models = list(models_dir.glob("*.gguf"))
+        if models:
+            console.print(f"[green]✓[/green] Found {len(models)} GPT4All model(s)")
+        else:
+            print_warning("No GPT4All models found")
+            print_info("Run 'llmshell model install' to download a model")
+    
+    console.print()
+    
+    # Check backends
+    manager = LLMManager(config)
+    backends = manager.check_backends()
+    print_backend_status(backends)
+    
+    console.print()
+    
+    # Check if at least one backend is available
+    available = any(available for _, available, _ in backends)
+    if available:
+        print_success("At least one backend is available")
+    else:
+        print_error("No backends are available")
+        console.print("\n[bold]Recommendations:[/bold]")
+        console.print("  1. Install GPT4All model: [cyan]llmshell model install[/cyan]")
+        console.print("  2. Configure OpenAI: [cyan]llmshell config set backends.openai.api_key YOUR_KEY[/cyan]")
+        console.print("  3. Start Ollama server: [cyan]ollama serve[/cyan]")
+    
+    # Show current backend
+    current_backend = config.get("llm_backend")
+    console.print(f"\n[bold]Current Backend:[/bold] {current_backend}")
+    
+    # Test current backend
+    console.print("\n[bold cyan]Testing current backend...[/bold cyan]")
+    try:
+        with console.status("[cyan]Generating test command...", spinner="dots"):
+            test_result = manager.generate_command("list files", backend=current_backend)
+        print_success(f"Backend test successful")
+        print_command(test_result, "Test Output")
+    except Exception as e:
+        print_error(f"Backend test failed: {e}")
+
+
+@app.command(name="version")
+def version_command():
+    """Show version information."""
+    console.print(f"[bold cyan]llmshell[/bold cyan] version [green]{__version__}[/green]")
+
+
+@app.callback(invoke_without_command=True)
+def main(
+    ctx: typer.Context,
+    version: bool = typer.Option(False, "--version", "-v", help="Show version"),
+):
+    """
+    llmshell - Convert natural language to shell commands using LLMs.
+    
+    Examples:
+      llmshell run "list all docker containers"
+      llmshell run "find python files" --execute
+      llmshell config show
+      llmshell model install
+      llmshell doctor
+    """
+    if version:
+        console.print(f"[bold cyan]llmshell[/bold cyan] version [green]{__version__}[/green]")
+        raise typer.Exit()
+    
+    if ctx.invoked_subcommand is None:
+        console.print(ctx.get_help())
+
+
+if __name__ == "__main__":
+    app()

gpt_shell/py.typed

@@ -0,0 +1 @@
+# Marker file for PEP 561