webscout 6.3__py3-none-any.whl → 6.4__py3-none-any.whl

webscout/optimizers.py

@@ -0,0 +1,270 @@
+"""Prompt optimization utilities."""
+import platform
+import subprocess
+import os
+
+class Optimizers:
+    """
+    >>> Optimizers.code("write a hello world")
+    Returns optimized prompt for code generation
+    
+    >>> Optimizers.shell_command("list files")
+    Returns optimized prompt for shell commands
+    
+    >>> Optimizers.search("best pizza places")
+    Returns optimized prompt for web search
+    
+    >>> Optimizers.math("solve quadratic equation")
+    Returns optimized prompt for math problems
+    """
+
+    @staticmethod
+    def code(prompt):
+        """Deprecated: Use coder() instead"""
+        return Optimizers.coder(prompt)
+
+    @staticmethod
+    def shell_command(prompt):
+        """Deprecated: Use coder() instead"""
+        return Optimizers.coder(f"!{prompt}")
+
+    @staticmethod
+    def coder(prompt):
+        """Unified optimizer for both code and shell commands."""
+        # Get system info for shell commands
+        operating_system = ""
+        if platform.system() == "Windows":
+            operating_system = "Windows"
+        elif platform.system() == "Darwin":
+            operating_system = "MacOS"
+        elif platform.system() == "Linux":
+            try:
+                result = subprocess.check_output(["lsb_release", "-si"]).decode().strip()
+                operating_system = f"Linux/{result}" if result else "Linux"
+            except:
+                operating_system = "Linux"
+        else:
+            operating_system = platform.system()
+
+        # Get shell info
+        shell_name = "/bin/sh"
+        if platform.system() == "Windows":
+            shell_name = "powershell.exe" if os.getenv("PSModulePath") else "cmd.exe"
+        else:
+            shell_env = os.getenv("SHELL")
+            if shell_env:
+                shell_name = shell_env
+
+        return (
+            "Your Role: You are a code generation expert. Analyze the request and provide appropriate output.\n"
+            "If the request starts with '!' or involves system/shell operations, provide a shell command.\n"
+            "Otherwise, provide Python code.\n\n"
+            "RULES:\n"
+            "1. Provide ONLY code/command output without any description or markdown\n"
+            "2. For shell commands:\n"
+            f"   - Target OS: {operating_system}\n"
+            f"   - Shell: {shell_name}\n"
+            "   - Combine multiple steps when possible\n"
+            "3. For Python code:\n"
+            "   - Include necessary imports\n"
+            "   - Handle errors appropriately\n"
+            "   - Follow PEP 8 style\n"
+            "4. If details are missing, use most logical implementation\n"
+            "5. No warnings, descriptions, or explanations\n\n"
+            f"Request: {prompt}\n"
+            "Output:\n"
+        )
+
+    @staticmethod
+    def search(prompt):
+        """Optimize prompt for web search queries."""
+        return (
+            "Your role: Generate a precise and focused web search query.\n"
+            "IMPORTANT: Return only the search query without any explanation.\n"
+            "Format: Plain text, no markdown.\n"
+            "If details are missing, focus on the most relevant aspects.\n\n"
+            f"Request: {prompt}\n"
+            "Search Query:"
+        )
+
+    @staticmethod
+    def math(prompt):
+        """Optimize prompt for mathematical problem solving."""
+        return (
+            "Your role: Solve mathematical problems step by step.\n"
+            "Format: Plain text, show calculations clearly.\n"
+            "Show all steps and intermediate results.\n"
+            "Include units where applicable.\n"
+            "Provide final answer in a clear format.\n\n"
+            f"Problem: {prompt}\n"
+            "Solution:"
+        )
+
+    @staticmethod
+    def explain(prompt):
+        """Optimize prompt for clear explanations."""
+        return (
+            "Your role: Explain concepts clearly and concisely.\n"
+            "Format: Break down complex ideas into simple terms.\n"
+            "Use analogies where helpful.\n"
+            "Focus on key points and practical understanding.\n\n"
+            f"Topic: {prompt}\n"
+            "Explanation:"
+        )
+
+    @staticmethod
+    def debug(prompt):
+        """Optimize prompt for debugging code."""
+        return (
+            "Your role: Debug code and identify issues.\n"
+            "Steps:\n"
+            "1. Identify syntax errors\n"
+            "2. Check logic issues\n"
+            "3. Look for common pitfalls\n"
+            "4. Suggest fixes\n\n"
+            f"Code to debug: {prompt}\n"
+            "Analysis:"
+        )
+
+    @staticmethod
+    def api(prompt):
+        """Optimize prompt for API endpoint design."""
+        return (
+            "Your role: Design RESTful API endpoints.\n"
+            "Include:\n"
+            "- HTTP methods\n"
+            "- URL structure\n"
+            "- Request/Response format\n"
+            "- Status codes\n\n"
+            f"API requirement: {prompt}\n"
+            "Design:"
+        )
+
+    @staticmethod
+    def sql(prompt):
+        """Optimize prompt for SQL query generation."""
+        return (
+            "Your role: Generate optimized SQL queries.\n"
+            "Requirements:\n"
+            "- Standard SQL syntax\n"
+            "- Efficient query structure\n"
+            "- Proper joins and indexing\n"
+            "- Consider performance\n\n"
+            f"Query need: {prompt}\n"
+            "SQL:"
+        )
+
+    @staticmethod
+    def regex(prompt):
+        """Optimize prompt for regex pattern generation."""
+        return (
+            "Your role: Generate precise regex patterns.\n"
+            "Requirements:\n"
+            "- Standard regex syntax\n"
+            "- Pattern explanation\n"
+            "- Test cases\n"
+            "- Consider edge cases\n\n"
+            f"Pattern need: {prompt}\n"
+            "Regex:"
+        )
+
+    @staticmethod
+    def test(prompt):
+        """Optimize prompt for test case generation."""
+        return (
+            "Your role: Generate comprehensive test cases.\n"
+            "Include:\n"
+            "- Edge cases\n"
+            "- Corner cases\n"
+            "- Error scenarios\n"
+            "- Happy path\n"
+            "Format: Test name and expected result\n\n"
+            f"Test requirement: {prompt}\n"
+            "Test Cases:"
+        )
+
+    @staticmethod
+    def docker(prompt):
+        """Optimize prompt for Dockerfile creation."""
+        return (
+            "Your role: Create efficient Dockerfile.\n"
+            "Consider:\n"
+            "- Base image selection\n"
+            "- Layer optimization\n"
+            "- Security best practices\n"
+            "- Multi-stage builds if needed\n\n"
+            f"Container requirement: {prompt}\n"
+            "Dockerfile:"
+        )
+
+    @staticmethod
+    def git(prompt):
+        """Optimize prompt for git commands."""
+        return (
+            "Your role: Generate git commands.\n"
+            "Requirements:\n"
+            "- Clear and safe commands\n"
+            "- Consider current state\n"
+            "- Include safety checks\n"
+            "- Best practices\n\n"
+            f"Git task: {prompt}\n"
+            "Command:"
+        )
+
+    @staticmethod
+    def yaml(prompt):
+        """Optimize prompt for YAML configuration."""
+        return (
+            "Your role: Generate YAML configuration.\n"
+            "Requirements:\n"
+            "- Valid YAML syntax\n"
+            "- Clear structure\n"
+            "- Comments for complex parts\n"
+            "- Best practices\n\n"
+            f"Config need: {prompt}\n"
+            "YAML:"
+        )
+
+    @staticmethod
+    def cli(prompt):
+        """Optimize prompt for CLI command design."""
+        return (
+            "Your role: Design CLI commands.\n"
+            "Include:\n"
+            "- Command structure\n"
+            "- Arguments/options\n"
+            "- Help messages\n"
+            "- Examples\n\n"
+            f"CLI requirement: {prompt}\n"
+            "Design:"
+        )
+
+    @staticmethod
+    def refactor(prompt):
+        """Optimize prompt for code refactoring suggestions."""
+        return (
+            "Your role: Suggest code improvements.\n"
+            "Focus on:\n"
+            "- Code quality\n"
+            "- Performance\n"
+            "- Readability\n"
+            "- Best practices\n"
+            "- Design patterns\n\n"
+            f"Code to refactor: {prompt}\n"
+            "Suggestions:"
+        )
+
+    @staticmethod
+    def security(prompt):
+        """Optimize prompt for security analysis."""
+        return (
+            "Your role: Security analysis and fixes.\n"
+            "Check for:\n"
+            "- Common vulnerabilities\n"
+            "- Security best practices\n"
+            "- Input validation\n"
+            "- Authentication/Authorization\n"
+            "- Data protection\n\n"
+            f"Code to analyze: {prompt}\n"
+            "Analysis:"
+        )

webscout/prompt_manager.py

@@ -0,0 +1,279 @@
+"""
+HAI's Awesome Prompts! 🔥
+The most fire prompts collection you'll ever see! 💯
+Created by the legendary HAI squad! 👑
+"""
+
+import os
+import json
+import logging
+import requests
+from typing import Optional, Dict, Union, List
+from rich.console import Console
+from rich.table import Table
+from rich.panel import Panel
+from datetime import datetime
+
+console = Console()
+
+class AwesomePrompts:
+    """The most awesome prompts manager you'll ever see fr fr! 🔥"""
+    
+    def __init__(
+        self,
+        repo_url: str = "https://raw.githubusercontent.com/OE-LUCIFER/prompts/main/prompt.json",
+        local_path: Optional[str] = None,
+        auto_update: bool = True
+    ):
+        """Initialize them Awesome Prompts with style! 💫
+
+        Args:
+            repo_url (str): URL to fetch prompts from
+            local_path (str, optional): Where to save them prompts locally
+            auto_update (bool): Auto update prompts on init. Defaults to True
+        """
+        self.repo_url = repo_url
+        self.local_path = local_path or os.path.join(
+            os.path.expanduser("~"),
+            ".webscout",
+            "awesome-prompts.json"
+        )
+        self._cache: Dict[Union[str, int], str] = {}
+        self._last_update: Optional[datetime] = None
+        
+        # Create directory if it doesn't exist
+        os.makedirs(os.path.dirname(self.local_path), exist_ok=True)
+        
+        # Load those prompts on init if auto_update is True
+        if auto_update:
+            self.update_prompts_from_online()
+    
+    def _load_prompts(self) -> Dict[Union[str, int], str]:
+        """Load prompts from the local file fr fr! 📂"""
+        try:
+            if os.path.exists(self.local_path):
+                with open(self.local_path, 'r', encoding='utf-8') as f:
+                    return json.load(f)
+            return {}
+        except Exception as e:
+            console.print(f"[red]❌ Error loading prompts: {str(e)}[/red]")
+            return {}
+    
+    def _save_prompts(self, prompts: Dict[Union[str, int], str]) -> None:
+        """Save them prompts with style! 💾"""
+        try:
+            with open(self.local_path, 'w', encoding='utf-8') as f:
+                json.dump(prompts, f, indent=4, ensure_ascii=False)
+            self._cache = prompts
+            console.print("[green]✨ Prompts saved successfully![/green]")
+        except Exception as e:
+            console.print(f"[red]❌ Error saving prompts: {str(e)}[/red]")
+    
+    def update_prompts_from_online(self, force: bool = False) -> bool:
+        """Update prompts from the repo! 🚀
+
+        Args:
+            force (bool): Force update even if recently updated
+
+        Returns:
+            bool: True if update successful
+        """
+        try:
+            # Check if we need to update
+            if not force and self._last_update and \
+               (datetime.now() - self._last_update).total_seconds() < 3600:
+                console.print("[yellow]⚡ Prompts are already up to date![/yellow]")
+                return True
+                
+            console.print("[cyan]🔄 Updating prompts...[/cyan]")
+            response = requests.get(self.repo_url, timeout=10)
+            response.raise_for_status()
+            
+            # Merge new prompts with existing ones
+            new_prompts = response.json()
+            existing_prompts = self._load_prompts()
+            merged_prompts = {**existing_prompts, **new_prompts}
+            
+            # Create a new dictionary for numeric indices
+            indexed_prompts = merged_prompts.copy()
+            
+            # Add indices for numeric access
+            for i, (key, value) in enumerate(list(merged_prompts.items())):
+                if isinstance(key, str):
+                    indexed_prompts[i] = value
+            
+            self._save_prompts(indexed_prompts)
+            self._last_update = datetime.now()
+            
+            console.print("[green]✨ Prompts updated successfully![/green]")
+            return True
+            
+        except Exception as e:
+            console.print(f"[red]❌ Error updating prompts: {str(e)}[/red]")
+            return False
+    
+    def get_act(
+        self,
+        key: Union[str, int],
+        default: Optional[str] = None,
+        case_insensitive: bool = True
+    ) -> Optional[str]:
+        """Get that perfect prompt! 🎯
+
+        Args:
+            key: Prompt name or index
+            default: Default value if not found
+            case_insensitive: Match case exactly?
+
+        Returns:
+            str: The prompt or default value
+        """
+        prompts = self._cache or self._load_prompts()
+        
+        # Try direct access first
+        if key in prompts:
+            return prompts[key]
+            
+        # Try case-insensitive search for string keys
+        if isinstance(key, str) and case_insensitive:
+            key_lower = key.lower()
+            for k, v in prompts.items():
+                if isinstance(k, str) and k.lower() == key_lower:
+                    return v
+        
+        return default
+    
+    def add_prompt(self, name: str, prompt: str) -> bool:
+        """Add a new prompt to the collection! ✨
+
+        Args:
+            name: Name of the prompt
+            prompt: The prompt text
+
+        Returns:
+            bool: Success status
+        """
+        if not name or not prompt:
+            console.print("[red]❌ Name and prompt cannot be empty![/red]")
+            return False
+            
+        prompts = self._cache or self._load_prompts()
+        prompts[name] = prompt
+        self._save_prompts(prompts)
+        return True
+    
+    def delete_prompt(
+        self,
+        name: Union[str, int],
+        case_insensitive: bool = True,
+        raise_not_found: bool = False
+    ) -> bool:
+        """Delete a prompt from the collection! 🗑️
+
+        Args:
+            name: Name or index of prompt to delete
+            case_insensitive: Match case exactly?
+            raise_not_found: Raise error if prompt not found?
+
+        Returns:
+            bool: Success status
+        """
+        prompts = self._cache or self._load_prompts()
+        
+        # Handle direct key match
+        if name in prompts:
+            del prompts[name]
+            self._save_prompts(prompts)
+            return True
+            
+        # Handle case-insensitive match
+        if isinstance(name, str) and case_insensitive:
+            name_lower = name.lower()
+            for k in list(prompts.keys()):
+                if isinstance(k, str) and k.lower() == name_lower:
+                    del prompts[k]
+                    self._save_prompts(prompts)
+                    return True
+        
+        if raise_not_found:
+            raise KeyError(f"Prompt '{name}' not found!")
+        console.print(f"[yellow]⚠️ Prompt '{name}' not found![/yellow]")
+        return False
+    
+    @property
+    def all_acts(self) -> Dict[Union[str, int], str]:
+        """All them awesome prompts mapped with style! 📚
+
+        Returns:
+            dict: All prompts with their indices
+        """
+        prompts = self._cache or self._load_prompts()
+        if not prompts:
+            self.update_prompts_from_online()
+            prompts = self._load_prompts()
+            
+        # Create a new dictionary for the result
+        result = prompts.copy()
+        
+        # Add numeric indices to the copy
+        for i, (key, value) in enumerate(list(prompts.items())):
+            if isinstance(key, str):
+                result[i] = value
+                
+        return result
+    
+    def show_acts(self, search: Optional[str] = None) -> None:
+        """Show all them awesome prompts with style! 📋
+
+        Args:
+            search: Optional search term to filter prompts
+        """
+        prompts = self.all_acts
+        
+        # Create a fire table! 🔥
+        table = Table(
+            title="🚀 Awesome Prompts Collection",
+            show_header=True,
+            header_style="bold magenta"
+        )
+        table.add_column("Index", style="cyan", justify="right")
+        table.add_column("Name", style="green")
+        table.add_column("Preview", style="yellow")
+        
+        for i, (key, value) in enumerate(prompts.items()):
+            if isinstance(key, int):
+                continue  # Skip numeric keys as they're duplicates
+                
+            # Filter by search term if provided
+            if search and search.lower() not in key.lower() and \
+               search.lower() not in value.lower():
+                continue
+                
+            preview = value[:50] + "..." if len(value) > 50 else value
+            table.add_row(str(i), str(key), preview)
+        
+        console.print(table)
+    
+    def get_random_act(self) -> Optional[str]:
+        """Get a random prompt for that surprise factor! 🎲"""
+        import random
+        prompts = self.all_acts
+        string_keys = [k for k in prompts.keys() if isinstance(k, str)]
+        if not string_keys:
+            return None
+        return prompts[random.choice(string_keys)]
+
+if __name__ == "__main__":
+    # Quick demo of the features! 🚀
+    prompts = AwesomePrompts()
+    prompts.update_prompts_from_online()
+    prompts.show_acts()
+    
+    # Add a test prompt
+    prompts.add_prompt("test_prompt", "This is a test prompt! 🔥")
+    
+    # Show the new prompt
+    print("\nTest Prompt:", prompts.get_act("test_prompt"))
+    
+    # Clean up
+    prompts.delete_prompt("test_prompt")