webscout 8.2.7__py3-none-any.whl → 8.2.9__py3-none-any.whl

webscout/Extra/autocoder/autocoder.py

@@ -0,0 +1,1105 @@
+"""RawDog module for generating and auto-executing Python scripts in the CLI."""
+
+import os
+import re
+import sys
+import queue
+import tempfile
+import threading
+import subprocess
+from typing import Optional, Generator, List, Tuple, Dict, Any, NamedTuple
+from rich.panel import Panel
+from rich.syntax import Syntax
+from rich.console import Console
+from rich.markdown import Markdown
+from rich.table import Table
+from rich.theme import Theme
+from rich.live import Live
+from rich.box import ROUNDED
+from .autocoder_utiles import get_intro_prompt
+# Initialize LitLogger with custom format and colors
+default_path = tempfile.mkdtemp(prefix="webscout_autocoder")
+
+# Custom theme for consistent styling
+CUSTOM_THEME = Theme({
+    "info": "cyan",
+    "warning": "yellow",
+    "error": "red bold",
+    "success": "green",
+    "code": "blue",
+    "output": "white",
+})
+
+console = Console(theme=CUSTOM_THEME)
+class CommandResult(NamedTuple):
+    """Result of a system command execution."""
+    success: bool
+    stdout: str
+    stderr: str
+
+def run_system_command(
+    command: str,
+    exit_on_error: bool = False,
+    stdout_error: bool = False,
+    help: Optional[str] = None
+) -> Tuple[bool, CommandResult]:
+    """Execute a system command and return the result.
+
+    Args:
+        command (str): Command to execute
+        exit_on_error (bool): Whether to exit on error. Defaults to False.
+        stdout_error (bool): Whether to include stdout in error messages. Defaults to False.
+        help (str, optional): Help message for errors. Defaults to None.
+
+    Returns:
+        Tuple[bool, CommandResult]: Success status and command result containing stdout/stderr
+    """
+    try:
+        # Execute command and capture output
+        process = subprocess.Popen(
+            command,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            shell=True,
+            text=True
+        )
+
+        # Get stdout and stderr
+        stdout, stderr = process.communicate()
+        success = process.returncode == 0
+
+        # Create result object
+        result = CommandResult(
+            success=success,
+            stdout=stdout.strip() if stdout else "",
+            stderr=stderr.strip() if stderr else ""
+        )
+
+        # Handle errors if needed
+        if not success and exit_on_error:
+            error_msg = stderr if stderr else stdout if stdout_error else "Command failed"
+            if help:
+                error_msg += f"\n{help}"
+            sys.exit(error_msg)
+
+        return success, result
+
+    except Exception as e:
+        # Handle execution errors
+        error_msg = str(e)
+        if help:
+            error_msg += f"\n{help}"
+
+        if exit_on_error:
+            sys.exit(error_msg)
+
+        return False, CommandResult(success=False, stdout="", stderr=error_msg)
+
+
+class AutoCoder:
+    """Generate and auto-execute Python scripts in the CLI with advanced error handling and retry logic.
+
+    This class provides:
+    - Automatic code generation
+    - Script execution with safety checks
+    - Advanced error handling and retries
+    - Beautiful logging with rich console
+    - Execution result capture and display
+
+    Examples:
+        >>> coder = AutoCoder()
+        >>> coder.execute("Get system info")
+        Generating system info script...
+        Script executed successfully!
+    """
+
+    def __init__(
+        self,
+        quiet: bool = False,
+        internal_exec: bool = False,
+        confirm_script: bool = False,
+        interpreter: str = "python",
+        prettify: bool = True,
+        path_to_script: str = "",
+        max_retries: int = 3,
+        ai_instance = None
+    ):
+        """Initialize AutoCoder instance.
+
+        Args:
+            quiet (bool): Flag to control logging. Defaults to False.
+            internal_exec (bool): Execute scripts with exec function. Defaults to False.
+            confirm_script (bool): Give consent to scripts prior to execution. Defaults to False.
+            interpreter (str): Python's interpreter name. Defaults to "python".
+            prettify (bool): Prettify the code on stdout. Defaults to True.
+            path_to_script (str): Path to save generated scripts. Defaults to "".
+            max_retries (int): Maximum number of retry attempts. Defaults to 3.
+            ai_instance: AI instance for error correction. Defaults to None.
+        """
+        self.internal_exec = internal_exec
+        self.confirm_script = confirm_script
+        self.quiet = quiet
+        self.interpreter = interpreter
+        self.prettify = prettify
+        self.path_to_script = path_to_script or os.path.join(default_path, "execute_this.py")
+        self.max_retries = max_retries
+        self.tried_solutions = set()
+        self.ai_instance = ai_instance
+        self.last_execution_result = ""
+
+        # Get Python version with enhanced logging
+        if self.internal_exec:
+            self.python_version = f"{sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}"
+        else:
+            version_output = run_system_command(
+                f"{self.interpreter} --version",
+                exit_on_error=True,
+                stdout_error=True,
+                help="If you're using Webscout-cli, use the flag '--internal-exec'"
+            )[1].stdout
+            self.python_version = version_output.split(" ")[1]
+
+
+
+    def _extract_code_blocks(self, response: str) -> List[Tuple[str, str]]:
+        """Extract code blocks from a response string.
+
+        Args:
+            response (str): Response string containing code blocks
+
+        Returns:
+            List[Tuple[str, str]]: List of (code_type, code) tuples
+        """
+        blocks = []
+
+        # First try to find code blocks with explicit language tags
+        pattern = r"```(\w+)\n(.*?)```"
+        matches = re.finditer(pattern, response, re.DOTALL)
+
+        for match in matches:
+            code_type = match.group(1).lower()
+            code = match.group(2).strip()
+
+            # Check if this is a shell command (starts with !)
+            if code_type == 'bash' or code_type == 'shell' or code.startswith('!'):
+                blocks.append(('shell', code))
+            else:
+                blocks.append((code_type, code))
+
+        # If no explicit code blocks found with language tags, try generic code blocks
+        if not blocks:
+            pattern = r"```(.*?)```"
+            matches = re.finditer(pattern, response, re.DOTALL)
+            for match in matches:
+                code = match.group(1).strip()
+
+                # Check if this is a shell command (starts with !)
+                if code.startswith('!'):
+                    blocks.append(('shell', code))
+                else:
+                    blocks.append(('python', code))
+
+        # If still no code blocks found, treat as raw Python code
+        if not blocks:
+            lines = [line.strip() for line in response.split('\n') if line.strip()]
+            if lines:
+                # Check if this is a shell command (starts with !)
+                if lines[0].startswith('!'):
+                    blocks.append(('shell', '\n'.join(lines)))
+                else:
+                    blocks.append(('python', '\n'.join(lines)))
+
+        return blocks
+
+    def _execute_code_block(self, code_type: str, code: str, ai_instance=None) -> Tuple[bool, str]:
+        """Execute a code block.
+
+        Args:
+            code_type (str): Type of code block ('python' or 'shell')
+            code (str): Code to execute
+            ai_instance: Optional AI instance for error correction
+
+        Returns:
+            Tuple[bool, str]: (Success status, Error message or execution result)
+        """
+        try:
+            # Handle shell commands (starting with !)
+            if code_type == 'shell':
+                # Remove the leading '!' from each line
+                shell_commands = []
+                for line in code.split('\n'):
+                    if line.startswith('!'):
+                        shell_commands.append(line[1:].strip())  # Remove the '!' and any leading whitespace
+                    else:
+                        shell_commands.append(line.strip())
+
+                # Execute each shell command
+                overall_success = True
+                overall_result = []
+
+                # Display the shell command in Jupyter-style UI
+                if self.prettify:
+                    # Format the command for display
+                    cmd_display = '\n'.join([f"!{cmd}" for cmd in shell_commands if cmd])
+                    syntax = Syntax(cmd_display, "bash", theme="monokai", line_numbers=True)
+                    console.print(Panel(
+                        syntax,
+                        title="[bold blue]In [1]:[/bold blue]",
+                        border_style="blue",
+                        expand=True,
+                        box=ROUNDED
+                    ))
+
+                for cmd in shell_commands:
+                    if not cmd:  # Skip empty commands
+                        continue
+
+                    success, result = run_system_command(cmd)
+
+                    if success:
+                        if result.stdout:
+                            overall_result.append(result.stdout)
+
+                            # Display the output in Jupyter-style UI
+                            if self.prettify:
+                                console.print(Panel(
+                                    result.stdout,
+                                    title="[bold red]Out [1]:[/bold red]",
+                                    border_style="red",
+                                    expand=True,
+                                    padding=(0, 1),
+                                    box=ROUNDED
+                                ))
+
+                        self.last_execution_result = '\n'.join(overall_result)
+                    else:
+                        error_msg = result.stderr if result.stderr else f"Command failed: {cmd}"
+
+                        # Display the error in Jupyter-style UI
+                        if self.prettify:
+                            console.print(Panel(
+                                f"Error: {error_msg}",
+                                title="[bold red]Out [1]:[/bold red]",
+                                border_style="red",
+                                expand=True,
+                                padding=(0, 1),
+                                box=ROUNDED
+                            ))
+
+                        return False, error_msg
+
+                return True, self.last_execution_result
+            else:
+                # Handle Python code
+                result = self._execute_with_retry(code, ai_instance)
+                if result is None:
+                    return True, self.last_execution_result
+                return False, result
+        except Exception as e:
+            return False, str(e)
+
+    def _format_output_panel(self, code: str, output_lines: list) -> Panel:
+        """Format code and output into a single panel.
+
+        Args:
+            code (str): The code that was executed
+            output_lines (list): List of output lines
+
+        Returns:
+            Panel: Formatted panel with code and output
+        """
+        # Format output
+        output_text = "\n".join(output_lines) if output_lines else "Running..."
+
+        # Create panel with Jupyter-like styling
+        panel = Panel(
+            output_text,
+            title="[bold red]Out [1]:[/bold red]",
+            border_style="red",
+            expand=True,
+            padding=(0, 1),
+            box=ROUNDED
+        )
+
+        return panel
+
+    def _format_result_panel(self, output: str) -> Panel:
+        """Format execution result into a panel.
+
+        Args:
+            output (str): Execution output text
+
+        Returns:
+            Panel: Formatted panel with execution result
+        """
+        # Create panel with Jupyter-like styling
+        panel = Panel(
+            output,
+            title="[bold red]Out [1]:[/bold red]",
+            border_style="red",
+            expand=True,
+            padding=(0, 1),
+            box=ROUNDED
+        )
+
+        return panel
+
+    def _stream_output(self, process: subprocess.Popen) -> Generator[str, None, None]:
+        """Stream output from a subprocess in realtime.
+
+        Args:
+            process: Subprocess to stream output from
+
+        Yields:
+            str: Lines of output
+        """
+        # Stream stdout
+        output_lines = []
+        for line in process.stdout:
+            decoded_line = line.decode('utf-8').strip() if isinstance(line, bytes) else line.strip()
+            if decoded_line:
+                output_lines.append(decoded_line)
+                yield decoded_line
+
+        # Check stderr
+        error = process.stderr.read() if process.stderr else None
+        if error:
+            error_str = error.decode('utf-8').strip() if isinstance(error, bytes) else error.strip()
+            if error_str:
+                yield f"Error: {error_str}"
+                output_lines.append(f"Error: {error_str}")
+
+        # Store the full execution result
+        self.last_execution_result = "\n".join(output_lines)
+
+    def _execute_with_retry(self, code: str, ai_instance=None) -> Optional[str]:
+        """Execute code with retry logic and error correction.
+
+        Args:
+            code (str): Code to execute
+            ai_instance: Optional AI instance for error correction
+
+        Returns:
+            Optional[str]: Error message if execution failed, None if successful
+        """
+        last_error = None
+        retries = 0
+
+        # Add the solution to tried solutions
+        self.tried_solutions.add(code)
+
+        # Print the code first
+        if self.prettify:
+            syntax = Syntax(code, "python", theme="monokai", line_numbers=True)
+            console.print(Panel(
+                syntax,
+                title="[bold blue]In [1]:[/bold blue]",
+                border_style="blue",
+                expand=True,
+                box=ROUNDED
+            ))
+
+        while retries < self.max_retries:
+            try:
+                if self.path_to_script:
+                    script_dir = os.path.dirname(self.path_to_script)
+                    if script_dir:
+                        os.makedirs(script_dir, exist_ok=True)
+                    with open(self.path_to_script, "w", encoding="utf-8") as f:
+                        f.write(code)
+
+                if self.internal_exec:
+                    # Create StringIO for output capture
+                    import io
+                    import sys
+                    stdout = io.StringIO()
+                    stderr = io.StringIO()
+
+                    # Create a queue for realtime output
+                    output_queue = queue.Queue()
+                    output_lines = []
+
+                    def execute_code():
+                        try:
+                            # Create a local namespace
+                            local_namespace: Dict[str, Any] = {}
+
+                            # Redirect stdout/stderr
+                            sys.stdout = stdout
+                            sys.stderr = stderr
+
+                            # Execute the code
+                            exec(code, globals(), local_namespace)
+
+                            # Get any output
+                            output = stdout.getvalue()
+                            error = stderr.getvalue()
+
+                            if error:
+                                output_queue.put(("error", error))
+                            if output:
+                                output_queue.put(("output", output))
+
+                        except Exception as e:
+                            output_queue.put(("error", str(e)))
+                        finally:
+                            # Restore stdout/stderr
+                            sys.stdout = sys.__stdout__
+                            sys.stderr = sys.__stderr__
+
+                    # Create and start execution thread
+                    thread = threading.Thread(target=execute_code)
+                    thread.daemon = True  # Make thread daemon to avoid hanging
+                    thread.start()
+
+                    # Display output in realtime
+                    with Live(auto_refresh=True) as live:
+                        timeout_counter = 0
+                        while thread.is_alive() or not output_queue.empty():
+                            try:
+                                msg_type, content = output_queue.get(timeout=0.1)
+                                if content:
+                                    new_lines = content.splitlines()
+                                    output_lines.extend(new_lines)
+                                    live.update(self._format_output_panel(code, output_lines))
+                                    live.refresh()
+                                output_queue.task_done()
+                            except queue.Empty:
+                                timeout_counter += 1
+                                # Refresh the display to show it's still running
+                                if timeout_counter % 10 == 0:  # Refresh every ~1 second
+                                    live.update(self._format_output_panel(code, output_lines))
+                                    live.refresh()
+                                if timeout_counter > 100 and thread.is_alive():  # ~10 seconds
+                                    output_lines.append("Warning: Execution taking longer than expected...")
+                                    live.update(self._format_output_panel(code, output_lines))
+                                    live.refresh()
+                                continue
+
+                    # Wait for thread to complete with timeout
+                    thread.join(timeout=30)  # 30 second timeout
+                    if thread.is_alive():
+                        output_lines.append("Error: Execution timed out after 30 seconds")
+                        raise TimeoutError("Execution timed out after 30 seconds")
+
+                    # Check for any final errors
+                    error = stderr.getvalue()
+                    if error:
+                        raise Exception(error)
+
+                    # Store the full execution result
+                    self.last_execution_result = stdout.getvalue()
+
+                else:
+                    try:
+                        process = subprocess.Popen(
+                            [self.interpreter, self.path_to_script],
+                            stdout=subprocess.PIPE,
+                            stderr=subprocess.PIPE,
+                            text=True,  # Use text mode to avoid encoding issues
+                            bufsize=1,
+                        )
+
+                        output_lines = []
+                        # Stream output in realtime
+                        with Live(auto_refresh=True) as live:
+                            for line in self._stream_output(process):
+                                output_lines.append(line)
+                                live.update(self._format_output_panel(code, output_lines))
+                                live.refresh()
+
+                        process.wait(timeout=30)  # 30 second timeout
+
+                        if process.returncode != 0:
+                            # Try to read more detailed error information
+                            if process.stderr:
+                                error = process.stderr.read()
+                                error_str = error.strip() if error else ""
+                                if error_str:
+                                    raise Exception(error_str)
+                            raise Exception(f"Process exited with code {process.returncode}")
+
+                        # Store the full execution result
+                        self.last_execution_result = "\n".join(output_lines)
+
+                    except subprocess.TimeoutExpired:
+                        # Handle the case where the process times out
+                        if process:
+                            process.kill()
+                        raise TimeoutError("Execution timed out after 30 seconds")
+
+                return None
+
+            except Exception as e:
+                last_error = e
+                if retries < self.max_retries - 1 and ai_instance:
+                    try:
+                        # First try to handle import errors
+                        if isinstance(e, ImportError):
+                            fixed_code = self._handle_import_error(e, code)
+                            if fixed_code:
+                                code = fixed_code
+                                retries += 1
+                                continue
+
+                        # Get error context and try to fix the specific error
+                        error_context = self._get_error_context(e, code)
+                        fixed_response = ai_instance.chat(error_context)
+                        fixed_code = self._extract_code_from_response(fixed_response)
+
+                        if not fixed_code:
+                            # If no code found, try a more general approach
+                            general_context = f"""
+The code failed with error: {str(e)}
+
+Original Code:
+```python
+{code}
+```
+
+Please provide a complete, corrected version of the code that handles this error. The code should:
+1. Handle any potential encoding issues
+2. Include proper error handling
+3. Use appropriate libraries and imports
+4. Be compatible with the current Python environment
+5. Fix the specific error: {str(e)}
+
+Provide only the corrected code without any explanation.
+"""
+                            fixed_response = ai_instance.chat(general_context)
+                            fixed_code = self._extract_code_from_response(fixed_response)
+
+                            if not fixed_code:
+                                break
+
+                        if self._is_similar_solution(fixed_code):
+                            # If solution is too similar, try a different approach
+                            different_context = f"""
+Previous solutions were not successful. The code failed with error: {str(e)}
+
+Original Code:
+```python
+{code}
+```
+
+Please provide a significantly different approach to solve this problem. Consider:
+1. Using alternative libraries or methods
+2. Implementing a different algorithm
+3. Adding more robust error handling
+4. Using a different encoding or data handling approach
+5. Specifically address the error: {str(e)}
+
+Provide only the corrected code without any explanation.
+"""
+                            fixed_response = ai_instance.chat(different_context)
+                            fixed_code = self._extract_code_from_response(fixed_response)
+
+                            if self._is_similar_solution(fixed_code):
+                                break
+
+                        # Update code and continue with retry
+                        code = fixed_code
+                        self.tried_solutions.add(code)
+                        retries += 1
+                        continue
+
+                    except Exception as ai_error:
+                        console.print(f"Error during AI correction: {str(ai_error)}", style="error")
+                        break
+                break
+
+        return str(last_error) if last_error else "Unknown error occurred"
+
+    def execute(self, prompt: str, ai_instance=None) -> bool:
+        """Execute the given prompt using the appropriate executor.
+
+        Args:
+            prompt (str): Prompt to execute
+            ai_instance: Optional AI instance for error correction
+
+        Returns:
+            bool: True if execution was successful, False otherwise
+        """
+        try:
+            # Check if this is a direct shell command (starts with !)
+            if prompt.strip().startswith('!'):
+                # Handle shell command
+                cmd = prompt.strip()[1:].strip()  # Remove the '!' and any leading whitespace
+
+                # Display the shell command in Jupyter-style UI
+                if self.prettify:
+                    syntax = Syntax(f"!{cmd}", "bash", theme="monokai", line_numbers=True)
+                    console.print(Panel(
+                        syntax,
+                        title="[bold blue]In [1]:[/bold blue]",
+                        border_style="blue",
+                        expand=True,
+                        box=ROUNDED
+                    ))
+
+                success, result = run_system_command(cmd)
+
+                if success:
+                    if result.stdout:
+                        # Display the output in Jupyter-style UI
+                        if self.prettify:
+                            console.print(Panel(
+                                result.stdout,
+                                title="[bold red]Out [1]:[/bold red]",
+                                border_style="red",
+                                expand=True,
+                                padding=(0, 1),
+                                box=ROUNDED
+                            ))
+                        else:
+                            console.print(result.stdout, style="output")
+                    self.last_execution_result = result.stdout
+                    return True
+                else:
+                    error_msg = result.stderr if result.stderr else f"Command failed: {cmd}"
+                    # Display the error in Jupyter-style UI
+                    if self.prettify:
+                        console.print(Panel(
+                            f"Error: {error_msg}",
+                            title="[bold red]Out [1]:[/bold red]",
+                            border_style="red",
+                            expand=True,
+                            padding=(0, 1),
+                            box=ROUNDED
+                        ))
+                    else:
+                        console.print(error_msg, style="error")
+                    return False
+
+            # Extract code blocks
+            code_blocks = self._extract_code_blocks(prompt)
+            if not code_blocks:
+                console.print("No executable code found in the prompt", style="warning")
+                return False
+
+            # Execute each code block
+            overall_success = True
+            for code_type, code in code_blocks:
+                success, result = self._execute_code_block(code_type, code, ai_instance)
+
+                if not success:
+                    console.print(f"Execution failed: {result}", style="error")
+                    overall_success = False
+
+            return overall_success
+
+        except Exception as e:
+            console.print(f"Error in execution: {str(e)}", style="error")
+            return False
+
+    def _extract_code_from_response(self, response: str) -> str:
+        """Extract code from AI response.
+
+        Args:
+            response (str): AI response containing code blocks
+
+        Returns:
+            str: Extracted code from the first code block
+        """
+        if not response:
+            return ""
+
+        # First try to find code blocks with explicit language tags
+        code_blocks = self._extract_code_blocks(response)
+        if code_blocks:
+            # Return the content of the first code block
+            return code_blocks[0][1]
+
+        # If no code blocks found, try to find raw Python code or shell commands
+        lines = []
+        for line in response.split('\n'):
+            line = line.strip()
+            if not line:
+                continue
+
+            # Skip markdown headers and other non-code lines
+            if line.startswith(('#', '```', '---', '===', '>>>')):
+                continue
+
+            # Skip common non-code lines
+            if any(line.startswith(prefix) for prefix in ['Please', 'Here', 'The', 'This', 'You']):
+                continue
+
+            lines.append(line)
+
+        if lines:
+            return '\n'.join(lines)
+
+        return ""
+
+    def _get_error_context(self, error: Exception, code: str) -> str:
+        """Create context about the error for AI correction.
+
+        Args:
+            error (Exception): The caught exception
+            code (str): The code that caused the error
+
+        Returns:
+            str: Formatted error context for AI
+        """
+        error_type = type(error).__name__
+        error_msg = str(error)
+
+        # Get Python version and environment info
+        python_version = f"{sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}"
+        platform = sys.platform
+
+        # Get the line number where the error occurred if available
+        import traceback
+        tb = traceback.extract_tb(error.__traceback__)
+        line_info = ""
+        if tb:
+            line_info = f"\nError occurred at line {tb[-1].lineno}"
+
+        return f"""
+The code failed with error:
+Error Type: {error_type}
+Error Message: {error_msg}{line_info}
+
+Environment:
+Python Version: {python_version}
+Platform: {platform}
+
+Original Code:
+```python
+{code}
+```
+
+Please fix the code to handle this error. The solution should:
+1. Address the specific error: {error_msg}
+2. Be compatible with Python {python_version}
+3. Work on {platform}
+4. Include proper error handling
+5. Use appropriate libraries and imports
+
+Provide only the corrected code without any explanation.
+"""
+
+    def _handle_import_error(self, error: ImportError, code: str) -> Optional[str]:
+        """Handle missing package errors by attempting to install them.
+
+        Args:
+            error (ImportError): The import error
+            code (str): The code that caused the error
+
+        Returns:
+            Optional[str]: Fixed code or None if installation failed
+        """
+        try:
+            missing_package = str(error).split("'")[1] if "'" in str(error) else str(error).split("No module named")[1].strip()
+            missing_package = missing_package.replace("'", "").strip()
+
+            console.print(f"Installing missing package: {missing_package}", style="info")
+            result = subprocess.run(
+                [sys.executable, "-m", "pip", "install", missing_package],
+                capture_output=True,
+                text=True
+            )
+            if result.returncode == 0:
+                console.print(f"Successfully installed {missing_package}", style="success")
+                return code  # Retry with same code after installing package
+            else:
+                raise Exception(f"Failed to install {missing_package}: {result.stderr}")
+        except Exception as e:
+            console.print(f"Error installing package: {str(e)}", style="error")
+            return None
+
+    def _is_similar_solution(self, new_code: str, threshold: float = 0.8) -> bool:
+        """Check if the new solution is too similar to previously tried ones.
+
+        Args:
+            new_code (str): New solution to check
+            threshold (float): Similarity threshold (0-1). Defaults to 0.8.
+
+        Returns:
+            bool: True if solution is too similar to previous attempts
+        """
+        import difflib
+
+        def normalize_code(code: str) -> str:
+            lines = [line.split('#')[0].strip() for line in code.split('\n')]
+            return '\n'.join(line for line in lines if line)
+
+        new_code_norm = normalize_code(new_code)
+
+        for tried_code in self.tried_solutions:
+            tried_code_norm = normalize_code(tried_code)
+            similarity = difflib.SequenceMatcher(None, new_code_norm, tried_code_norm).ratio()
+            if similarity > threshold:
+                return True
+        return False
+
+    def main(self, response: str) -> Optional[str]:
+        """Execute code with error correction.
+
+        Args:
+            response (str): AI response containing code
+
+        Returns:
+            Optional[str]: Error message if execution failed, None if successful
+        """
+        if not response:
+            return "No response provided"
+
+        # Check if this is a shell command (starts with !)
+        if response.strip().startswith('!'):
+            # Handle shell command
+            cmd = response.strip()[1:].strip()  # Remove the '!' and any leading whitespace
+
+            # Display the shell command in Jupyter-style UI
+            if self.prettify:
+                syntax = Syntax(f"!{cmd}", "bash", theme="monokai", line_numbers=True)
+                console.print(Panel(
+                    syntax,
+                    title="[bold blue]In [1]:[/bold blue]",
+                    border_style="blue",
+                    expand=True,
+                    box=ROUNDED
+                ))
+
+            success, result = run_system_command(cmd)
+
+            if success:
+                if result.stdout:
+                    # Display the output in Jupyter-style UI
+                    if self.prettify:
+                        console.print(Panel(
+                            result.stdout,
+                            title="[bold red]Out [1]:[/bold red]",
+                            border_style="red",
+                            expand=True,
+                            padding=(0, 1),
+                            box=ROUNDED
+                        ))
+                self.last_execution_result = result.stdout
+                return None
+            else:
+                error_msg = result.stderr if result.stderr else f"Command failed: {cmd}"
+                # Display the error in Jupyter-style UI
+                if self.prettify:
+                    console.print(Panel(
+                        f"Error: {error_msg}",
+                        title="[bold red]Out [1]:[/bold red]",
+                        border_style="red",
+                        expand=True,
+                        padding=(0, 1),
+                        box=ROUNDED
+                    ))
+                else:
+                    console.print(error_msg, style="error")
+                return error_msg
+
+        # Extract code blocks
+        code_blocks = self._extract_code_blocks(response)
+        if code_blocks:
+            code_type, code = code_blocks[0]
+
+            # Handle shell commands
+            if code_type == 'shell':
+                success, result = self._execute_code_block(code_type, code)
+                if success:
+                    return None
+                else:
+                    # Error is already displayed in _execute_code_block
+                    return result
+
+        # Handle regular Python code
+        code = self._extract_code_from_response(response)
+        if not code:
+            return "No executable code found in the response"
+
+        ai_instance = self.ai_instance or globals().get('ai')
+
+        if not ai_instance:
+            console.print("AI instance not found, error correction disabled", style="warning")
+            try:
+                if self.path_to_script:
+                    script_dir = os.path.dirname(self.path_to_script)
+                    if script_dir:
+                        os.makedirs(script_dir, exist_ok=True)
+                    with open(self.path_to_script, "w", encoding="utf-8") as f:
+                        f.write(code)
+
+                if self.internal_exec:
+                    console.print("[INFO] Executing code internally", style="info")
+                    # Create a local namespace
+                    local_namespace: Dict[str, Any] = {}
+
+                    # Capture stdout
+                    import io
+                    old_stdout = sys.stdout
+                    captured_output = io.StringIO()
+                    sys.stdout = captured_output
+
+                    # Execute the code
+                    try:
+                        exec(code, globals(), local_namespace)
+                        # Capture the result
+                        self.last_execution_result = captured_output.getvalue()
+                    finally:
+                        # Restore stdout
+                        sys.stdout = old_stdout
+                else:
+                    console.print("[INFO] Executing code as external process", style="info")
+                    result = subprocess.run(
+                        [self.interpreter, self.path_to_script],
+                        capture_output=True,
+                        text=True
+                    )
+                    self.last_execution_result = result.stdout
+
+                    if result.returncode != 0:
+                        raise Exception(result.stderr or result.stdout)
+
+                return None
+            except Exception as e:
+                error_msg = f"Execution error: {str(e)}"
+                console.print(error_msg, style="error")
+                return error_msg
+
+        result = self._execute_with_retry(code, ai_instance)
+        return result
+
+    @property
+    def intro_prompt(self) -> str:
+        """Get the introduction prompt.
+
+        Returns:
+            str: Introduction prompt
+        """
+        return get_intro_prompt()
+
+    def log(self, message: str, category: str = "info"):
+        """RawDog logger
+
+        Args:
+            message (str): Log message
+            category (str, optional): Log level. Defaults to 'info'.
+        """
+        if self.quiet:
+            return
+
+        message = "[Webscout] - " + message
+        if category == "error":
+            console.print(f"[ERROR] {message}", style="error")
+        else:
+            console.print(message, style=category)
+
+    def stdout(self, message: str, style: str = "info") -> None:
+        """Enhanced stdout with Rich formatting.
+
+        Args:
+            message (str): Text to be printed
+            style (str, optional): Style to apply. Defaults to "info".
+        """
+        if not self.prettify:
+            print(message)
+            return
+
+        if message.startswith("```") and message.endswith("```"):
+            # Handle code blocks
+            code = message.strip("`").strip()
+            syntax = Syntax(code, "python", theme="monokai", line_numbers=True)
+            console.print(Panel(syntax, title="Code", border_style="blue"))
+        elif "```python" in message:
+            # Handle markdown code blocks
+            md = Markdown(message)
+            console.print(md)
+        else:
+            # Handle regular text with optional styling
+            console.print(message, style=style)
+
+    def print_code(self, code: str, title: str = "Generated Code") -> None:
+        """Print code with syntax highlighting and panel.
+
+        Args:
+            code (str): Code to print
+            title (str, optional): Panel title. Defaults to "Generated Code".
+        """
+        if self.prettify:
+            syntax = Syntax(code, "python", theme="monokai", line_numbers=True)
+            console.print(Panel(
+                syntax,
+                title=f"[bold blue]In [1]:[/bold blue]",
+                border_style="blue",
+                expand=True,
+                box=ROUNDED
+            ))
+        else:
+            print(f"\n{title}:")
+            print(code)
+
+    def print_output(self, output: str, style: str = "output") -> None:
+        """Print command output with optional styling.
+
+        Args:
+            output (str): Output to print
+            style (str, optional): Style to apply. Defaults to "output".
+        """
+        if self.prettify:
+            # Try to detect if output is Python code
+            try:
+                # If it looks like Python code, syntax highlight it
+                compile(output, '<string>', 'exec')
+                syntax = Syntax(output, "python", theme="monokai", line_numbers=False)
+                formatted_output = syntax
+            except SyntaxError:
+                # If not Python code, treat as plain text
+                formatted_output = output
+
+            # Use the style parameter for the panel border
+            console.print(Panel(
+                formatted_output,
+                title="[bold red]Out [1]:[/bold red]",
+                border_style=style if style != "output" else "red",
+                expand=True,
+                padding=(0, 1),
+                box=ROUNDED
+            ))
+        else:
+            print("\nOutput:")
+            print(output)
+
+    def print_error(self, error: str) -> None:
+        """Print error message with styling.
+
+        Args:
+            error (str): Error message to print
+        """
+        if self.prettify:
+            console.print(f"\n Error:", style="error bold")
+            console.print(error, style="error")
+        else:
+            print("\nError:")
+            print(error)
+
+    def print_table(self, headers: list, rows: list) -> None:
+        """Print data in a formatted table.
+
+        Args:
+            headers (list): Table headers
+            rows (list): Table rows
+        """
+        if not self.prettify:
+            # Simple ASCII table
+            print("\n" + "-" * 80)
+            print("| " + " | ".join(headers) + " |")
+            print("-" * 80)
+            for row in rows:
+                print("| " + " | ".join(str(cell) for cell in row) + " |")
+            print("-" * 80)
+            return
+
+        table = Table(show_header=True, header_style="bold cyan")
+        for header in headers:
+            table.add_column(header)
+
+        for row in rows:
+            table.add_row(*[str(cell) for cell in row])
+
+        console.print(table)