codemate-cli 1.0.0__py3-none-any.whl

codemate/utils/error_handler.py

@@ -0,0 +1,277 @@
+# codemate/utils/error_handler.py
+"""Enhanced error handling for CodeMate CLI"""
+
+import re
+import webbrowser
+from typing import Optional, Tuple
+from rich.console import Console
+from rich.panel import Panel
+from rich.text import Text
+from rich import box
+
+
+class ErrorHandler:
+    """Centralized error handling for CodeMate CLI"""
+    
+    # Upgrade URL for plan limits
+    UPGRADE_URL = "https://app.codemate.ai/settings"
+    
+    def __init__(self, console: Console):
+        self.console = console
+    
+    def parse_error_message(self, error_msg: str) -> Tuple[str, str, Optional[str]]:
+        """
+        Parse error message and categorize it
+        
+        Returns:
+            Tuple of (error_type, display_message, upgrade_url)
+            - error_type: "connection", "rate_limit", "server", "generic"
+            - display_message: User-friendly message
+            - upgrade_url: URL for upgrade (if rate limit error)
+        """
+        error_lower = error_msg.lower()
+        
+        # Connection errors
+        if "connection" in error_lower or "failed to connect" in error_lower:
+            return (
+                "connection",
+                "Unable to connect to CodeMate server. Please check:\n"
+                "  • Is the server running?\n"
+                "  • Check your internet connection\n"
+                "  • Verify server endpoint in configuration",
+                None
+            )
+        
+        # All connection attempts failed
+        if "all connection attempts failed" in error_lower:
+            return (
+                "connection",
+                "Cannot reach CodeMate server. Please ensure:\n"
+                "  • The server is running and accessible\n"
+                "  • Your network connection is stable\n"
+                "  • Firewall is not blocking the connection",
+                None
+            )
+        
+        # Rate limit errors - parse for details
+        rate_limit_match = re.search(
+            r'rate limit exceeded.*?you have used (\d+)/(\d+) requests',
+            error_lower
+        )
+        if rate_limit_match or "rate limit" in error_lower or "ratelimiterror" in error_lower:
+            used = rate_limit_match.group(1) if rate_limit_match else "N/A"
+            limit = rate_limit_match.group(2) if rate_limit_match else "N/A"
+            
+            return (
+                "rate_limit",
+                f"Rate Limit Exceeded\n\n"
+                f"You have used {used}/{limit} requests.\n"
+                f"Please upgrade your plan for higher limits.\n\n"
+                f"Upgrade URL: {self.UPGRADE_URL}",
+                self.UPGRADE_URL
+            )
+        
+        # 429 Status Code (Too Many Requests)
+        if "429" in error_msg or "too many requests" in error_lower:
+            return (
+                "rate_limit",
+                f"Too Many Requests (429)\n\n"
+                f"You've exceeded your request limit.\n"
+                f"Please upgrade your plan for higher limits.\n\n"
+                f"Upgrade URL: {self.UPGRADE_URL}",
+                self.UPGRADE_URL
+            )
+        
+        # Server errors (5xx)
+        if any(code in error_msg for code in ["500", "502", "503", "504"]):
+            return (
+                "server",
+                "Internal Server Error\n\n"
+                "The CodeMate service is temporarily unavailable.\n"
+                "Please try again in a few moments.",
+                None
+            )
+        
+        # Authentication errors
+        if "unauthorized" in error_lower or "401" in error_msg:
+            return (
+                "auth",
+                "Authentication Failed\n\n"
+                "Your session may have expired.\n"
+                "Please login again using /logout and restart CLI.",
+                None
+            )
+        
+        # Timeout errors
+        if "timeout" in error_lower or "timed out" in error_lower:
+            return (
+                "timeout",
+                "Request Timeout\n\n"
+                "The server took too long to respond.\n"
+                "Please try again or check your connection.",
+                None
+            )
+        
+        # Generic error
+        return (
+            "generic",
+            f"An error occurred:\n{error_msg}",
+            None
+        )
+    
+    def display_connection_error(self):
+        """Display connection error panel"""
+        self.console.print()
+        self.console.print(Panel(
+            "[red]⚠️  Cannot Connect to Server[/red]\n\n"
+            "[white]Please verify:[/white]\n"
+            "  [cyan]•[/cyan] Is the CodeMate server running?\n"
+            "  [cyan]•[/cyan] Check your internet connection\n"
+            "  [cyan]•[/cyan] Verify server endpoint configuration\n\n"
+            "[dim]Run [cyan]codemate-cli --help[/cyan] for more information[/dim]",
+            border_style="red",
+            title="[bold red]Connection Error[/bold red]",
+            padding=(1, 2),
+            box=box.ROUNDED
+        ))
+        self.console.print()
+    
+    def display_rate_limit_error(self, used: str = "N/A", limit: str = "N/A"):
+        """Display rate limit error with upgrade prompt"""
+        self.console.print()
+        self.console.print(Panel(
+            f"[yellow]⚠️  Rate Limit Exceeded[/yellow]\n\n"
+            f"[white]Usage:[/white] {used}/{limit} requests\n\n"
+            f"[white]You've reached your plan's request limit.[/white]\n"
+            f"[cyan]Upgrade your plan for higher limits.[/cyan]\n\n"
+            f"[dim]Upgrade URL:[/dim] [link={self.UPGRADE_URL}]{self.UPGRADE_URL}[/link]",
+            border_style="yellow",
+            title="[bold yellow]⚡ Upgrade Required[/bold yellow]",
+            padding=(1, 2),
+            box=box.ROUNDED
+        ))
+        
+        # Prompt user to open browser
+        self.console.print()
+        try:
+            response = self.console.input(
+                "[cyan]Would you like to open the upgrade page in your browser? (y/n):[/cyan] "
+            ).strip().lower()
+            
+            if response in ['y', 'yes']:
+                try:
+                    webbrowser.open(self.UPGRADE_URL)
+                    self.console.print("[green]✓[/green] Opening browser...")
+                except Exception as e:
+                    self.console.print(f"[yellow]Could not open browser: {e}[/yellow]")
+                    self.console.print(f"[dim]Please visit: {self.UPGRADE_URL}[/dim]")
+        except (KeyboardInterrupt, EOFError):
+            self.console.print()
+        
+        self.console.print()
+    
+    def display_server_error(self):
+        """Display server error panel"""
+        self.console.print()
+        self.console.print(Panel(
+            "[red]⚠️  Internal Server Error[/red]\n\n"
+            "[white]The CodeMate service is temporarily unavailable.[/white]\n\n"
+            "[dim]Please try again in a few moments.\n"
+            "If the issue persists, contact support.[/dim]",
+            border_style="red",
+            title="[bold red]Service Unavailable[/bold red]",
+            padding=(1, 2),
+            box=box.ROUNDED
+        ))
+        self.console.print()
+    
+    def display_auth_error(self):
+        """Display authentication error panel"""
+        self.console.print()
+        self.console.print(Panel(
+            "[red]⚠️  Authentication Failed[/red]\n\n"
+            "[white]Your session may have expired.[/white]\n\n"
+            "[cyan]Please run:[/cyan] [bold]/logout[/bold]\n"
+            "[dim]Then restart the CLI to login again.[/dim]",
+            border_style="red",
+            title="[bold red]Session Expired[/bold red]",
+            padding=(1, 2),
+            box=box.ROUNDED
+        ))
+        self.console.print()
+    
+    def display_timeout_error(self):
+        """Display timeout error panel"""
+        self.console.print()
+        self.console.print(Panel(
+            "[yellow]⚠️  Request Timeout[/yellow]\n\n"
+            "[white]The server took too long to respond.[/white]\n\n"
+            "[dim]Please try again or check your connection.[/dim]",
+            border_style="yellow",
+            title="[bold yellow]Timeout[/bold yellow]",
+            padding=(1, 2),
+            box=box.ROUNDED
+        ))
+        self.console.print()
+    
+    def display_generic_error(self, error_msg: str):
+        """Display generic error panel"""
+        self.console.print()
+        self.console.print(Panel(
+            f"[red]❌ Error[/red]\n\n"
+            f"[white]{error_msg}[/white]\n\n"
+            f"[dim]If this issue persists, please contact support.[/dim]",
+            border_style="red",
+            title="[bold red]Error[/bold red]",
+            padding=(1, 2),
+            box=box.ROUNDED
+        ))
+        self.console.print()
+    
+    def handle_error(self, error: Exception):
+        """Main error handler - routes to appropriate display method"""
+        error_msg = str(error)
+        error_type, display_msg, upgrade_url = self.parse_error_message(error_msg)
+        
+        if error_type == "connection":
+            self.display_connection_error()
+        elif error_type == "rate_limit":
+            # Extract usage numbers if available
+            match = re.search(r'(\d+)/(\d+) requests', error_msg)
+            if match:
+                self.display_rate_limit_error(match.group(1), match.group(2))
+            else:
+                self.display_rate_limit_error()
+        elif error_type == "server":
+            self.display_server_error()
+        elif error_type == "auth":
+            self.display_auth_error()
+        elif error_type == "timeout":
+            self.display_timeout_error()
+        else:
+            self.display_generic_error(display_msg)
+    
+    def handle_streaming_error(self, error_data: dict):
+        """Handle errors from streaming API (type: "error" chunks)"""
+        error_msg = error_data.get("message", "Unknown error occurred")
+        
+        # Parse the error
+        error_type, display_msg, upgrade_url = self.parse_error_message(error_msg)
+        
+        # Display appropriate error
+        if error_type == "rate_limit":
+            match = re.search(r'(\d+)/(\d+) requests', error_msg)
+            if match:
+                self.display_rate_limit_error(match.group(1), match.group(2))
+            else:
+                self.display_rate_limit_error()
+        elif error_type == "server":
+            self.display_server_error()
+        elif error_type == "auth":
+            self.display_auth_error()
+        elif error_type == "connection":
+            self.display_connection_error()
+        elif error_type == "timeout":
+            self.display_timeout_error()
+        else:
+            self.display_generic_error(error_msg)

codemate/utils/errors.py

@@ -0,0 +1,156 @@
+import functools
+import sys
+from typing import Callable
+from rich.console import Console
+from rich.panel import Panel
+import httpx
+
+console = Console()
+
+
+class CodeMateError(Exception):
+    """Base exception for CodeMate CLI"""
+    pass
+
+
+class APIError(CodeMateError):
+    """API-related errors"""
+    pass
+
+
+class ConfigError(CodeMateError):
+    """Configuration-related errors"""
+    pass
+
+
+class AuthenticationError(APIError):
+    """Authentication failed"""
+    pass
+
+
+class NetworkError(APIError):
+    """Network connectivity issues"""
+    pass
+
+
+def handle_errors(func: Callable) -> Callable:
+    """Decorator to handle errors gracefully in CLI commands"""
+    
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        try:
+            return func(*args, **kwargs)
+        
+        except httpx.HTTPStatusError as e:
+            if e.response.status_code == 401:
+                console.print(Panel(
+                    "[red]Authentication failed![/red]\n\n"
+                    "Your API key may be invalid or expired.\n"
+                    "Please set a valid API key:\n\n"
+                    "[cyan]codemate config set-key YOUR_API_KEY[/cyan]",
+                    title="[bold red]Authentication Error[/bold red]",
+                    border_style="red"
+                ))
+            elif e.response.status_code == 429:
+                console.print(Panel(
+                    "[red]Rate limit exceeded![/red]\n\n"
+                    "You've made too many requests. Please wait a moment and try again.",
+                    title="[bold red]Rate Limit[/bold red]",
+                    border_style="red"
+                ))
+            elif e.response.status_code == 500:
+                console.print(Panel(
+                    "[red]Server error![/red]\n\n"
+                    "The API server encountered an error.\n"
+                    "Please try again later or contact support.",
+                    title="[bold red]Server Error[/bold red]",
+                    border_style="red"
+                ))
+            else:
+                console.print(Panel(
+                    f"[red]HTTP Error {e.response.status_code}[/red]\n\n"
+                    f"{str(e)}",
+                    title="[bold red]Request Failed[/bold red]",
+                    border_style="red"
+                ))
+            sys.exit(1)
+        
+        except httpx.ConnectError:
+            console.print(Panel(
+                "[red]Connection failed![/red]\n\n"
+                "Could not connect to the API server.\n"
+                "Please check:\n"
+                "  • Is the server running?\n"
+                "  • Is the endpoint correct?\n"
+                "  • Do you have network connectivity?\n\n"
+                f"Current endpoint: [cyan]{kwargs.get('endpoint', 'http://localhost:45223')}[/cyan]\n\n"
+                "Set a different endpoint:\n"
+                "[cyan]codemate config set-endpoint http://your-server:port[/cyan]",
+                title="[bold red]Connection Error[/bold red]",
+                border_style="red"
+            ))
+            sys.exit(1)
+        
+        except httpx.TimeoutException:
+            console.print(Panel(
+                "[red]Request timed out![/red]\n\n"
+                "The request took too long to complete.\n"
+                "This might be due to:\n"
+                "  • Slow network connection\n"
+                "  • Server overload\n"
+                "  • Large request processing\n\n"
+                "Please try again.",
+                title="[bold red]Timeout Error[/bold red]",
+                border_style="red"
+            ))
+            sys.exit(1)
+        
+        except ConfigError as e:
+            console.print(Panel(
+                f"[red]Configuration error![/red]\n\n{str(e)}",
+                title="[bold red]Config Error[/bold red]",
+                border_style="red"
+            ))
+            sys.exit(1)
+        
+        except KeyboardInterrupt:
+            console.print("\n[yellow]Operation cancelled by user.[/yellow]")
+            sys.exit(0)
+        
+        except Exception as e:
+            console.print(Panel(
+                f"[red]Unexpected error![/red]\n\n"
+                f"{type(e).__name__}: {str(e)}\n\n"
+                "If this persists, please report the issue.",
+                title="[bold red]Error[/bold red]",
+                border_style="red"
+            ))
+            if console.is_terminal:
+                import traceback
+                console.print("\n[dim]Full traceback:[/dim]")
+                traceback.print_exc()
+            sys.exit(1)
+    
+    return wrapper
+
+
+def format_error_message(error: Exception) -> str:
+    """Format an error message for display"""
+    error_type = type(error).__name__
+    return f"{error_type}: {str(error)}"
+
+
+def is_network_error(error: Exception) -> bool:
+    """Check if an error is network-related"""
+    return isinstance(error, (
+        httpx.ConnectError,
+        httpx.TimeoutException,
+        httpx.NetworkError,
+    ))
+
+
+def is_auth_error(error: Exception) -> bool:
+    """Check if an error is authentication-related"""
+    if isinstance(error, httpx.HTTPStatusError):
+        return error.response.status_code == 401
+    return isinstance(error, AuthenticationError)

codemate/utils/kb_parser.py

@@ -0,0 +1,111 @@
+"""
+Utility functions for parsing and handling knowledge base mentions in user input
+"""
+import re
+from typing import Dict, List, Optional, Tuple
+
+
+def parse_kb_mentions(user_input: str, available_kbs: List[Dict]) -> Tuple[str, List[Dict], List[str]]:
+    """
+    Parse @kb_name mentions from user input and build context
+    
+    Args:
+        user_input: The user's input message
+        available_kbs: List of available knowledge bases
+    
+    Returns:
+        Tuple of (modified_message, context_list, invalid_kb_names)
+        - modified_message: Message with KB context XML tags inserted
+        - context_list: List of context objects for API
+        - invalid_kb_names: List of KB names that were mentioned but not found
+    """
+    # Find all @mentions in the input (supporting hyphens, dots, and word characters)
+    mentions = re.findall(r'@([\w.-]+)', user_input)
+    
+    if not mentions:
+        return user_input, [], []
+    
+    # Create a mapping of KB names to KB objects
+    kb_map = {kb['name']: kb for kb in available_kbs}
+    
+    context_list = []
+    invalid_kbs = []
+    modified_message = user_input
+    
+    # Process each mention
+    for kb_name in mentions:
+        if kb_name in kb_map:
+            kb = kb_map[kb_name]
+            
+            # Build context object
+            context_obj = {
+                "type": kb.get("type", "codebase"),
+                "kbid": kb["id"],
+                "name": kb["name"],
+                "id": kb["id"]
+            }
+            
+            # Only add if not already in context list
+            if not any(ctx["id"] == context_obj["id"] for ctx in context_list):
+                context_list.append(context_obj)
+            
+            # Build XML context tag
+            context_xml = (
+                f"<cm:context>"
+                f"<cm:context:name>{kb['name']}</cm:context:name>"
+                f"<cm:context:type>{kb.get('type', 'codebase')}</cm:context:type>"
+                f"<cm:context:id>{kb['id']}</cm:context:id>"
+                f"<cm:context:content></cm:context:content>"
+                f"</cm:context>"
+            )
+            
+            # Replace the @mention with context XML + @mention
+            # This ensures the mention appears once in the message
+            pattern = f"@{kb_name}"
+            if pattern in modified_message:
+                modified_message = modified_message.replace(
+                    pattern,
+                    f"{context_xml} ",
+                    1  # Replace only first occurrence
+                )
+        else:
+            invalid_kbs.append(kb_name)
+    
+    # Remove any remaining @mentions that were invalid
+    for invalid_kb in invalid_kbs:
+        modified_message = modified_message.replace(f"@{invalid_kb}", f"[Invalid KB: @{invalid_kb}]")
+    
+    return modified_message, context_list, invalid_kbs
+
+
+def format_kb_context_message(
+    user_input: str,
+    available_kbs: List[Dict]
+) -> Tuple[Optional[str], Optional[List[Dict]], Optional[str]]:
+    """
+    Format user input with KB context for API
+    
+    Args:
+        user_input: The user's input message
+        available_kbs: List of available knowledge bases
+    
+    Returns:
+        Tuple of (message, context, error_message)
+        - If successful: (formatted_message, context_list, None)
+        - If error: (None, None, error_message)
+    """
+    modified_message, context_list, invalid_kbs = parse_kb_mentions(user_input, available_kbs)
+    
+    # If there are invalid KB names, return error
+    if invalid_kbs:
+        error_msg = (
+            f"Invalid knowledge base name(s): {', '.join(['@' + kb for kb in invalid_kbs])}\n\n"
+            f"Use /listkb to see available knowledge bases."
+        )
+        return None, None, error_msg
+    
+    # If no context found, return original message with empty context
+    if not context_list:
+        return user_input, None, None
+    
+    return modified_message, context_list, None