omnimancer-cli 0.1.0__py3-none-any.whl

omnimancer/core/setup_wizard_ui.py

@@ -0,0 +1,317 @@
+"""
+UI components for the setup wizard.
+
+This module contains all UI and display methods for the setup wizard,
+including welcome screens, provider details, and completion messages.
+"""
+
+from typing import Any, Dict
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.text import Text
+
+
+class SetupWizardUI:
+    """UI components for the setup wizard."""
+
+    def __init__(self, console: Console, provider_info: Dict[str, Dict[str, Any]]):
+        """
+        Initialize the UI component.
+
+        Args:
+            console: Rich console instance
+            provider_info: Dictionary of provider information
+        """
+        self.console = console
+        self.provider_info = provider_info
+
+    def show_welcome(self) -> None:
+        """Show welcome message and setup introduction."""
+        welcome_text = Text()
+        welcome_text.append("Welcome to Omnimancer Setup!\n\n", style="bold blue")
+        welcome_text.append(
+            "This wizard will help you add AI providers to your configuration.\n"
+        )
+        welcome_text.append(
+            "You can run this anytime to add more providers without affecting existing ones.\n"
+        )
+
+        panel = Panel(
+            welcome_text,
+            title="🚀 Omnimancer Setup Wizard",
+            border_style="blue",
+            padding=(1, 2),
+        )
+
+        self.console.print(panel)
+        self.console.print()
+
+    def show_provider_details(self, provider_name: str) -> None:
+        """
+        Show detailed information about a provider.
+
+        Args:
+            provider_name: Name of the provider
+        """
+        info = self.provider_info[provider_name]
+
+        details = Text()
+        details.append(f"{info['name']}\n", style="bold blue")
+        details.append(f"{info['description']}\n\n", style="dim")
+        details.append("Strengths:\n", style="bold")
+        for strength in info["strengths"]:
+            details.append(f"  • {strength}\n", style="green")
+        details.append(
+            f"\nAvailable Models: {', '.join(info['models'][:3])}\n",
+            style="dim",
+        )
+
+        panel = Panel(
+            details,
+            title=f"📋 {info['name']} Details",
+            border_style="blue",
+            padding=(1, 2),
+        )
+
+        self.console.print(panel)
+
+    def show_completion(self, provider_name: str) -> None:
+        """
+        Show setup completion message with next steps.
+
+        Args:
+            provider_name: Name of the configured provider
+        """
+        info = self.provider_info[provider_name]
+
+        completion_text = Text()
+        completion_text.append("🎉 Setup Complete!\n\n", style="bold green")
+        completion_text.append(f"You've successfully configured {info['name']}.\n\n")
+        completion_text.append("Next Steps:\n", style="bold")
+        completion_text.append("  • Start chatting by typing your message\n")
+        completion_text.append("  • Use /help to see available commands\n")
+        completion_text.append("  • Use /providers to add more AI providers\n")
+        completion_text.append("  • Use /models to see available models\n\n")
+        completion_text.append("Happy chatting! 🚀", style="bold blue")
+
+        panel = Panel(
+            completion_text,
+            title="✨ Welcome to Omnimancer!",
+            border_style="green",
+            padding=(1, 2),
+        )
+
+        self.console.print(panel)
+
+    def show_troubleshooting_guidance(self, provider_name: str, error: str) -> None:
+        """
+        Show provider-specific troubleshooting guidance.
+
+        Args:
+            provider_name: Name of the provider
+            error: Error message
+        """
+        info = self.provider_info[provider_name]
+
+        guidance = Text()
+        guidance.append("Troubleshooting Guide:\n\n", style="bold yellow")
+
+        # Show error-specific guidance
+        if (
+            "api key" in error.lower()
+            or "authentication" in error.lower()
+            or "format" in error.lower()
+        ):
+            guidance.append("🔑 API Key Issues:\n", style="bold red")
+            guidance.append(f"  • Get your API key from: {info['api_key_url']}\n")
+            if info["api_key_prefix"]:
+                guidance.append(
+                    f"  • Ensure the key starts with '{info['api_key_prefix']}'\n"
+                )
+            guidance.append(
+                "  • Check that your account has sufficient credits/quota\n"
+            )
+            guidance.append("  • Verify the API key hasn't expired\n\n")
+
+        if (
+            "connection" in error.lower()
+            or "network" in error.lower()
+            or "timeout" in error.lower()
+        ):
+            guidance.append("🌐 Connection Issues:\n", style="bold blue")
+            guidance.append("  • Check your internet connection\n")
+            guidance.append("  • Verify firewall/proxy settings\n")
+            guidance.append("  • Try again in a few moments (temporary outage)\n")
+            guidance.append("  • Check provider status page for known issues\n\n")
+
+        if "model" in error.lower():
+            guidance.append("🤖 Model Issues:\n", style="bold green")
+            guidance.append("  • Verify the model name is spelled correctly\n")
+            guidance.append("  • Check if you have access to the requested model\n")
+            guidance.append("  • Try a different model from the same provider\n\n")
+
+        # Provider-specific guidance
+        self._add_provider_specific_guidance(guidance, provider_name, error)
+
+        # Show common issues for this provider
+        from .setup_wizard_core import SetupWizardCore
+
+        # Create a temporary instance just to access the common issues method
+        temp_core = SetupWizardCore(None, None)
+        common_issues = temp_core.get_common_setup_issues(provider_name)
+
+        if common_issues:
+            guidance.append("💡 Common Issues:\n", style="bold magenta")
+            for issue in common_issues[:3]:  # Show top 3 common issues
+                guidance.append(f"  • {issue['issue']}\n", style="dim")
+                guidance.append(f"    → {issue['solution']}\n")
+            guidance.append("\n")
+
+        # Add helpful links
+        guidance.append("📚 Helpful Links:\n", style="bold cyan")
+        guidance.append(f"  • API Documentation: {info['api_key_url']}\n")
+        if provider_name == "claude":
+            guidance.append("  • Status Page: https://status.anthropic.com/\n")
+            guidance.append("  • Support: https://support.anthropic.com/\n")
+        elif provider_name == "openai":
+            guidance.append("  • Status Page: https://status.openai.com/\n")
+            guidance.append("  • Support: https://help.openai.com/\n")
+        elif provider_name == "gemini":
+            guidance.append("  • Status Page: https://status.cloud.google.com/\n")
+            guidance.append("  • Support: https://support.google.com/\n")
+        elif provider_name == "ollama":
+            guidance.append("  • Documentation: https://ollama.ai/docs\n")
+            guidance.append("  • GitHub: https://github.com/ollama/ollama\n")
+
+        panel = Panel(
+            guidance,
+            title=f"🔧 {info['name']} Troubleshooting",
+            border_style="yellow",
+            padding=(1, 2),
+        )
+
+        self.console.print(panel)
+
+    def _add_provider_specific_guidance(
+        self, guidance: Text, provider_name: str, error: str
+    ) -> None:
+        """
+        Add provider-specific troubleshooting guidance.
+
+        Args:
+            guidance: Text object to append guidance to
+            provider_name: Name of the provider
+            error: Error message
+        """
+        if provider_name == "claude":
+            guidance.append("🎭 Claude-Specific:\n", style="bold")
+            guidance.append(
+                "  • Ensure you're using the correct API version (2023-06-01)\n"
+            )
+            guidance.append(
+                "  • Check message format (Claude uses specific message structure)\n"
+            )
+            guidance.append(
+                "  • Verify your account tier supports the selected model\n"
+            )
+            guidance.append("  • Try reducing max_tokens if getting context errors\n\n")
+
+        elif provider_name == "openai":
+            guidance.append("🤖 OpenAI-Specific:\n", style="bold")
+            guidance.append(
+                "  • Check if you have access to GPT-4 models (requires separate approval)\n"
+            )
+            guidance.append("  • Verify your organization ID if using team accounts\n")
+            guidance.append("  • Ensure billing is set up for API usage\n")
+            guidance.append("  • Try gpt-3.5-turbo if GPT-4 access is limited\n\n")
+
+        elif provider_name == "gemini":
+            guidance.append("🔮 Gemini-Specific:\n", style="bold")
+            guidance.append(
+                "  • Enable the Generative AI API in Google Cloud Console\n"
+            )
+            guidance.append("  • Check safety settings if requests are being blocked\n")
+            guidance.append(
+                "  • Verify your Google Cloud project has billing enabled\n"
+            )
+            guidance.append("  • Try gemini-1.5-flash for faster/cheaper responses\n\n")
+
+        elif provider_name == "perplexity":
+            guidance.append("🔍 Perplexity-Specific:\n", style="bold")
+            guidance.append(
+                "  • Ensure you have a Perplexity Pro subscription for API access\n"
+            )
+            guidance.append("  • Check your monthly API usage limits\n")
+            guidance.append(
+                "  • Verify search functionality is enabled for your account\n"
+            )
+            guidance.append(
+                "  • Try 'sonar' model if 'sonar-pro' is not accessible\n\n"
+            )
+
+        elif provider_name == "xai":
+            guidance.append("🚀 xAI-Specific:\n", style="bold")
+            guidance.append(
+                "  • Ensure you have access to the xAI API (currently in beta)\n"
+            )
+            guidance.append("  • Check your account status and API limits\n")
+            guidance.append("  • Verify you're using the correct endpoint URL\n")
+            guidance.append("  • Try 'grok-3-fast' for quicker responses\n\n")
+
+        elif provider_name == "mistral":
+            guidance.append("🌪️ Mistral-Specific:\n", style="bold")
+            guidance.append(
+                "  • Ensure you have a Mistral AI account with API access\n"
+            )
+            guidance.append("  • Check your usage quotas and billing status\n")
+            guidance.append("  • Verify the model name matches exactly\n")
+            guidance.append("  • Try 'mistral-small-3.1' for cost-effective usage\n\n")
+
+        elif provider_name == "cohere":
+            guidance.append("🧠 Cohere-Specific:\n", style="bold")
+            guidance.append("  • Ensure you have a Cohere account with API access\n")
+            guidance.append("  • Check your trial credits or subscription status\n")
+            guidance.append("  • Verify the model supports your use case\n")
+            guidance.append("  • Try 'command-light' for faster responses\n\n")
+
+        elif provider_name == "ollama":
+            guidance.append("🏠 Ollama-Specific:\n", style="bold")
+            guidance.append("  • Start Ollama server: 'ollama serve'\n")
+            guidance.append("  • Install required model: 'ollama pull <model-name>'\n")
+            guidance.append("  • Check server URL (default: http://localhost:11434)\n")
+            guidance.append("  • Ensure sufficient RAM for the model size\n")
+            guidance.append("  • List available models: 'ollama list'\n")
+            guidance.append("  • Check Ollama logs for detailed error messages\n\n")
+
+    def show_provider_help(self, provider_name: str) -> None:
+        """
+        Show provider-specific setup help.
+
+        Args:
+            provider_name: Name of the provider
+        """
+        if provider_name not in self.provider_info:
+            self.console.print(f"[red]Unknown provider: {provider_name}[/red]")
+            return
+
+        info = self.provider_info[provider_name]
+
+        help_text = Text()
+        help_text.append(f"{info['name']} Setup Guide\n\n", style="bold blue")
+        help_text.append(f"{info['description']}\n\n")
+        help_text.append("Strengths:\n", style="bold")
+        for strength in info["strengths"]:
+            help_text.append(f"  • {strength}\n", style="green")
+        help_text.append(f"\nAPI Key: {info['api_key_url']}\n", style="bold")
+        help_text.append(f"Setup Notes: {info['setup_notes']}\n")
+        help_text.append(f"Available Models: {', '.join(info['models'])}\n")
+
+        panel = Panel(
+            help_text,
+            title=f"📚 {info['name']} Help",
+            border_style="blue",
+            padding=(1, 2),
+        )
+
+        self.console.print(panel)

omnimancer/core/setup_wizard_validation.py

@@ -0,0 +1,371 @@
+"""
+Validation methods for the setup wizard.
+
+This module contains all validation and testing methods for provider
+configurations, including API key validation and credential testing.
+"""
+
+import asyncio
+from typing import Any, Dict, Optional
+
+from rich.console import Console
+from rich.progress import Progress, SpinnerColumn, TextColumn
+from rich.prompt import Confirm
+
+from .models import ProviderConfig
+from .setup_wizard_ui import SetupWizardUI
+
+
+class SetupWizardValidation:
+    """Validation methods for the setup wizard."""
+
+    def __init__(
+        self,
+        console: Console,
+        provider_info: Dict[str, Dict[str, Any]],
+        provider_factory,
+        cancellation_handler,
+        signal_handler,
+    ):
+        """
+        Initialize the validation component.
+
+        Args:
+            console: Rich console instance
+            provider_info: Dictionary of provider information
+            provider_factory: Factory for creating provider instances
+            cancellation_handler: Handler for cancellation support
+            signal_handler: Handler for signal management
+        """
+        self.console = console
+        self.provider_info = provider_info
+        self.provider_factory = provider_factory
+        self.cancellation_handler = cancellation_handler
+        self.signal_handler = signal_handler
+        self.ui = SetupWizardUI(console, provider_info)
+
+    async def test_configuration(
+        self, provider_name: str, provider_config: ProviderConfig
+    ) -> bool:
+        """
+        Test the configuration and provide feedback.
+
+        Args:
+            provider_name: Name of the provider
+            provider_config: Provider configuration to test
+
+        Returns:
+            True if configuration is valid, False otherwise
+        """
+        self.console.print(
+            f"\n[bold]Testing {self.provider_info[provider_name]['name']} configuration...[/bold]"
+        )
+
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            console=self.console,
+        ) as progress:
+            # Step 1: Validate API key format
+            task = progress.add_task("Validating API key format...", total=None)
+
+            if not self._validate_api_key_format(
+                provider_name, provider_config.api_key
+            ):
+                progress.update(task, description="❌ Invalid API key format!")
+                await asyncio.sleep(0.5)
+                self.console.print("[red]❌ API key format validation failed![/red]")
+                self.ui.show_troubleshooting_guidance(
+                    provider_name, "Invalid API key format"
+                )
+                return Confirm.ask("Continue with this configuration anyway?")
+
+            progress.update(task, description="✅ API key format valid!")
+            await asyncio.sleep(0.5)
+
+            # Step 2: Test API connection
+            progress.update(task, description="Testing API connection...")
+
+            try:
+                # Create provider instance for testing
+                provider = self.provider_factory.create_provider(
+                    provider_name, provider_config
+                )
+
+                # Test credentials
+                is_valid = await self._validate_provider_credentials(provider)
+
+                if is_valid:
+                    progress.update(task, description="✅ API connection successful!")
+                    await asyncio.sleep(0.5)
+
+                    # Step 3: Test model availability
+                    progress.update(task, description="Checking model availability...")
+
+                    # Special handling for Bedrock to test model access
+                    if provider_name == "bedrock" and hasattr(
+                        provider, "validate_model_access"
+                    ):
+                        model_test = await provider.validate_model_access()
+
+                        if model_test["success"]:
+                            progress.update(task, description="✅ Model accessible!")
+                            await asyncio.sleep(0.5)
+                            self.console.print(
+                                "[green]✅ All configuration tests passed![/green]"
+                            )
+                            return True
+                        else:
+                            progress.update(task, description="⚠️  Model access issue!")
+                            await asyncio.sleep(0.5)
+
+                            # Show detailed model access warning
+                            self.console.print(
+                                f"[yellow]⚠️  Model Access Warning: {model_test['message']}[/yellow]"
+                            )
+                            if "suggestion" in model_test:
+                                self.console.print(
+                                    f"[dim]💡 Suggestion: {model_test['suggestion']}[/dim]"
+                                )
+
+                            self.console.print(
+                                "\n[yellow]Note: Configuration will be saved, but you may need to:[/yellow]"
+                            )
+                            self.console.print(
+                                "  [yellow]• Request model access in AWS Console[/yellow]"
+                            )
+                            self.console.print(
+                                "  [yellow]• Check account permissions[/yellow]"
+                            )
+                            self.console.print(
+                                "  [yellow]• Try a different model[/yellow]"
+                            )
+
+                            return Confirm.ask(
+                                "Continue with this configuration?",
+                                default=True,
+                            )
+                    else:
+                        # Standard model availability check for other providers
+                        model_available = await self._check_model_availability(
+                            provider, provider_config.model
+                        )
+
+                        if model_available:
+                            progress.update(task, description="✅ Model available!")
+                            await asyncio.sleep(0.5)
+                            self.console.print(
+                                "[green]✅ All configuration tests passed![/green]"
+                            )
+                            return True
+                        else:
+                            progress.update(
+                                task,
+                                description="⚠️  Model may not be available!",
+                            )
+                            await asyncio.sleep(0.5)
+                            self.console.print(
+                                "[yellow]⚠️  Model availability could not be confirmed[/yellow]"
+                            )
+                            return Confirm.ask("Continue with this configuration?")
+                else:
+                    progress.update(task, description="❌ API authentication failed!")
+                    await asyncio.sleep(0.5)
+                    self.console.print("[red]❌ API authentication failed![/red]")
+                    self.ui.show_troubleshooting_guidance(
+                        provider_name, "Authentication failed"
+                    )
+                    return Confirm.ask("Continue with this configuration anyway?")
+
+            except Exception as e:
+                progress.update(task, description="❌ Connection test failed!")
+                await asyncio.sleep(0.5)
+
+                self.console.print(f"[red]❌ Configuration test failed: {e}[/red]")
+
+                # Provide troubleshooting guidance
+                self.ui.show_troubleshooting_guidance(provider_name, str(e))
+
+                return Confirm.ask("Continue with this configuration anyway?")
+
+    def _validate_api_key_format(
+        self, provider_name: str, api_key: Optional[str]
+    ) -> bool:
+        """
+        Validate API key format for a specific provider.
+
+        Args:
+            provider_name: Name of the provider
+            api_key: API key to validate
+
+        Returns:
+            True if format is valid, False otherwise
+        """
+        if provider_name in ["ollama", "claude-code"]:
+            return True  # Ollama and Claude Code don't require API key
+
+        if not api_key:
+            return False
+
+        info = self.provider_info.get(provider_name, {})
+        prefix = info.get("api_key_prefix", "")
+
+        # Basic format validation
+        if prefix and not api_key.startswith(prefix):
+            return False
+
+        # Provider-specific validation
+        if provider_name == "claude":
+            return api_key.startswith("sk-ant-") and len(api_key) > 20
+        elif provider_name == "openai":
+            return api_key.startswith("sk-") and len(api_key) > 20
+        elif provider_name == "gemini":
+            return api_key.startswith("AIza") and len(api_key) > 20
+        elif provider_name == "perplexity":
+            return api_key.startswith("pplx-") and len(api_key) > 20
+        elif provider_name == "xai":
+            return api_key.startswith("xai-") and len(api_key) > 20
+        elif provider_name == "bedrock":
+            return api_key.startswith("ABSKQmVkcm9ja0FQSUtleS1") and len(api_key) > 50
+        elif provider_name == "mistral":
+            return len(api_key) > 20  # Mistral keys don't have consistent prefix
+        elif provider_name == "cohere":
+            return len(api_key) > 20  # Cohere keys don't have consistent prefix
+
+        return len(api_key) > 10  # Generic validation
+
+    async def _validate_provider_credentials(self, provider) -> bool:
+        """
+        Validate provider credentials by making a test API call.
+
+        Args:
+            provider: Provider instance to test
+
+        Returns:
+            True if credentials are valid, False otherwise
+        """
+        try:
+            # Use the provider's validate_credentials method with cancellation support
+            async def credential_validation():
+                return await provider.validate_credentials()
+
+            return await self.cancellation_handler.start_cancellable_operation(
+                operation=credential_validation,
+                status_message="Testing API credentials",
+                cancellation_message="Credential validation cancelled",
+                signal_handler=self.signal_handler,
+            )
+        except asyncio.CancelledError:
+            # Operation was cancelled by user
+            return False
+        except Exception:
+            # Log the error but don't raise it
+            return False
+
+    async def _check_model_availability(self, provider, model_name: str) -> bool:
+        """
+        Check if a specific model is available for the provider.
+
+        Args:
+            provider: Provider instance
+            model_name: Name of the model to check
+
+        Returns:
+            True if model is available, False otherwise
+        """
+        try:
+            # Try to get available models with cancellation support
+            async def model_availability_check():
+                available_models = provider.get_available_models()
+                model_names = [model.name for model in available_models]
+                return model_name in model_names
+
+            return await self.cancellation_handler.start_cancellable_operation(
+                operation=model_availability_check,
+                status_message="Checking model availability",
+                cancellation_message="Model availability check cancelled",
+                signal_handler=self.signal_handler,
+            )
+        except asyncio.CancelledError:
+            # Operation was cancelled by user
+            return True  # Assume available to allow setup to continue
+        except Exception:
+            # If we can't check model availability, assume it's available
+            # This prevents blocking setup for providers that don't support model listing
+            return True
+
+    async def validate_existing_configuration(
+        self, provider_name: str, config_manager
+    ) -> Dict[str, Any]:
+        """
+        Validate an existing provider configuration.
+
+        Args:
+            provider_name: Name of the provider to validate
+            config_manager: Configuration manager instance
+
+        Returns:
+            Dictionary with validation results
+        """
+        result = {
+            "provider": provider_name,
+            "valid": False,
+            "errors": [],
+            "warnings": [],
+            "suggestions": [],
+        }
+
+        try:
+            # Get existing configuration
+            provider_config = config_manager.get_provider_config(provider_name)
+            if not provider_config:
+                result["errors"].append(
+                    f"No configuration found for provider '{provider_name}'"
+                )
+                return result
+
+            # Validate API key format
+            if not self._validate_api_key_format(
+                provider_name, provider_config.api_key
+            ):
+                result["errors"].append("Invalid API key format")
+                result["suggestions"].append(
+                    f"Check API key format for {self.provider_info[provider_name]['name']}"
+                )
+
+            # Test credentials
+            try:
+                provider = self.provider_factory.create_provider(
+                    provider_name, provider_config.model_dump(mode="json")
+                )
+
+                credentials_valid = await self._validate_provider_credentials(provider)
+                if not credentials_valid:
+                    result["errors"].append("API credentials validation failed")
+                    result["suggestions"].append("Verify API key and account status")
+                else:
+                    # Check model availability
+                    model_available = await self._check_model_availability(
+                        provider, provider_config.model
+                    )
+                    if not model_available:
+                        result["warnings"].append(
+                            f"Model '{provider_config.model}' may not be available"
+                        )
+                        result["suggestions"].append(
+                            "Consider updating to a newer model"
+                        )
+
+            except Exception as e:
+                result["errors"].append(f"Provider initialization failed: {str(e)}")
+                result["suggestions"].append(
+                    "Check provider configuration and network connectivity"
+                )
+
+            # Set overall validity
+            result["valid"] = len(result["errors"]) == 0
+
+        except Exception as e:
+            result["errors"].append(f"Configuration validation failed: {str(e)}")
+
+        return result