arionxiv 1.0.32__py3-none-any.whl

arionxiv/cli/utils/api_config.py

@@ -0,0 +1,505 @@
+"""
+API Key Configuration Manager for ArionXiv
+Handles secure storage and retrieval of API keys (Gemini, HuggingFace, etc.)
+"""
+
+import os
+import json
+from pathlib import Path
+from typing import Dict, Any, Optional
+from rich.console import Console
+from rich.panel import Panel
+from rich.prompt import Prompt, Confirm
+from rich.table import Table
+
+console = Console()
+
+# Import animation utility
+try:
+    from ..utils.animations import left_to_right_reveal
+    ANIMATIONS_AVAILABLE = True
+except ImportError:
+    ANIMATIONS_AVAILABLE = False
+    def left_to_right_reveal(console, text, style="", duration=1.0):
+        console.print(text, style=style)
+
+
+# Step-by-step instructions for getting API keys
+API_KEY_INSTRUCTIONS = {
+    "gemini": {
+        "title": "How to Get Your Google Gemini API Key (FREE)",
+        "steps": [
+            "1. Go to: https://aistudio.google.com/app/apikey",
+            "2. Sign in with your Google account",
+            "3. Click 'Create API Key'",
+            "4. Select a Google Cloud project (or create a new one)",
+            "5. Copy your API key",
+            "",
+            "Note: Gemini has a generous FREE tier - no credit card needed!"
+        ]
+    },
+    "huggingface": {
+        "title": "How to Get Your HuggingFace API Token (FREE)",
+        "steps": [
+            "1. Go to: https://huggingface.co/settings/tokens",
+            "2. Create a free account or sign in",
+            "3. Click 'New token'",
+            "4. Give it a name (e.g., 'ArionXiv')",
+            "5. Select 'Read' access (that's all we need)",
+            "6. Click 'Generate token' and copy it",
+            "",
+            "Note: HuggingFace is FREE for most models!"
+        ]
+    },
+    "groq": {
+        "title": "How to Get Your Groq API Key (FREE & FAST)",
+        "steps": [
+            "1. Go to: https://console.groq.com/keys",
+            "2. Create a free account or sign in",
+            "3. Click 'Create API Key'",
+            "4. Give it a name (e.g., 'ArionXiv')",
+            "5. Copy your API key",
+            "",
+            "Note: Groq is FREE and incredibly fast!",
+            "      Optional - use for local LLM inference."
+        ]
+    },
+    "openrouter": {
+        "title": "How to Get Your OpenRouter API Key (FREE models available)",
+        "steps": [
+            "1. Go to: https://openrouter.ai/keys",
+            "2. Create a free account or sign in with Google/GitHub",
+            "3. Click 'Create Key'",
+            "4. Copy your API key (starts with sk-or-)",
+            "",
+            "Note: OpenRouter provides FREE access to many LLMs!",
+            "      Recommended for paper chat feature.",
+            "      Free models: Llama 3.3, Gemma, Qwen, and more."
+        ]
+    }
+}
+
+
+class APIConfigManager:
+    """
+    Manages API key configuration with secure local storage.
+    
+    Keys are stored in ~/.arionxiv/api_keys.json
+    Environment variables take precedence over stored keys.
+    """
+    
+    # Supported API providers
+    PROVIDERS = {
+        "gemini": {
+            "name": "Google Gemini",
+            "env_var": "GEMINI_API_KEY",
+            "description": "Used for embeddings and AI features (FREE tier available)",
+            "url": "https://aistudio.google.com/app/apikey",
+            "required": False
+        },
+        "huggingface": {
+            "name": "HuggingFace",
+            "env_var": "HF_API_KEY",
+            "description": "Used for model downloads and inference API",
+            "url": "https://huggingface.co/settings/tokens",
+            "required": False
+        },
+        "groq": {
+            "name": "Groq",
+            "env_var": "GROQ_API_KEY",
+            "description": "Optional - for local LLM inference (hosted API is used by default)",
+            "url": "https://console.groq.com/keys",
+            "required": False
+        },
+        "openrouter": {
+            "name": "OpenRouter",
+            "env_var": "OPENROUTER_API_KEY",
+            "description": "For paper chat - access FREE LLMs (Llama, Gemma, Qwen)",
+            "url": "https://openrouter.ai/keys",
+            "required": False
+        },
+        "openrouter_model": {
+            "name": "OpenRouter Model",
+            "env_var": "OPENROUTER_MODEL",
+            "description": "Model to use with OpenRouter (e.g., openai/gpt-4o-mini, meta-llama/llama-3.3-70b-instruct:free)",
+            "url": "https://openrouter.ai/models",
+            "required": False
+        }
+    }
+    
+    def __init__(self):
+        self.config_dir = Path.home() / ".arionxiv"
+        self.api_keys_file = self.config_dir / "api_keys.json"
+        self._keys: Dict[str, str] = {}
+        self._loaded = False
+        
+        # Ensure config directory exists
+        self.config_dir.mkdir(exist_ok=True)
+    
+    def _load_keys(self) -> Dict[str, str]:
+        """Load API keys from file"""
+        if self._loaded:
+            return self._keys
+        
+        try:
+            if self.api_keys_file.exists():
+                with open(self.api_keys_file, 'r') as f:
+                    self._keys = json.load(f)
+            else:
+                self._keys = {}
+        except Exception:
+            self._keys = {}
+        
+        self._loaded = True
+        return self._keys
+    
+    def _save_keys(self) -> bool:
+        """Save API keys to file"""
+        try:
+            with open(self.api_keys_file, 'w') as f:
+                json.dump(self._keys, f, indent=2)
+            
+            # Set restrictive permissions (owner read/write only)
+            try:
+                os.chmod(self.api_keys_file, 0o600)
+            except Exception:
+                pass  # Windows may not support chmod
+            
+            return True
+        except Exception as e:
+            console.print(f"[red]Error saving API keys: {e}[/red]")
+            return False
+    
+    def get_api_key(self, provider: str) -> Optional[str]:
+        """
+        Get API key for a provider.
+        Environment variables take precedence over stored keys.
+        """
+        if provider not in self.PROVIDERS:
+            return None
+        
+        env_var = self.PROVIDERS[provider]["env_var"]
+        
+        # Check environment variable first
+        env_key = os.getenv(env_var)
+        if env_key:
+            return env_key
+        
+        # Fall back to stored key
+        self._load_keys()
+        return self._keys.get(provider)
+    
+    def set_api_key(self, provider: str, key: str) -> bool:
+        """Set API key for a provider"""
+        if provider not in self.PROVIDERS:
+            return False
+        
+        self._load_keys()
+        self._keys[provider] = key
+        
+        # Also set as environment variable for current session
+        env_var = self.PROVIDERS[provider]["env_var"]
+        os.environ[env_var] = key
+        
+        return self._save_keys()
+    
+    def remove_api_key(self, provider: str) -> bool:
+        """Remove API key for a provider"""
+        if provider not in self.PROVIDERS:
+            return False
+        
+        self._load_keys()
+        if provider in self._keys:
+            del self._keys[provider]
+            return self._save_keys()
+        return True
+    
+    def is_configured(self, provider: str) -> bool:
+        """Check if a provider's API key is configured"""
+        return self.get_api_key(provider) is not None
+    
+    def get_status(self) -> Dict[str, Dict[str, Any]]:
+        """Get configuration status for all providers"""
+        status = {}
+        for provider, info in self.PROVIDERS.items():
+            key = self.get_api_key(provider)
+            status[provider] = {
+                "name": info["name"],
+                "configured": key is not None,
+                "source": "environment" if os.getenv(info["env_var"]) else ("stored" if key else "not set"),
+                "required": info["required"],
+                "masked_key": self._mask_key(key) if key else None
+            }
+        return status
+    
+    def _mask_key(self, key: str) -> str:
+        """Mask API key for display (show first 4 and last 4 chars)"""
+        if not key or len(key) < 12:
+            return "****"
+        return f"{key[:4]}...{key[-4:]}"
+    
+    def is_first_time_setup_needed(self) -> bool:
+        """Check if first-time API setup is needed"""
+        # Check if setup has been completed or skipped
+        self._load_keys()
+        if self._keys.get("_setup_completed"):
+            return False
+        
+        # Check if at least the required key (Groq) is set
+        if self.is_configured("groq"):
+            return False
+        
+        return True
+    
+    def mark_setup_completed(self) -> bool:
+        """Mark first-time setup as completed (even if skipped)"""
+        self._load_keys()
+        self._keys["_setup_completed"] = True
+        return self._save_keys()
+    
+    def load_keys_to_environment(self):
+        """Load stored keys into environment variables and refresh clients"""
+        self._load_keys()
+        for provider, key in self._keys.items():
+            if provider.startswith("_"):
+                continue  # Skip internal flags
+            if provider in self.PROVIDERS:
+                env_var = self.PROVIDERS[provider]["env_var"]
+                if key and not os.getenv(env_var):
+                    os.environ[env_var] = key
+        
+        # Refresh OpenRouter client to pick up the loaded keys
+        try:
+            from ...services.llm_inference.openrouter_client import openrouter_client
+            if openrouter_client:
+                openrouter_client.refresh_api_key()
+        except ImportError:
+            pass  # OpenRouter client not available
+
+
+# Global instance
+api_config_manager = APIConfigManager()
+
+
+def _show_api_instructions(console_instance: Console, provider: str, colors: Dict[str, str]):
+    """Display step-by-step instructions for getting an API key"""
+    if provider not in API_KEY_INSTRUCTIONS:
+        return
+    
+    instructions = API_KEY_INSTRUCTIONS[provider]
+    steps_text = "\n".join(instructions["steps"])
+    
+    left_to_right_reveal(console_instance, "", duration=0.3)
+    console_instance.print(Panel(
+        steps_text,
+        title=f"[bold {colors['primary']}]{instructions['title']}[/bold {colors['primary']}]",
+        border_style=f"bold {colors['primary']}",
+        padding=(1, 2)
+    ))
+
+
+def run_first_time_api_setup(console_instance: Console = None) -> bool:
+    """
+    Run first-time API key setup wizard.
+    Returns True if setup was completed, False if skipped.
+    """
+    if console_instance is None:
+        console_instance = console
+    
+    from ..ui.theme import get_theme_colors, style_text
+    colors = get_theme_colors()
+    
+    console_instance.print()
+    console_instance.print(Panel(
+        "[bold]Welcome to ArionXiv![/bold]\n\n"
+        "ArionXiv is ready to use. All AI features work out of the box\n"
+        "using the hosted backend.\n\n"
+        "[bold]Optional:[/bold] Configure your own API keys for:\n"
+        "  - Gemini - Enhanced embeddings\n"
+        "  - Groq - Faster local LLM inference\n"
+        "  - HuggingFace - Model downloads\n\n"
+        "[dim]You can configure these anytime with: arionxiv settings api[/dim]",
+        title="[bold]First-Time Setup[/bold]",
+        border_style=f"bold {colors['primary']}"
+    ))
+    
+    # Ask if user wants to configure now - default is No
+    if not Confirm.ask(
+        f"\n[bold {colors['primary']}]Would you like to configure optional API keys now?[/bold {colors['primary']}]",
+        default=False
+    ):
+        left_to_right_reveal(console_instance, f"\nGreat! You're all set.", style=colors['primary'], duration=1.0)
+        left_to_right_reveal(console_instance, f"Configure keys later with: arionxiv settings api", style=f"dim {colors['primary']}", duration=1.0)
+        api_config_manager.mark_setup_completed()
+        return False
+    
+    console_instance.print()
+    
+    # Configure each provider with instructions
+    for provider, info in api_config_manager.PROVIDERS.items():
+        _configure_single_provider_with_instructions(console_instance, provider, info, colors, first_time=True)
+    
+    api_config_manager.mark_setup_completed()
+    
+    console_instance.print()
+    console_instance.print(Panel(
+        "API configuration complete!\n\n"
+        f"Manage keys anytime with: [{colors['primary']}]arionxiv settings api[/{colors['primary']}]",
+        title="[bold]Setup Complete[/bold]",
+        border_style=f"bold {colors['primary']}"
+    ))
+    
+    return True
+
+
+def _configure_single_provider_with_instructions(
+    console_instance: Console,
+    provider: str,
+    info: Dict[str, Any],
+    colors: Dict[str, str],
+    first_time: bool = False,
+    show_instructions: bool = True
+) -> bool:
+    """Configure a single API provider with step-by-step instructions"""
+    
+    current_key = api_config_manager.get_api_key(provider)
+    required_text = "REQUIRED" if info["required"] else "optional"
+    req_style = colors['error'] if info["required"] else colors['primary']
+    
+    left_to_right_reveal(console_instance, f"\n{'='*60}", style=colors['primary'], duration=0.5)
+    left_to_right_reveal(console_instance, f"{info['name']} ({required_text})", style=f"bold {colors['primary']}", duration=0.8)
+    left_to_right_reveal(console_instance, f"{info['description']}", style="white", duration=0.6)
+    
+    if current_key:
+        left_to_right_reveal(console_instance, f"Already configured: {api_config_manager._mask_key(current_key)}", style=f"bold {colors['primary']}", duration=0.8)
+        if first_time:
+            # Already configured, skip
+            return True
+    
+    # Show step-by-step instructions
+    if show_instructions and provider in API_KEY_INSTRUCTIONS:
+        _show_api_instructions(console_instance, provider, colors)
+    
+    # Ask for key
+    prompt_text = f"Enter {info['name']} API key"
+    if not info["required"]:
+        prompt_text += " (or press Enter to skip)"
+    
+    key_input = Prompt.ask(
+        f"\n[bold {colors['primary']}]{prompt_text}[/bold {colors['primary']}]",
+        default="",
+        show_default=False
+    )
+    
+    if key_input.strip():
+        if api_config_manager.set_api_key(provider, key_input.strip()):
+            left_to_right_reveal(console_instance, f"{info['name']} key saved successfully!", style=f"bold {colors['primary']}", duration=1.0)
+            return True
+        else:
+            left_to_right_reveal(console_instance, f"Failed to save {info['name']} key", style=f"bold {colors['error']}", duration=1.0)
+            return False
+    else:
+        if info["required"]:
+            left_to_right_reveal(console_instance, f"Warning: {info['name']} key is REQUIRED for AI features", style=colors['warning'], duration=1.0)
+            left_to_right_reveal(console_instance, f"  You can add it later with: arionxiv settings api", style=colors['warning'], duration=0.8)
+        else:
+            left_to_right_reveal(console_instance, f"Skipped {info['name']} (you can add it later)", style="white", duration=0.8)
+        return True
+
+
+def _configure_single_provider(
+    console_instance: Console,
+    provider: str,
+    info: Dict[str, Any],
+    colors: Dict[str, str],
+    first_time: bool = False
+) -> bool:
+    """Configure a single API provider (legacy - without detailed instructions)"""
+    
+    current_key = api_config_manager.get_api_key(provider)
+    required_text = "[required]" if info["required"] else "[optional]"
+    
+    left_to_right_reveal(console_instance, f"\n{info['name']} {required_text}", style=f"bold {colors['primary']}", duration=0.8)
+    left_to_right_reveal(console_instance, f"{info['description']}", style="white", duration=0.6)
+    left_to_right_reveal(console_instance, f"Get your key at: {info['url']}", style="white", duration=0.6)
+    
+    if current_key:
+        left_to_right_reveal(console_instance, f"Current: {api_config_manager._mask_key(current_key)}", style=f"bold {colors['primary']}", duration=0.8)
+        if first_time:
+            # Already configured, skip
+            return True
+    
+    # Ask for key
+    prompt_text = f"Enter {info['name']} API key"
+    if not info["required"]:
+        prompt_text += " (or press Enter to skip)"
+    
+    key_input = Prompt.ask(
+        f"[bold {colors['primary']}]{prompt_text}[/bold {colors['primary']}]",
+        default="",
+        show_default=False
+    )
+    
+    if key_input.strip():
+        if api_config_manager.set_api_key(provider, key_input.strip()):
+            left_to_right_reveal(console_instance, f"{info['name']} key saved successfully", style=f"bold {colors['primary']}", duration=1.0)
+            return True
+        else:
+            left_to_right_reveal(console_instance, f"Failed to save {info['name']} key", style=f"bold {colors['error']}", duration=1.0)
+            return False
+    else:
+        if info["required"]:
+            left_to_right_reveal(console_instance, f"Warning: {info['name']} key is required for AI features", style=f"bold {colors['warning']}", duration=1.0)
+        else:
+            left_to_right_reveal(console_instance, f"Skipped {info['name']}", style="white", duration=0.8)
+        return True
+
+
+def show_api_status(console_instance: Console = None):
+    """Display current API configuration status"""
+    if console_instance is None:
+        console_instance = console
+    
+    from ..ui.theme import get_theme_colors
+    colors = get_theme_colors()
+    
+    status = api_config_manager.get_status()
+    
+    table = Table(
+        title="API Configuration Status",
+        show_header=True,
+        header_style=f"bold {colors['primary']}",
+        border_style=f"bold {colors['primary']}"
+    )
+    table.add_column("Provider", style="bold white")
+    table.add_column("Status", style="white", width=12)
+    table.add_column("Source", style="white", width=12)
+    table.add_column("Key", style="white", width=20)
+    table.add_column("Required", style="white", width=10)
+    
+    for provider, info in status.items():
+        status_text = f"[bold {colors['primary']}]Configured[/bold {colors['primary']}]" if info["configured"] else f"[bold {colors['warning']}]Not Set[/bold {colors['warning']}]"
+        source_text = info["source"].title() if info["configured"] else "-"
+        key_text = info["masked_key"] if info["masked_key"] else "-"
+        required_text = "Yes" if info["required"] else "No"
+        
+        table.add_row(
+            info["name"],
+            status_text,
+            source_text,
+            key_text,
+            required_text
+        )
+    
+    console_instance.print()
+    console_instance.print(table)
+    console_instance.print()
+
+
+__all__ = [
+    'APIConfigManager',
+    'api_config_manager',
+    'run_first_time_api_setup',
+    'show_api_status',
+    'API_KEY_INSTRUCTIONS'
+]

arionxiv/cli/utils/command_suggestions.py

@@ -0,0 +1,147 @@
+"""
+Command Suggestions Utility
+Shows helpful next commands after each feature completes
+"""
+
+from rich.console import Console
+from rich.panel import Panel
+from typing import List, Tuple, Optional
+
+
+def _get_theme_colors():
+    """Get theme colors with lazy import to avoid circular imports"""
+    try:
+        from ..ui.theme_system import get_theme_colors
+        return get_theme_colors()
+    except ImportError:
+        return {'primary': 'cyan', 'secondary': 'blue', 'success': 'green', 
+                'warning': 'yellow', 'error': 'red', 'muted': 'dim'}
+
+
+# Command categories for different contexts
+CHAT_COMMANDS = [
+    ("arionxiv chat", "Start a new chat session"),
+    ("arionxiv search <query>", "Search for more papers"),
+    ("arionxiv settings papers", "Manage your saved papers"),
+]
+
+SEARCH_COMMANDS = [
+    ("arionxiv chat", "Chat with a paper"),
+    ("arionxiv search <query>", "Search for different papers"),
+    ("arionxiv trending", "See trending papers"),
+]
+
+SETTINGS_COMMANDS = [
+    ("arionxiv settings", "Back to settings menu"),
+    ("arionxiv chat", "Start a chat session"),
+    ("arionxiv search <query>", "Search for papers"),
+]
+
+TRENDING_COMMANDS = [
+    ("arionxiv chat", "Chat with a paper"),
+    ("arionxiv search <query>", "Search for specific papers"),
+    ("arionxiv daily", "Get your daily digest"),
+]
+
+DAILY_COMMANDS = [
+    ("arionxiv chat", "Chat with a paper"),
+    ("arionxiv search <query>", "Search for papers"),
+    ("arionxiv trending", "See trending papers"),
+]
+
+ANALYZE_COMMANDS = [
+    ("arionxiv chat", "Chat with this paper"),
+    ("arionxiv search <query>", "Search for related papers"),
+    ("arionxiv settings papers", "Save to your library"),
+]
+
+LIBRARY_COMMANDS = [
+    ("arionxiv chat", "Chat with a saved paper"),
+    ("arionxiv search <query>", "Find new papers"),
+    ("arionxiv settings papers", "Manage saved papers"),
+]
+
+GENERAL_COMMANDS = [
+    ("arionxiv chat", "Chat with papers using AI"),
+    ("arionxiv search <query>", "Search arXiv papers"),
+    ("arionxiv trending", "See trending papers"),
+    ("arionxiv daily", "Daily paper digest"),
+    ("arionxiv settings", "Configure preferences"),
+]
+
+# Navigation commands
+NAVIGATION_COMMANDS = [
+    ("arionxiv", "Go to homepage"),
+    ("arionxiv --help", "Show all commands"),
+]
+
+
+def show_command_suggestions(
+    console: Console,
+    context: str = "general",
+    custom_commands: Optional[List[Tuple[str, str]]] = None,
+    show_navigation: bool = True,
+    title: str = "What's Next?"
+):
+    """
+    Show helpful command suggestions after a feature completes.
+    
+    Args:
+        console: Rich console instance
+        context: One of 'chat', 'search', 'settings', 'trending', 'daily', 
+                'analyze', 'library', 'general'
+        custom_commands: Optional list of (command, description) tuples to show instead
+        show_navigation: Whether to show navigation commands (homepage, help)
+        title: Panel title
+    """
+    colors = _get_theme_colors()
+    
+    # Get commands based on context
+    context_commands = {
+        'chat': CHAT_COMMANDS,
+        'search': SEARCH_COMMANDS,
+        'settings': SETTINGS_COMMANDS,
+        'trending': TRENDING_COMMANDS,
+        'daily': DAILY_COMMANDS,
+        'analyze': ANALYZE_COMMANDS,
+        'library': LIBRARY_COMMANDS,
+        'general': GENERAL_COMMANDS,
+    }
+    
+    commands = custom_commands or context_commands.get(context, GENERAL_COMMANDS)
+    
+    # Build command lines
+    lines = []
+    for cmd, desc in commands:
+        lines.append(
+            f"  [bold {colors['primary']}]{cmd}[/bold {colors['primary']}]  "
+            f"[white]→  {desc}[/white]"
+        )
+    
+    # Add separator and navigation if requested
+    if show_navigation:
+        lines.append("")  # Empty line as separator
+        lines.append(f"  [white]─────────────────────────────────────[/white]")
+        for cmd, desc in NAVIGATION_COMMANDS:
+            lines.append(
+                f"  [bold {colors['primary']}]{cmd}[/bold {colors['primary']}]  "
+                f"[white]→  {desc}[/white]"
+            )
+    
+    console.print()
+    console.print(Panel(
+        "\n".join(lines),
+        title=f"[bold {colors['primary']}]{title}[/bold {colors['primary']}]",
+        border_style=f"bold {colors['primary']}",
+        padding=(1, 2)
+    ))
+
+
+def show_back_to_home(console: Console):
+    """Show a simple message about going back to homepage"""
+    colors = _get_theme_colors()
+    console.print()
+    console.print(
+        f"[white]Run [bold {colors['primary']}]arionxiv[/bold {colors['primary']}] "
+        f"to go back to homepage[/white]"
+    )