diff --git a/README.md b/README.md
index a23de80..ec5c7ce 100644
--- a/README.md
+++ b/README.md
@@ -119,4 +119,7 @@ Thank you for considering contributing! Please follow these steps:
 `LinkedIn` - [Visit](https://linkedin.com/in/anshsoni) </br>
 `Follow Us` - [Visit](https://linkedin.com/company/py-shell)
 
+### Recent updates check:
+updates_to_read.md
+
 ## Thankyou 😀<br/>
diff --git a/ai_config.json b/ai_config.json
new file mode 100644
index 0000000..3ccf8ab
--- /dev/null
+++ b/ai_config.json
@@ -0,0 +1,4 @@
+{
+    "api_key": "123",
+    "smart_suggestions": true
+}
\ No newline at end of file
diff --git a/ai_panel.py b/ai_panel.py
new file mode 100644
index 0000000..88e6d0f
--- /dev/null
+++ b/ai_panel.py
@@ -0,0 +1,99 @@
+import json
+import os
+from prompt_toolkit.shortcuts import checkboxlist_dialog, radiolist_dialog
+from rich.console import Console
+
+console = Console()
+AI_CONFIG_FILE = "ai_config.json"
+
+def load_ai_config():
+    """Loads the AI feature configuration from a JSON file."""
+    if os.path.exists(AI_CONFIG_FILE):
+        try:
+            with open(AI_CONFIG_FILE, 'r') as f:
+                return json.load(f)
+        except (json.JSONDecodeError, IOError):
+            pass
+    return {"smart_suggestions": False}
+
+def save_ai_config(config):
+    """Saves the AI feature configuration to a JSON file."""
+    with open(AI_CONFIG_FILE, 'w') as f:
+        json.dump(config, f, indent=4)
+
+def show_config_panel():
+    """Shows a checklist to toggle AI features ON or OFF."""
+    config = load_ai_config()
+    default_values = [key for key, value in config.items() if value]
+
+    results = checkboxlist_dialog(
+        title="⚙️ AI Configuration",
+        text="Use SPACE to toggle features ON/OFF. Press ENTER to save.",
+        values=[
+            ("smart_suggestions", "💡 Live Smart Suggestions"),
+        ],
+        default_values=default_values
+    ).run()
+
+    if results is not None:
+        config["smart_suggestions"] = "smart_suggestions" in results
+        save_ai_config(config)
+        status = "ON" if config["smart_suggestions"] else "OFF"
+        console.print(f"\n[bold green]Live Smart Suggestions are now {status}[/bold green]")
+
+def show_ai_features():
+    """Shows the AI features menu."""
+    from features import nl_to_code, error_explainer, snippet_search, code_refactor
+    
+    AI_FEATURES = [
+        ("nl", "🧠 NL to Code", nl_to_code.run),
+        ("explain", "❌ Error Explainer", error_explainer.run),
+        ("snippet", "📚 Snippet Search", snippet_search.run),
+        ("refactor", "🧹 Code Refactor", code_refactor.run),
+        ("back", "↩️ Back to Main Menu", None)
+    ]
+    
+    while True:
+        choice = radiolist_dialog(
+            title="🤖 AI Features",
+            text="Select an AI feature to run:",
+            values=[(key, label) for key, label, _ in AI_FEATURES],
+        ).run()
+
+        if choice is None or choice == "back":
+            break
+
+        # Find and run the selected feature
+        for key, label, func in AI_FEATURES:
+            if key == choice and func:
+                try:
+                    func()
+                except Exception as e:
+                    print(f"[Error in {label}]: {e}")
+                input("\nPress Enter to return to the AI features menu...")
+                break
+
+def show_ai_panel():
+    """Main AI panel with options to configure or run features."""
+    while True:
+        choice = radiolist_dialog(
+            title="🤖 PyShell AI Panel",
+            text="Choose an option:",
+            values=[
+                ("features", "🚀 Run AI Features"),
+                ("config", "⚙️ Configure AI Settings"),
+                ("exit", "↩️ Return to Shell")
+            ],
+        ).run()
+
+        if choice == "features":
+            show_ai_features()
+        elif choice == "config":
+            show_config_panel()
+        elif choice == "exit" or choice is None:
+            break
+
+def is_feature_enabled(feature_name):
+    """Checks if a specific AI feature is enabled in the config."""
+    config = load_ai_config()
+    return config.get(feature_name, False) 
\ No newline at end of file
diff --git a/config.py b/config.py
index bc7080c..c8b2761 100644
--- a/config.py
+++ b/config.py
@@ -1 +1 @@
-current_terminal_layout = 8
+current_terminal_layout = 2
diff --git a/equations.py b/equations.py
index a1d5c99..cc8c463 100644
--- a/equations.py
+++ b/equations.py
@@ -6,6 +6,11 @@
 from sympy.parsing.sympy_parser import parse_expr
 import re
 from sympy.abc import x
+import time
+import msvcrt
+from rich.table import Table
+from menu_base import MojiSwitchMenu
+from statistics_menu import show_statistics_menu
 
 console = Console()
 
@@ -119,4 +124,151 @@ def solve_differential(self, args):
                 f"[red]❌ Error:[/red] {str(e)}\n"
                 "Please ensure your equation is in the correct format.",
                 title="⚠️ Invalid Input", border_style="red"
-            ))
\ No newline at end of file
+            ))
+
+def show_equations_menu():
+    # Define options for equation operations
+    options = [
+        ("➕ Basic Math", "basic"),
+        ("📐 Algebra", "algebra"),
+        ("📊 Calculus", "calculus"),
+        ("📈 Statistics", "stats"),
+        ("🔢 Matrix", "matrix")
+    ]
+    
+    def on_execute(state):
+        # Get list of enabled operations
+        enabled_ops = [name for name, value in options if state[value]]
+        if not enabled_ops:
+            console.print("[bold red]No operations selected![/bold red]")
+            return
+            
+        # Animate calculation
+        animate_calculation()
+        
+        # Process each enabled operation
+        results = {}
+        for op in enabled_ops:
+            # Simulate calculation
+            time.sleep(0.5)
+            results[op] = f"Result for {op}"
+            
+        # Display results
+        animate_results_display(results)
+    
+    # Create and run menu
+    menu = MojiSwitchMenu(
+        title="🧮 Equation Operations",
+        options=options,
+        on_execute=on_execute
+    )
+    menu.run()
+
+def display_equation_table(equations):
+    """Display equations in a modern table format"""
+    table = Table(
+        show_header=True,
+        header_style="bold cyan",
+        box=None,
+        padding=(0, 1)
+    )
+    
+    # Add columns
+    table.add_column("No.", style="dim", width=4)
+    table.add_column("Type", style="bold")
+    table.add_column("Description", style="italic")
+    table.add_column("Status", justify="center", width=4)
+    
+    # Add rows with equation types
+    features = [
+        ("1", "Basic Math", "Arithmetic and algebraic operations", "basic"),
+        ("2", "Algebra", "Solve linear and quadratic equations", "algebra"),
+        ("3", "Calculus", "Derivatives and integrals", "calculus"),
+        ("4", "Statistics", "Statistical formulas and calculations", "stats"),
+        ("5", "Matrix", "Matrix operations and determinants", "matrix")
+    ]
+    
+    for no, name, desc, key in features:
+        status = "✅" if equations.get(key, False) else "❌"
+        table.add_row(no, name, desc, status)
+        
+    # Create panel with table
+    panel = Panel(
+        table,
+        title="🧮 Equation Types",
+        border_style="cyan",
+        padding=(1, 2)
+    )
+    
+    console.print(panel)
+
+def animate_calculation():
+    """Animate calculation with a spinning effect"""
+    spinner = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"]
+    console.print("\n")
+    for _ in range(20):  # 2 seconds of animation
+        for char in spinner:
+            console.print(f"\033[A\033[K[bold blue]{char} Calculating...[/bold blue]")
+            time.sleep(0.1)
+    console.print("\n")
+
+def animate_results_display(results):
+    """Animate results display with a fade-in effect"""
+    console.print("\n")
+    for i in range(3):
+        console.print("\033[A\033[K", end="")
+        if i == 0:
+            for key, value in results.items():
+                console.print(f"[grey50]{key}: {value}[/grey50]")
+        elif i == 1:
+            for key, value in results.items():
+                console.print(f"[bold blue]{key}: {value}[/bold blue]")
+        else:
+            for key, value in results.items():
+                console.print(f"[bold green]{key}: {value}[/bold green]")
+        time.sleep(0.2)
+    console.print("\n")
+
+def animate_equation_solving(equation):
+    """Animate equation solving with a step-by-step effect"""
+    console.print("\n")
+    steps = [
+        f"Original equation: {equation}",
+        "Simplifying...",
+        "Solving for x...",
+        "Checking solution..."
+    ]
+    
+    for step in steps:
+        console.print(f"\033[A\033[K[bold blue]{step}[/bold blue]")
+        time.sleep(0.5)
+    console.print("\n")
+
+def animate_matrix_operation():
+    """Animate matrix operation with a progress bar effect"""
+    console.print("\n")
+    for i in range(10):
+        progress = "█" * i + "░" * (10 - i)
+        console.print(f"\033[A\033[K[bold blue]Performing matrix operation: [{progress}] {i*10}%[/bold blue]")
+        time.sleep(0.2)
+    console.print("\n")
+
+def solve_equation(equation_str):
+    try:
+        # Split equation into left and right sides
+        left, right = equation_str.split('=')
+        
+        # Convert strings to sympy expressions
+        left_expr = parse_expr(left.strip())
+        right_expr = parse_expr(right.strip())
+        
+        # Create equation
+        equation = Eq(left_expr, right_expr)
+        
+        # Solve equation
+        solution = solve(equation, x)
+        
+        return solution
+    except Exception as e:
+        console.print(f"Error solving equation: {e}", style="bold red")
+        return None
\ No newline at end of file
diff --git a/features/code_refactor.py b/features/code_refactor.py
new file mode 100644
index 0000000..86cb82d
--- /dev/null
+++ b/features/code_refactor.py
@@ -0,0 +1,10 @@
+from local_llm_client import run_llama_prompt
+import sys
+
+def run():
+    print("\n🧹 Paste your code below (CTRL+D to end):")
+    code = sys.stdin.read()
+    prompt = f"Refactor this code for better readability and performance:\n{code}"
+    result = run_llama_prompt(prompt)
+    print("\n🔧 Refactored Code:\n")
+    print(result) 
\ No newline at end of file
diff --git a/features/error_explainer.py b/features/error_explainer.py
new file mode 100644
index 0000000..af2b5f0
--- /dev/null
+++ b/features/error_explainer.py
@@ -0,0 +1,7 @@
+from local_llm_client import run_llama_prompt
+
+def run():
+    error = input("\n❌ Paste the error message: ")
+    prompt = f"Explain and fix this error:\n{error}"
+    explanation = run_llama_prompt(prompt)
+    print(f"\n🛠️ Explanation:\n{explanation}") 
\ No newline at end of file
diff --git a/features/nl_to_code.py b/features/nl_to_code.py
new file mode 100644
index 0000000..868cb15
--- /dev/null
+++ b/features/nl_to_code.py
@@ -0,0 +1,13 @@
+from local_llm_client import run_llama_prompt
+import os
+
+def run():
+    instruction = input("\n💬 Describe your task: ")
+    prompt = f"Convert this to a shell command:\nInstruction: {instruction}\nCommand:"
+    command = run_llama_prompt(prompt)
+    if command:
+        print(f"\n🧠 Suggested Command: {command}")
+        if input("Run it? (y/n): ").lower().startswith("y"):
+            os.system(command)
+    else:
+        print("\nCould not generate a command.") 
\ No newline at end of file
diff --git a/features/smart_suggestions.py b/features/smart_suggestions.py
new file mode 100644
index 0000000..34e1624
--- /dev/null
+++ b/features/smart_suggestions.py
@@ -0,0 +1,94 @@
+import os
+import json
+import html
+
+COMMAND_HINTS = {
+    "git": "Try: 'git status', 'git add <file>', 'git commit -m \"message\"'",
+    "ls": "Try: 'ls -l' for details, 'ls -a' to show hidden files",
+    "cd": "Try: 'cd ..' to go up, 'cd /path/to/dir' for absolute path",
+    "python": "Try: 'python my_script.py'",
+    "pip": "Try: 'pip install <package>', 'pip freeze > requirements.txt'",
+    "docker": "Try: 'docker ps', 'docker build .', 'docker run <image>'",
+    "conda": "Try: 'conda activate <env>', 'conda list'",
+    "help": "Shows a list of available commands.",
+    "~ai": "Opens the AI feature configuration panel.",
+    "exit": "Exits PyShell."
+}
+
+# Subcommand and syntax hints for commands with sub-features
+SUBCOMMAND_HINTS = {
+    "git": [
+        ("status", "git status"),
+        ("add", "git add <file>"),
+        ("commit", 'git commit -m "<message>"'),
+        ("push", "git push"),
+        ("pull", "git pull"),
+        ("branch", "git branch"),
+        ("checkout", "git checkout <branch>"),
+        ("merge", "git merge <branch>")
+    ],
+    "pip": [
+        ("install", "pip install <package>"),
+        ("uninstall", "pip uninstall <package>"),
+        ("freeze", "pip freeze > requirements.txt")
+    ],
+    # Add more subcommand hints as needed
+}
+
+def get_live_suggestion(text: str, commands_dict: dict, command_args: dict) -> str:
+    """Generates a live suggestion with syntax based on all available CLI commands."""
+    if not text.strip():
+        return "💡 Tip: Type a command or '~ai' for options."
+
+    words = text.split()
+    if not words:
+        return ""
+        
+    command = words[0].lower()
+    rest = words[1:] if len(words) > 1 else []
+
+    # If the command is a known subcommand group (like git)
+    if command in SUBCOMMAND_HINTS:
+        if not rest:
+            # Show all subcommands
+            subcmds = [f"{name} ({syntax})" for name, syntax in SUBCOMMAND_HINTS[command]]
+            return f"💡 Subcommands: {html.escape(', '.join(subcmds))}"
+        else:
+            # Suggest subcommands that match the next word
+            sub = rest[0].lower()
+            matches = [syntax for name, syntax in SUBCOMMAND_HINTS[command] if name.startswith(sub)]
+            if matches:
+                return f"💡 Did you mean: {html.escape(', '.join(matches))}?"
+
+    if command in commands_dict:
+        if command in command_args:
+            syntax = " ".join(command_args[command])
+            return f"✅ Usage: {command} {html.escape(syntax)}"
+        else:
+            return f"✅ Command '{command}' is valid. Press Enter to execute."
+
+    # Check for partial command matches from the full command list
+    possible_matches = [cmd for cmd in commands_dict if cmd.startswith(command)]
+    if possible_matches:
+        # Suggest the first few matches
+        suggestions = ", ".join(possible_matches[:3])
+        return f"💡 Did you mean: {suggestions}?"
+    
+    return "" # Return empty string if no specific hint
+
+def run():
+    history_path = os.path.join(os.path.dirname(__file__), '..', 'history.json')
+    try:
+        with open(history_path, 'r') as f:
+            history = json.load(f)
+    except Exception:
+        history = {}
+    recent = history.get('commands', [])[-1] if history.get('commands') else ''
+    # Simple rule-based suggestion
+    if 'git status' in recent:
+        suggestion = 'git add .'
+    elif 'ls' in recent:
+        suggestion = 'cd <folder>'
+    else:
+        suggestion = 'echo Hello World'
+    print(f"\n💡 Based on '{recent}', try: {suggestion}") 
\ No newline at end of file
diff --git a/features/snippet_search.py b/features/snippet_search.py
new file mode 100644
index 0000000..91e83b8
--- /dev/null
+++ b/features/snippet_search.py
@@ -0,0 +1,7 @@
+from local_llm_client import run_llama_prompt
+
+def run():
+    topic = input("\n🔍 What code snippet are you looking for? ")
+    prompt = f"Give a Python snippet to: {topic}"
+    snippet = run_llama_prompt(prompt)
+    print(f"\n📚 Snippet:\n{snippet}") 
\ No newline at end of file
diff --git a/graphs.py b/graphs.py
index c154e65..846b8f2 100644
--- a/graphs.py
+++ b/graphs.py
@@ -4,6 +4,10 @@
 from rich.prompt import Prompt, FloatPrompt
 from rich.panel import Panel
 from rich import box
+import time
+from rich.text import Text
+from rich.table import Table
+from menu_base import MojiSwitchMenu
 
 # Safe functions for eval
 SAFE_FUNCTIONS = {
@@ -87,4 +91,127 @@ def run(self):
                 self.console.print("[bold red]Invalid choice. Please enter 1 or 2.[/bold red]")
                 
         except KeyboardInterrupt:
-            print("\n")
\ No newline at end of file
+            print("\n")
+
+def show_graphs_menu():
+    # Define options for graph operations
+    options = [
+        ("📈 Line Plot", "line"),
+        ("📊 Bar Chart", "bar"),
+        ("📉 Scatter Plot", "scatter"),
+        ("📊 Histogram", "histogram"),
+        ("📈 Pie Chart", "pie"),
+        ("📊 3D Plot", "3d")
+    ]
+    
+    def on_execute(state):
+        # Get list of enabled operations
+        enabled_ops = [name for name, value in options if state[value]]
+        if not enabled_ops:
+            console.print("[bold red]No operations selected![/bold red]")
+            return
+            
+        # Animate plot creation
+        animate_plot_creation()
+        
+        # Process each enabled operation
+        results = {}
+        for op in enabled_ops:
+            # Simulate plot creation
+            time.sleep(0.5)
+            results[op] = f"Plot created for {op}"
+            
+        # Display results
+        animate_plot_display(results)
+    
+    # Create and run menu
+    menu = MojiSwitchMenu(
+        title="📊 Graph Operations",
+        options=options,
+        on_execute=on_execute
+    )
+    menu.run()
+
+def display_graph_table(graphs):
+    """Display graphs in a modern table format"""
+    table = Table(
+        show_header=True,
+        header_style="bold cyan",
+        box=None,
+        padding=(0, 1)
+    )
+    
+    # Add columns
+    table.add_column("No.", style="dim", width=4)
+    table.add_column("Type", style="bold")
+    table.add_column("Description", style="italic")
+    table.add_column("Status", justify="center", width=4)
+    
+    # Add rows with graph types
+    features = [
+        ("1", "Line Plot", "Plot continuous data points", "line"),
+        ("2", "Bar Chart", "Compare categorical data", "bar"),
+        ("3", "Scatter Plot", "Show relationships between variables", "scatter"),
+        ("4", "Histogram", "Display data distribution", "histogram"),
+        ("5", "Pie Chart", "Show proportional data", "pie"),
+        ("6", "3D Plot", "Visualize three-dimensional data", "3d")
+    ]
+    
+    for no, name, desc, key in features:
+        status = "✅" if graphs.get(key, False) else "❌"
+        table.add_row(no, name, desc, status)
+        
+    # Create panel with table
+    panel = Panel(
+        table,
+        title="📊 Graph Types",
+        border_style="cyan",
+        padding=(1, 2)
+    )
+    
+    console.print(panel)
+
+def animate_plot_creation():
+    """Animate plot creation with a progress bar effect"""
+    console.print("\n")
+    for i in range(10):
+        progress = "█" * i + "░" * (10 - i)
+        console.print(f"\033[A\033[K[bold blue]Creating plot: [{progress}] {i*10}%[/bold blue]")
+        time.sleep(0.2)
+    console.print("\n")
+
+def animate_plot_display(plots):
+    """Animate plot display with a fade-in effect"""
+    console.print("\n")
+    for i in range(3):
+        console.print("\033[A\033[K", end="")
+        if i == 0:
+            for key, value in plots.items():
+                console.print(f"[grey50]{key}: {value}[/grey50]")
+        elif i == 1:
+            for key, value in plots.items():
+                console.print(f"[bold blue]{key}: {value}[/bold blue]")
+        else:
+            for key, value in plots.items():
+                console.print(f"[bold green]{key}: {value}[/bold green]")
+        time.sleep(0.2)
+    console.print("\n")
+
+def animate_data_loading():
+    """Animate data loading with a spinning effect"""
+    spinner = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"]
+    console.print("\n")
+    for _ in range(10):  # 1 second of animation
+        for char in spinner:
+            console.print(f"\033[A\033[K[bold blue]{char} Loading data...[/bold blue]")
+            time.sleep(0.1)
+    console.print("\n")
+
+def animate_export_progress():
+    """Animate export progress with a progress bar effect"""
+    console.print("\n")
+    for i in range(10):
+        progress = "█" * i + "░" * (10 - i)
+        console.print(f"\033[A\033[K[bold blue]Exporting plot: [{progress}] {i*10}%[/bold blue]")
+        time.sleep(0.2)
+    console.print("\n")
\ No newline at end of file
diff --git a/local_llm_client.py b/local_llm_client.py
new file mode 100644
index 0000000..a1f7dab
--- /dev/null
+++ b/local_llm_client.py
@@ -0,0 +1,40 @@
+from llama_cpp import Llama, CreateCompletionResponse
+from rich.console import Console
+import typing
+
+console = Console()
+
+# The model path provided by the user
+MODEL_PATH = "C:/Users/Prince Patel/models/mistral/mistral-7b-instruct-v0.1.Q4_K_M.gguf"
+
+_llm_cache = None
+
+def get_llama_client():
+    """Initializes and returns the Llama client, caching it for the session."""
+    global _llm_cache
+    if _llm_cache is None:
+        try:
+            console.print(f"[bold yellow]Loading model from: {MODEL_PATH}...[/bold yellow]")
+            _llm_cache = Llama(model_path=MODEL_PATH, n_ctx=2048, verbose=False)
+            console.print("[bold green]Model loaded successfully![/bold green]")
+        except Exception as e:
+            console.print(f"[bold red]Error loading model: {e}[/bold red]")
+            _llm_cache = None
+    return _llm_cache
+
+def run_llama_prompt(prompt: str, max_tokens=512, temperature=0.7) -> str:
+    """Runs a prompt against the local LLM and returns the text response."""
+    llm = get_llama_client()
+    if not llm:
+        return "Local model is not available."
+
+    try:
+        response = llm(prompt, max_tokens=max_tokens, temperature=temperature, stream=False)
+        # We expect a dictionary, so we assert the type to satisfy the linter
+        response_dict = typing.cast(CreateCompletionResponse, response)
+        if response_dict and 'choices' in response_dict and response_dict['choices']:
+            return response_dict['choices'][0]['text'].strip()
+        return "Failed to get a valid response from the model."
+    except Exception as e:
+        console.print(f"[bold red]Error during model inference: {e}[/bold red]")
+        return "An error occurred while generating a response." 
\ No newline at end of file
diff --git a/main.py b/main.py
index 6339349..5590b1b 100644
--- a/main.py
+++ b/main.py
@@ -1,17 +1,29 @@
 import os, time, psutil, json, pyperclip, random, string, threading, time, pyfiglet, config
 from rich.console import Console
 from rich.prompt import Prompt
+from rich.text import Text
+from rich.panel import Panel
+from rich.markdown import Markdown
+from prompt_toolkit import PromptSession
+from prompt_toolkit.completion import WordCompleter, Completer, Completion
+from ai_panel import show_ai_panel, is_feature_enabled
+from prompt_toolkit.key_binding import KeyBindings
+from rich.live import Live
+from rich.table import Table
+import msvcrt
+from prompt_toolkit.formatted_text import HTML
+from features.smart_suggestions import get_live_suggestion
 
 # dependencies
 from weather import Weather
-from task import Task
+from tasks import Task
 from linux_commands import Commands
 from git_commands import Git
 from terminals import Terminal
 from song import Song
 from equations import Equations
 from game import Game
-from statistical import StatisticsCalculator
+from statistics_menu import show_statistics_menu
 from graphs import GraphPlotter
 
 console = Console()
@@ -22,6 +34,93 @@
 stop_scheduler = False
 prompt_flag = True
 
+# Animated ASCII Art for PyShell
+ASCII_ART = [
+    " ____        ____  _          _ _ ",
+    "|  _ \\ _   _/ ___|| |__   ___| | |",
+    "| |_) | | | \\___ \\| '_ \\ / _ \\ | |",
+    "|  __/| |_| |___) | | | |  __/ | |",
+    "|_|    \\__, |____/|_| |_|\\___|_|_|",
+    "       |___/"
+]
+
+COLOR_WAVE = [
+    "deep_pink3", "hot_pink", "magenta", "purple", 
+    "blue_violet", "royal_blue1", "cyan", "turquoise2",
+    "spring_green3", "lime", "yellow", "orange1",
+    "red", "dark_red", "deep_pink2", "medium_purple"
+]
+
+WELCOME_ASCII = [
+    " __        __   _                            ",
+    " \\ \\      / /__| | ___ ___  _ __ ___   ___   ",
+    "  \\ \\ /\\ / / _ \\ |/ __/ _ \\| '_ ` _ \\ / _ \\  ",
+    "   \\ V  V /  __/ | (_| (_) | | | | | |  __/  ",
+    "    \\_/\\_/ \\___|_|\\___\\___/|_| |_| |_|\\___|  "
+]
+
+def animate_welcome_zoom_out():
+    max_padding = 12
+    welcome_colors = ["deep_pink3", "hot_pink", "magenta", "purple", "blue_violet"]
+    for pad in range(max_padding, -1, -2):  # 7 frames
+        console.clear()
+        for i, line in enumerate(WELCOME_ASCII):
+            color = welcome_colors[i % len(welcome_colors)]
+            console.print(" " * pad + f"[bold {color}]{line}[/bold {color}]", justify="left")
+        time.sleep(0.05)
+    console.clear()
+
+def animate_welcome_ascii_reveal():
+    welcome_colors = ["deep_pink3", "hot_pink", "magenta", "purple", "blue_violet"]
+    for col in range(1, len(WELCOME_ASCII[0]) + 1):
+        console.clear()
+        for i, line in enumerate(WELCOME_ASCII):
+            # Reveal up to the current column, mask the rest
+            revealed = line[:col]
+            masked = line[col:]
+            color = welcome_colors[i % len(welcome_colors)]
+            console.print(f"[bold {color}]{revealed}[/bold {color}][grey23]{masked}[/grey23]", justify='left')
+        time.sleep(0.07)
+    time.sleep(0.5)
+    console.clear()
+
+def animate_ascii_art_wave():
+    animate_welcome_zoom_out()
+    for frame in range(7):  # 7 frames
+        console.clear()
+        for idx, line in enumerate(ASCII_ART):
+            wave_offset = (frame + idx) % len(COLOR_WAVE)
+            styled_line = Text()
+            for i, char in enumerate(line):
+                color = COLOR_WAVE[(wave_offset + i) % len(COLOR_WAVE)]
+                styled_line.append(char, style=color)
+            console.print(styled_line)
+        time.sleep(0.07)
+    console.clear()
+    # Final static display with gradient effect
+    final_colors = ["deep_pink3", "hot_pink", "magenta", "purple", "blue_violet", "royal_blue1"]
+    for i, line in enumerate(ASCII_ART):
+        color = final_colors[i % len(final_colors)]
+        console.print(Text(line, style=f"bold {color}"))
+
+def show_command_feedback(cmd):
+    table = Table.grid(padding=(0, 1))
+    table.add_column("Status", style="cyan")
+    table.add_column("Command", style="green")
+    table.add_row("", cmd)
+    with Live(table, refresh_per_second=10):
+        time.sleep(0.1)  # Brief pause for visual feedback
+
+def show_smart_suggestion():
+    suggestions = [
+        "Try 'git status' to check repository state",
+        "Use 'weather' to get local forecast",
+        "Run 'stats' for statistical calculations",
+        "Type '~ai' to configure AI features"
+    ]
+    suggestion = random.choice(suggestions)
+    console.print(f"\n[bold green]💡 {suggestion}[/bold green]")
+
 # Load users
 def load_users():
     with lock:
@@ -91,7 +190,6 @@ def generate_password(*args):
     except ValueError:
         console.print("Invalid input. Using default length (12)", style="bold red")
         length = 12
-        display_prompt(username)
         return
     
     characters = string.ascii_letters + string.digits + string.punctuation
@@ -121,18 +219,140 @@ def display_prompt(username):
     elif config.current_terminal_layout == 8:
         Terminal().terminal_8()
         
-    console.print(terminal.get_prompt())
+    prompt = terminal.get_prompt()
+    console.print(f"{prompt}", justify="left")
        
     
 # clear console 
 def clear(*args):
     os.system('cls' if os.name == 'nt' else 'clear')
 
+def show_suggestions():
+    suggestions = """
+# Welcome to PyShell!
+
+Here are some things you can try:
+
+• File: rename, move, copy, delete, create, list, edit, cd  
+• Processes: list, kill  
+• Network: info  
+• Clipboard: copy, paste  
+• Password: generate  
+• Math: calculator, math-help, equation, differential, stats  
+• Weather: get weather  
+• Tasks: schedule, list, unschedule, stop  
+• Terminal: change style  
+• Games: play games  
+• Graphs: plot  
+• Git: status, branches, create, switch, delete, merge, clone, add, commit, push, pull, stash, undo, recover, dashboard, auto_merge, voice, reminder, offline_sync, history, help  
+• Music: play a song  
+• Other: clear, exit  
+"""
+    panel = Panel.fit(Markdown(suggestions), title="💡 Suggestions", border_style="yellow", padding=(1, 2))
+    console.print(panel)
+
+def show_menu():
+    menu_items = [
+        ("1", "📊 Statistics", "Calculate statistics and generate plots"),
+        ("2", "🌤️ Weather", "Get weather information"),
+        ("3", "📝 Tasks", "Manage your tasks"),
+        ("4", "🔧 Terminal", "Customize terminal appearance"),
+        ("5", "🤖 AI Panel", "Configure AI features"),
+        ("6", "📈 Graph", "Create and visualize graphs"),
+        ("7", "🧮 Equations", "Solve mathematical equations"),
+        ("8", "📂 Git", "Git repository management"),
+        ("9", "⚙️ Settings", "Configure PyShell settings"),
+        ("0", "❌ Exit", "Exit PyShell")
+    ]
+    
+    selected_index = 0
+    
+    # Animate header
+    console.print("\n")
+    for i in range(3):
+        console.print("\033[A\033[K", end="")
+        if i == 0:
+            console.print("[bold cyan]╔════════════════════════════════════╗[/bold cyan]")
+        elif i == 1:
+            console.print("[bold cyan]║           PyShell Menu            ║[/bold cyan]")
+        else:
+            console.print("[bold cyan]╚════════════════════════════════════╝[/bold cyan]")
+        time.sleep(0.05)
+    
+    # Print initial menu with fade-in effect
+    for i, (no, name, desc) in enumerate(menu_items):
+        if i == selected_index:
+            console.print(f"[bold green]▶ {name}[/bold green]")
+        else:
+            console.print(f"  {name}")
+        time.sleep(0.02)  # Fade-in effect
+    
+    while True:
+        if msvcrt.kbhit():
+            key = msvcrt.getch()
+            
+            # Arrow key handling
+            if key == b'\xe0':  # Arrow key prefix
+                key = msvcrt.getch()
+                if key == b'H':  # Up arrow
+                    # Move up one line
+                    console.print("\033[A", end="")
+                    # Clear current line
+                    console.print("\033[K", end="")
+                    # Print previous item without arrow
+                    console.print(f"  {menu_items[selected_index][1]}")
+                    # Move up one more line
+                    console.print("\033[A", end="")
+                    # Clear current line
+                    console.print("\033[K", end="")
+                    # Update selection
+                    selected_index = (selected_index - 1) % len(menu_items)
+                    # Print new selection with arrow and glow effect
+                    console.print(f"[bold green]▶ {menu_items[selected_index][1]}[/bold green]")
+                elif key == b'P':  # Down arrow
+                    # Move down one line
+                    console.print("\033[B", end="")
+                    # Clear current line
+                    console.print("\033[K", end="")
+                    # Print next item without arrow
+                    console.print(f"  {menu_items[selected_index][1]}")
+                    # Move up one line
+                    console.print("\033[A", end="")
+                    # Clear current line
+                    console.print("\033[K", end="")
+                    # Update selection
+                    selected_index = (selected_index + 1) % len(menu_items)
+                    # Print new selection with arrow and glow effect
+                    console.print(f"[bold green]▶ {menu_items[selected_index][1]}[/bold green]")
+            
+            # Enter key to select
+            elif key == b'\r':
+                # Animate selection
+                for _ in range(3):
+                    console.print(f"\033[A\033[K[bold green]▶ {menu_items[selected_index][1]}[/bold green]")
+                    time.sleep(0.1)
+                    console.print(f"\033[A\033[K  {menu_items[selected_index][1]}")
+                    time.sleep(0.1)
+                # Call the correct function for each menu item
+                if menu_items[selected_index][0] == "4":
+                    terminal.show_terminal_themes()
+                    continue
+                return menu_items[selected_index][0]
+            
+            # Escape key to exit
+            elif key == b'\x1b':
+                return "0"  # Exit option
+
+def show_help(commands_dict):
+    """Displays a list of all available commands."""
+    console.print("\n[bold cyan]Available Commands:[/bold cyan]")
+    for command in sorted(commands_dict.keys()):
+        console.print(f"- {command}")
+    console.print("\nType `~ai` to access AI features.")
+
 def main():
     console.clear()
-    ascii_banner = pyfiglet.figlet_format("PyShell")
-    print(ascii_banner)
-    
+    animate_ascii_art_wave()
     global username
     username, role = register_user() if Prompt.ask("New user?", choices=["y", "n"]) == "y" else login_user()
     
@@ -143,9 +363,11 @@ def main():
     terminl = Terminal()
     git = Git()
     eq = Equations()
-    stats = StatisticsCalculator()
     graph = GraphPlotter()
     
+    # AI Feature command stubs are removed from the 'commands' dictionary.
+    # The '~ai' command is the single entry point.
+    
     commands = {
         "rename": cmds.rename_item,
         "move": cmds.move_file,
@@ -157,7 +379,7 @@ def main():
         "paste": clipboard_paste,
         "password": generate_password,
         "calc": cmds.calculator,
-        "stats": lambda args: stats.calculate_statistics(),
+        "stats": lambda args: show_statistics_menu(),
         "equation": eq.solve_equation,
         "differential": lambda args: eq.solve_differential(args),
         "math-help": cmds.math_help,
@@ -167,87 +389,117 @@ def main():
         "unschedule": task.remove_scheduled_task,
         "stop": task.stop_running_tasks,
         "cls": clear,
-        "terminal": terminl.change_terminal,
-        "game": lambda args: Game.play_game(" ".join(args)),
+        "terminal": lambda args: terminl.show_terminal_themes(),
+        "games": lambda *args: console.print('Game feature not implemented.'),
         "plot": lambda args: graph.run(),
+        "help": lambda *args: show_help(commands),
         "exit": lambda _: exit(),
-        
-        # Git Commands (Using Git Class)
-        "git-status": git.git_status,
-        "git-branches": git.git_branches,
-        "git-create": git.git_create_branch,
-        "git-switch": git.git_switch_branch,
-        "git-push": git.git_push,
-        "git-pull": git.git_pull,
-        "git-merge": git.git_merge,
-        "git-delete": git.git_delete_branch,
-        "git-clone": git.git_clone,
-        "git-add": git.git_add,
-        "git-commit": git.git_commit,
-        
-        # Unique Git Features
-        "play": lambda args: Song.play_song(" ".join(args)),
-        "git-smart": git.git_smart_commit,
-        "git-help": git.git_help,
-        "git-history": git.git_history,
-        "git-undo": git.git_undo,
-        "git-stash": git.git_stash,
-        "git-recover": git.git_recover,
-        "git-dashboard": git.git_dashboard,
-        "git-auto_merge": git.git_auto_merge,
-        "git-voice": git.git_voice_command,
-        "git-reminder": git.git_reminder,
-        "git-offline_sync": git.git_offline_sync,
     }
     
     scheduler_thread = threading.Thread(target=Task().run_scheduler, daemon=True)
     scheduler_thread.start()
     
+    show_suggestions()
+    
+    # Define required arguments for each command
+    command_args = {
+        "rename": ["<old_name>", "<new_name>"],
+        "move": ["<source>", "<destination>"],
+        "copy": ["<source>", "<destination>"],
+        "kill": ["<PID>"],
+        "copytext": ["<text>"],
+        "equation": ["<equation>"],
+        "differential": ["<equation>"],
+        "weather": ["<location>"],
+        "schedule": ["<task_name>", "<time>"],
+        "unschedule": ["<task_name>"],
+        "git-create": ["<branch_name>"],
+        "git-switch": ["<branch_name>"],
+        "git-merge": ["<branch_name>"],
+        "git-delete": ["<branch_name>"],
+        "git-clone": ["<repository_url>"],
+        "git-add": ["<file>"],
+        "git-commit": ["<message>"],
+        "play": ["<song_name>"]
+    }
+
+    class CommandCompleter(Completer):
+        def get_completions(self, document, complete_event):
+            text = document.text_before_cursor
+            words = text.split()
+            if len(words) == 1:
+                for cmd in commands.keys():
+                    if cmd.startswith(words[0]):
+                        yield Completion(cmd, start_position=-len(words[0]))
+            elif len(words) == 2 and words[0] in command_args:
+                for arg in command_args[words[0]]:
+                    if arg.startswith(words[1]):
+                        yield Completion(arg, start_position=-len(words[1]))
+
+    def get_bottom_toolbar():
+        if is_feature_enabled("smart_suggestions"):
+            # This function is called on every render, making the suggestion live
+            return HTML(get_live_suggestion(session.default_buffer.text, commands, command_args))
+        return None
+
+    session = PromptSession(
+        completer=CommandCompleter(),
+        bottom_toolbar=get_bottom_toolbar,
+        refresh_interval=0.5  # Refresh toolbar every 0.5 seconds
+    )
+    
     while True:
         display_prompt(username)
-        command = input().strip().lower().split()
-        
-        if not command:
-            continue
-        
-        cmd, *args = command
-        
-        start_time = time.time()
-        
-        if not command:
-            continue
-        
-        cmd, *args = command
-        start_time = time.time()
+        try:
+            user_input = session.prompt("").strip().lower()
+            if not user_input:
+                continue
+            command = user_input.split()
+            cmd, *args = command
+            start_time = time.time()
 
-        if cmd in commands:
-            commands[cmd](args)
-        else:
-            if cmd == "ls":
-                cmds.list_files()
-            elif cmd == "touch" and args:
-                cmds.create_file(args[0])
-            elif cmd == "rm" and args:
-                cmds.delete_file(args[0])
-            elif cmd == "mkdir" and args:
-                cmds.create_folder(args[0])
-            elif cmd == "rmdir" and args:
-                cmds.delete_folder(args[0])
-            elif cmd == "cd" and args:
-                cmds.change_directory(args[0])
-            elif cmd == "edit" and args:
-                cmds.text_editor(args[0])
-            elif cmd == "sysinfo":
-                cmds.system_info()
-            elif cmd == "exit":
-                console.print("Exiting PyShell...", style="bold red")
-                break
+            # Show command feedback
+            show_command_feedback(cmd)
+            
+            if cmd == "~ai":
+                show_ai_panel()
+                continue
+            if cmd in commands:
+                commands[cmd](args)
             else:
-                console.print("Invalid command!", style="bold red")
-        
-        exec_time = time.time() - start_time
-        console.print(f"Execution time: {exec_time:.4f} seconds", style="bold yellow")
-        time.sleep(1)
+                if cmd == "ls":
+                    cmds.list_files()
+                elif cmd == "touch" and args:
+                    cmds.create_file(args[0])
+                elif cmd == "rm" and args:
+                    cmds.delete_file(args[0])
+                elif cmd == "mkdir" and args:
+                    cmds.create_folder(args[0])
+                elif cmd == "rmdir" and args:
+                    cmds.delete_folder(args[0])
+                elif cmd == "cd" and args:
+                    cmds.change_directory(args[0])
+                elif cmd == "edit" and args:
+                    cmds.text_editor(args[0])
+                elif cmd == "sysinfo":
+                    cmds.system_info()
+                elif cmd == "exit":
+                    console.print("Exiting PyShell...", style="bold red")
+                    break
+                else:
+                    console.print("Invalid command!", style="bold red")
+            exec_time = time.time() - start_time
+            console.print(f"Execution time: {exec_time:.4f} seconds", style="bold yellow")
+                
+            # Show smart suggestion occasionally
+            if random.random() < 0.3:  # 30% chance
+                show_smart_suggestion()
+                
+            time.sleep(1)
+        except KeyboardInterrupt:
+            console.print("\nUse 'exit' to quit", style="bold yellow")
+        except Exception as e:
+            console.print(f"Error: {str(e)}", style="bold red")
 
 if __name__ == "__main__":
     main()
diff --git a/menu_base.py b/menu_base.py
new file mode 100644
index 0000000..d913108
--- /dev/null
+++ b/menu_base.py
@@ -0,0 +1,99 @@
+import os
+from typing import Dict, List, Tuple, Callable
+from rich.console import Console
+from rich.text import Text
+
+console = Console()
+
+class MojiSwitchMenu:
+    def __init__(self, title: str, options: List[Tuple[str, str]], on_execute: Callable = None):
+        """
+        Initialize the menu with options and optional execute callback.
+        
+        Args:
+            title: Menu title
+            options: List of (display_name, value) tuples
+            on_execute: Optional callback function when execute is pressed
+        """
+        self.title = title
+        self.options = options
+        self.on_execute = on_execute
+        self.state = {value: False for _, value in options}
+        self.key_map = {str(i+1): value for i, (_, value) in enumerate(options)}
+        
+    def clear_screen(self):
+        """Clear the terminal screen efficiently."""
+        os.system('cls' if os.name == 'nt' else 'clear')
+        
+    def display(self):
+        """Display the current menu state."""
+        self.clear_screen()
+        console.print(f"\n[bold cyan]{self.title}[/bold cyan]\n")
+        
+        for idx, (name, value) in enumerate(self.options, 1):
+            status = "✅" if self.state[value] else "❌"
+            console.print(f"{idx}. {name}: {status}")
+            
+        console.print("\n[dim]Use number keys to toggle, E to execute, Q to quit[/dim]")
+        
+    def handle_input(self, choice: str) -> bool:
+        """
+        Handle user input and return True if should continue, False if should exit.
+        
+        Args:
+            choice: User input string
+            
+        Returns:
+            bool: True to continue, False to exit
+        """
+        choice = choice.strip().lower()
+        
+        if choice in self.key_map:
+            # Toggle state
+            value = self.key_map[choice]
+            self.state[value] = not self.state[value]
+            return True
+            
+        elif choice == 'e':
+            # Execute with current state
+            self.clear_screen()
+            console.print("[bold green]Selected options:[/bold green]")
+            for name, value in self.options:
+                if self.state[value]:
+                    console.print(f" - {name}")
+                    
+            if self.on_execute:
+                self.on_execute(self.state)
+                
+            console.print("\n[dim]Press Enter to return to menu[/dim]")
+            input()
+            return True
+            
+        elif choice == 'q':
+            return False
+            
+        return True
+        
+    def run(self):
+        """Run the menu loop."""
+        while True:
+            self.display()
+            choice = input("Choice: ")
+            if not self.handle_input(choice):
+                break
+
+# Example usage:
+if __name__ == "__main__":
+    # Example menu for statistics
+    stats_menu = MojiSwitchMenu(
+        title="Statistical Operations",
+        options=[
+            ("Mean", "mean"),
+            ("Median", "median"),
+            ("Mode", "mode"),
+            ("Standard Deviation", "stddev"),
+            ("Variance", "variance")
+        ],
+        on_execute=lambda state: print(f"Executing with state: {state}")
+    )
+    stats_menu.run() 
\ No newline at end of file
diff --git a/requirements.txt b/requirements.txt
index 25e5e0d..ee83433 100644
Binary files a/requirements.txt and b/requirements.txt differ
diff --git a/statistical.py b/statistical.py
deleted file mode 100644
index 801f1d1..0000000
--- a/statistical.py
+++ /dev/null
@@ -1,105 +0,0 @@
-from rich.console import Console
-from rich.table import Table
-from rich.panel import Panel
-from rich.prompt import Prompt
-from rich.text import Text
-import statistics
-import numpy as np
-from scipy import stats
-from InquirerPy import inquirer
-
-console = Console()
-
-class StatisticsCalculator:
-    def get_dataset(self, prompt):
-        while True:
-            try:
-                user_input = Prompt.ask(f"[bold cyan]{prompt}[/] (comma-separated)")
-                data = list(map(float, user_input.split(',')))
-                if not data:
-                    raise ValueError
-                return data
-            except ValueError:
-                console.print("❌ [red]Invalid input. Please enter comma-separated numbers.[/red]\n")
-
-    def display_result(self, title, result):
-        panel = Panel.fit(
-            Text(f"{result}", style="bold green"),
-            title=f"[bold magenta]{title}[/bold magenta]",
-            border_style="bright_blue"
-        )
-        console.print(panel)
-
-    def calculate_statistics(self):
-        while True:
-            choice = inquirer.select(
-                message="📊 Select the statistical measure you want to calculate:",
-                choices=[
-                    "Mean", "Median", "Mode", "Standard Deviation", "Variance",
-                    "Covariance & Correlation",
-                    "Spearman Rank Correlation",
-                    "Regression Analysis",
-                    "❌ Exit"
-                ],
-            ).execute()
-
-            if choice == "❌ Exit":
-                console.print("[bold red]Exiting the Statistics Calculator. Goodbye![/bold red]")
-                break
-
-            # Single-dataset measures
-            if choice in ["Mean", "Median", "Mode", "Standard Deviation", "Variance"]:
-                data = self.get_dataset("Enter numbers for Dataset 1")
-                try:
-                    if choice == "Mean":
-                        result = statistics.mean(data)
-                    elif choice == "Median":
-                        result = statistics.median(data)
-                    elif choice == "Mode":
-                        result = statistics.mode(data)
-                    elif choice == "Standard Deviation":
-                        result = statistics.stdev(data)
-                    elif choice == "Variance":
-                        result = statistics.variance(data)
-
-                    self.display_result(choice, result)
-                except Exception as e:
-                    console.print(f"❌ [red]Error calculating {choice}: {e}[/red]")
-
-            # Two-dataset measures
-            elif choice in ["Covariance & Correlation", "Spearman Rank Correlation", "Regression Analysis"]:
-                data1 = self.get_dataset("Enter numbers for Dataset 1")
-                data2 = self.get_dataset("Enter numbers for Dataset 2")
-                try:
-                    if len(data1) != len(data2):
-                        raise ValueError("Datasets must be of equal length.")
-
-                    if choice == "Covariance & Correlation":
-                        cov = np.cov(data1, data2)[0][1]
-                        corr = np.corrcoef(data1, data2)[0][1]
-
-                        table = Table(title="Covariance & Pearson Correlation", style="cyan")
-                        table.add_column("Measure", style="bold yellow")
-                        table.add_column("Value", style="bold green")
-                        table.add_row("Covariance", f"{cov:.4f}")
-                        table.add_row("Pearson Correlation", f"{corr:.4f}")
-                        console.print(table)
-
-                    elif choice == "Spearman Rank Correlation":
-                        spearman_corr, _ = stats.spearmanr(data1, data2)
-                        self.display_result("Spearman Rank Correlation", f"{spearman_corr:.4f}")
-
-                    elif choice == "Regression Analysis":
-                        slope, intercept, r_value, p_value, std_err = stats.linregress(data1, data2)
-
-                        table = Table(title="Linear Regression Analysis", style="cyan")
-                        table.add_column("Metric", style="bold yellow")
-                        table.add_column("Value", style="bold green")
-                        table.add_row("Regression Line", f"Y = {slope:.2f}X + {intercept:.2f}")
-                        table.add_row("R-squared", f"{r_value**2:.4f}")
-                        table.add_row("P-value", f"{p_value:.4f}")
-                        table.add_row("Std. Error", f"{std_err:.4f}")
-                        console.print(table)
-
-                except Exception as e:
-                    console.print(f"❌ [red]Error: {e}[/red]\n")
diff --git a/statistics_menu.py b/statistics_menu.py
new file mode 100644
index 0000000..69b646d
--- /dev/null
+++ b/statistics_menu.py
@@ -0,0 +1,199 @@
+import time
+from rich.console import Console
+from rich.text import Text
+from rich.table import Table
+from rich.panel import Panel
+from menu_base import MojiSwitchMenu
+from rich.prompt import Prompt
+from rich.live import Live
+from rich.progress import Progress, SpinnerColumn, TextColumn
+import statistics
+import numpy as np
+
+console = Console()
+
+def show_statistics_menu():
+    # Define options for statistical operations
+    options = [
+        ("📊 Descriptive Stats", "descriptive"),
+        ("📈 Regression", "regression"),
+        ("📉 Correlation", "correlation"),
+        ("📊 Hypothesis Test", "hypothesis"),
+        ("📈 Time Series", "timeseries"),
+        ("📊 Distribution", "distribution")
+    ]
+    
+    def on_execute(state):
+        selected = [name for name, value in options if state[value]]
+        if not selected:
+            console.print("[bold red]No operation selected![/bold red]")
+            return
+        if len(selected) > 1:
+            console.print("[bold red]Please select only one operation at a time![/bold red]")
+            return
+        op = selected[0]
+        step_text = f"Selected option: {op}"
+        with Live(status_table(step_text, "Pending"), refresh_per_second=10, transient=True) as live:
+            time.sleep(0.7)
+            live.update(status_table(step_text, "In Progress"))
+            time.sleep(0.7)
+        try:
+            if op == "📊 Descriptive Stats":
+                data = Prompt.ask("[cyan]Enter numbers (comma-separated)[/cyan]")
+                nums = [float(i) for i in data.split(",")]
+                animate_calculation()
+                mean = statistics.mean(nums)
+                median = statistics.median(nums)
+                try:
+                    mode = statistics.mode(nums)
+                except Exception:
+                    mode = "No unique mode"
+                stdev = statistics.stdev(nums) if len(nums) > 1 else "N/A"
+                variance = statistics.variance(nums) if len(nums) > 1 else "N/A"
+                result = {
+                    "Mean": mean,
+                    "Median": median,
+                    "Mode": mode,
+                    "Std Dev": stdev,
+                    "Variance": variance
+                }
+                animate_results_display(result)
+            elif op == "📈 Regression":
+                data1 = Prompt.ask("[cyan]Enter numbers for Dataset 1 (comma-separated)[/cyan]")
+                data2 = Prompt.ask("[cyan]Enter numbers for Dataset 2 (comma-separated)[/cyan]")
+                x = [float(i) for i in data1.split(",")]
+                y = [float(i) for i in data2.split(",")]
+                if len(x) != len(y):
+                    raise ValueError("Datasets must be of equal length.")
+                animate_calculation()
+                slope, intercept = np.polyfit(x, y, 1)
+                result = {op: f"Y = {slope:.2f}X + {intercept:.2f}"}
+                animate_results_display(result)
+            elif op == "📉 Correlation":
+                data1 = Prompt.ask("[cyan]Enter numbers for Dataset 1 (comma-separated)[/cyan]")
+                data2 = Prompt.ask("[cyan]Enter numbers for Dataset 2 (comma-separated)[/cyan]")
+                x = [float(i) for i in data1.split(",")]
+                y = [float(i) for i in data2.split(",")]
+                if len(x) != len(y):
+                    raise ValueError("Datasets must be of equal length.")
+                animate_calculation()
+                corr = np.corrcoef(x, y)[0][1]
+                result = {op: f"Correlation: {corr:.4f}"}
+                animate_results_display(result)
+            elif op == "📊 Hypothesis Test":
+                with Live(status_table("Hypothesis Test", "Not implemented"), refresh_per_second=10, transient=True) as live:
+                    time.sleep(1.2)
+            elif op == "📈 Time Series":
+                with Live(status_table("Time Series", "Not implemented"), refresh_per_second=10, transient=True) as live:
+                    time.sleep(1.2)
+            elif op == "📊 Distribution":
+                with Live(status_table("Distribution", "Not implemented"), refresh_per_second=10, transient=True) as live:
+                    time.sleep(1.2)
+            else:
+                animate_calculation()
+                result = {op: f"Result for {op}"}
+                animate_results_display(result)
+        except Exception as e:
+            error_table = Table(title="Error", show_header=False)
+            error_table.add_row(f"[bold red]Error: {e}[/bold red]", "❌")
+            with Live(error_table, refresh_per_second=10, transient=True):
+                time.sleep(1.5)
+    
+    # Create and run menu (single-select logic)
+    menu = MojiSwitchMenu(
+        title="📊 Statistical Operations (Select ONE)",
+        options=options,
+        on_execute=on_execute
+    )
+    # Patch menu to only allow one selection at a time
+    orig_handle_input = menu.handle_input
+    def single_select_handle_input(choice):
+        # Only one can be True at a time
+        if choice in menu.key_map:
+            for k in menu.state:
+                menu.state[k] = False
+            menu.state[menu.key_map[choice]] = True
+            return True
+        return orig_handle_input(choice)
+    menu.handle_input = single_select_handle_input
+    menu.run()
+
+def display_statistics_table(stats):
+    """Display statistics in a modern table format"""
+    table = Table(
+        show_header=True,
+        header_style="bold cyan",
+        box=None,
+        padding=(0, 1)
+    )
+    
+    # Add columns
+    table.add_column("No.", style="dim", width=4)
+    table.add_column("Type", style="bold")
+    table.add_column("Description", style="italic")
+    table.add_column("Status", justify="center", width=4)
+    
+    # Add rows with statistical operations
+    features = [
+        ("1", "Descriptive Stats", "Calculate mean, median, mode, variance", "descriptive"),
+        ("2", "Regression", "Linear and non-linear regression analysis", "regression"),
+        ("3", "Correlation", "Measure relationships between variables", "correlation"),
+        ("4", "Hypothesis Test", "Test statistical significance", "hypothesis"),
+        ("5", "Time Series", "Analyze temporal data patterns", "timeseries"),
+        ("6", "Distribution", "Probability distribution analysis", "distribution")
+    ]
+    
+    for no, name, desc, key in features:
+        status = "✅" if stats.get(key, False) else "❌"
+        table.add_row(no, name, desc, status)
+        
+    # Create panel with table
+    panel = Panel(
+        table,
+        title="📊 Statistical Analysis",
+        border_style="cyan",
+        padding=(1, 2)
+    )
+    
+    console.print(panel)
+
+def animate_calculation():
+    with Progress(SpinnerColumn(), TextColumn("[progress.description]{task.description}"), transient=True) as progress:
+        task = progress.add_task("Calculating...", total=None)
+        time.sleep(1.5)
+        progress.update(task, description="Done!")
+        time.sleep(0.5)
+
+def animate_results_display(result_dict):
+    table = Table(title="Results", show_header=True, header_style="bold magenta")
+    table.add_column("Metric", style="cyan")
+    table.add_column("Value", style="green")
+    for k, v in result_dict.items():
+        table.add_row(str(k), str(v))
+    with Live(table, refresh_per_second=10):
+        time.sleep(1.2)
+
+def animate_data_loading():
+    """Animate data loading with a progress bar effect"""
+    console.print("\n")
+    for i in range(10):
+        progress = "█" * i + "░" * (10 - i)
+        console.print(f"\033[A\033[K[bold blue]Loading data: [{progress}] {i*10}%[/bold blue]")
+        time.sleep(0.2)
+    console.print("\n")
+
+def animate_export_progress():
+    """Animate export progress with a progress bar effect"""
+    console.print("\n")
+    for i in range(10):
+        progress = "█" * i + "░" * (10 - i)
+        console.print(f"\033[A\033[K[bold blue]Exporting results: [{progress}] {i*10}%[/bold blue]")
+        time.sleep(0.2)
+    console.print("\n") 
+
+def status_table(step, status):
+    table = Table(title="PyShell Statistics", show_header=True, header_style="bold blue")
+    table.add_column("Step", style="cyan")
+    table.add_column("Status", style="yellow")
+    table.add_row(step, status)
+    return table 
\ No newline at end of file
diff --git a/task.py b/task.py
deleted file mode 100644
index 681b6f6..0000000
--- a/task.py
+++ /dev/null
@@ -1,108 +0,0 @@
-# Task Scheduling
-
-from rich.console import Console
-import shlex, subprocess, time, schedule
-
-console = Console()
-scheduled_jobs = {}
-commands = {} 
-stop_scheduler = False 
-
-class Task:      
-    def execute_command(self, args):
-        if not args:
-            console.print("[bold red]No command entered![/bold red]")
-            return
-
-        command_name = args[0]
-        command_args = args[1:]
-
-        if command_name in commands:
-            try:
-                commands[command_name](*command_args) 
-            except TypeError as e:
-                console.print(f"[bold red]Error executing command '{command_name}': {e}[/bold red]")
-        else:
-            try:
-                subprocess.run([command_name] + command_args, check=True, text=True)
-            except FileNotFoundError:
-                console.print(f"[bold red]Unknown command: {command_name}. Type 'help' for a list of commands.[/bold red]")
-            except Exception as e:
-                console.print(f"[bold red]Error executing command: {e}[/bold red]")
-                
-    def run_scheduled_task(self, args=None):
-        """Executes a scheduled command."""
-        global stop_scheduler
-        
-        if stop_scheduler:
-            console.print("[bold red]Task execution stopped.[/bold red]")
-            return
-        
-        if args is None or len(args) < 3:
-            console.print("[bold red]Invalid task arguments![/bold red]")
-            return
-        
-        command = " ".join(args[2:])
-        console.print(f"[bold green]Running scheduled task:[/bold green] {command}")
-        
-        cmd_parts = shlex.split(command)
-        self.execute_command(cmd_parts)
-            
-    def schedule_task(self, args):
-        if len(args) < 3:
-            console.print("Usage: schedule <interval> <unit> <command>", style="bold red")
-            console.print("Example: schedule 10 seconds say 'Hello'", style="bold yellow")
-            return
-
-        try:
-            interval = int(args[0])
-        except ValueError:
-            console.print("[bold red]Invalid interval! Must be an integer.[/bold red]")
-            return
-
-        unit = args[1].lower()
-
-        if unit in ["seconds", "minutes", "hours"]:
-            job = getattr(schedule.every(interval), unit).do(self.run_scheduled_task, args)
-            job_id = len(scheduled_jobs) + 1
-            scheduled_jobs[job_id] = job
-            console.print(f"Task scheduled every {interval} {unit}. Task ID: {job_id}", style="bold cyan")
-        else:
-            console.print("[bold red]Invalid time unit! Use: seconds, minutes, or hours.[/bold red]")
-
-    def stop_running_tasks(self, *args):
-        """Sets the stop flag to True to prevent new tasks from running."""
-        global stop_scheduler
-        stop_scheduler = True
-        schedule.clear()
-        console.print("[bold red]Stopping all scheduled tasks...[/bold red]")
-
-    def run_scheduler(self):
-        """Continuously runs pending scheduled tasks in the background."""
-        while True:
-            schedule.run_pending()
-            time.sleep(1)  
-
-    def list_scheduled_tasks(self, _):
-        if not scheduled_jobs:
-            console.print("No scheduled tasks.", style="bold yellow")
-        else:
-            console.print("Scheduled Tasks:", style="bold cyan")
-            for job_id, job in scheduled_jobs.items():
-                console.print(f"[{job_id}] {job}", style="bold green")
-
-    def remove_scheduled_task(self, args):
-        if not args:
-            console.print("Usage: unschedule <task_id>", style="bold red")
-            return
-
-        try:
-            task_id = int(args[0])
-            if task_id in scheduled_jobs:
-                schedule.cancel_job(scheduled_jobs[task_id])
-                del scheduled_jobs[task_id]
-                console.print(f"Task {task_id} unscheduled.", style="bold yellow")
-            else:
-                console.print(f"No task found with ID {task_id}.", style="bold red")
-        except ValueError:
-            console.print("[bold red]Invalid task ID! Must be an integer.[/bold red]")
\ No newline at end of file
diff --git a/tasks.py b/tasks.py
new file mode 100644
index 0000000..6c9cbc6
--- /dev/null
+++ b/tasks.py
@@ -0,0 +1,238 @@
+import time
+import shlex
+import subprocess
+import schedule
+from rich.console import Console
+from rich.text import Text
+from menu_base import MojiSwitchMenu
+from statistics_menu import show_statistics_menu
+
+console = Console()
+
+scheduled_jobs = {}
+commands = {} 
+stop_scheduler = False 
+
+def animate_task_creation():
+    spinner = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"]
+    console.print("\n")
+    for _ in range(10):
+        for char in spinner:
+            console.print(f"\033[A\033[K[bold blue]{char} Creating task...[/bold blue]")
+            time.sleep(0.1)
+    console.print("\n")
+
+def animate_task_completion():
+    console.print("\n")
+    for i in range(3):
+        console.print("\033[A\033[K", end="")
+        if i == 0:
+            console.print("[grey50]✓ Task completed[/grey50]")
+        elif i == 1:
+            console.print("[bold blue]✓ Task completed[/bold blue]")
+        else:
+            console.print("[bold green]✓ Task completed[/bold green]")
+        time.sleep(0.2)
+    console.print("\n")
+
+def animate_task_deletion():
+    console.print("\n")
+    for i in range(3):
+        console.print("\033[A\033[K", end="")
+        if i == 0:
+            console.print("[bold red]Task deleted[/bold red]")
+        elif i == 1:
+            console.print("[red]Task deleted[/red]")
+        else:
+            console.print("[grey50]Task deleted[/grey50]")
+        time.sleep(0.2)
+    console.print("\n")
+
+def animate_task_scheduling():
+    console.print("\n")
+    for i in range(10):
+        progress = "█" * i + "░" * (10 - i)
+        console.print(f"\033[A\033[K[bold blue]Scheduling task: [{progress}] {i*10}%[/bold blue]")
+        time.sleep(0.2)
+    console.print("\n")
+
+def animate_task_list_display(tasks):
+    console.print("\n")
+    for i in range(3):
+        console.print("\033[A\033[K", end="")
+        if i == 0:
+            for task in tasks:
+                console.print(f"[grey50]{task}[/grey50]")
+        elif i == 1:
+            for task in tasks:
+                console.print(f"[bold blue]{task}[/bold blue]")
+        else:
+            for task in tasks:
+                console.print(f"[bold green]{task}[/bold green]")
+        time.sleep(0.2)
+    console.print("\n")
+
+class Task:
+    def __init__(self):
+        self.tasks = []  # Simple in-memory task list
+        self.completed = set()
+
+    def create_task(self, name):
+        self.tasks.append(name)
+        animate_task_creation()
+        console.print(f"[bold green]Task created:[/bold green] {name}")
+
+    def list_tasks(self):
+        if not self.tasks:
+            console.print("No tasks available.", style="bold yellow")
+        else:
+            animate_task_list_display(self.tasks)
+
+    def complete_task(self, idx):
+        try:
+            idx = int(idx) - 1
+            if 0 <= idx < len(self.tasks):
+                self.completed.add(self.tasks[idx])
+                animate_task_completion()
+                console.print(f"[bold green]Task completed:[/bold green] {self.tasks[idx]}")
+            else:
+                console.print("[bold red]Invalid task number![/bold red]")
+        except Exception:
+            console.print("[bold red]Invalid input![/bold red]")
+
+    def delete_task(self, idx):
+        try:
+            idx = int(idx) - 1
+            if 0 <= idx < len(self.tasks):
+                animate_task_deletion()
+                console.print(f"[bold yellow]Task deleted:[/bold yellow] {self.tasks[idx]}")
+                del self.tasks[idx]
+            else:
+                console.print("[bold red]Invalid task number![/bold red]")
+        except Exception:
+            console.print("[bold red]Invalid input![/bold red]")
+
+    def execute_command(self, args):
+        if not args:
+            console.print("[bold red]No command entered![/bold red]")
+            return
+        command_name = args[0]
+        command_args = args[1:]
+        if command_name in commands:
+            try:
+                commands[command_name](*command_args)
+            except TypeError as e:
+                console.print(f"[bold red]Error executing command '{command_name}': {e}[/bold red]")
+        else:
+            try:
+                subprocess.run([command_name] + command_args, check=True, text=True)
+            except FileNotFoundError:
+                console.print(f"[bold red]Unknown command: {command_name}. Type 'help' for a list of commands.[/bold red]")
+            except Exception as e:
+                console.print(f"[bold red]Error executing command: {e}[/bold red]")
+
+    def run_scheduled_task(self, args=None):
+        global stop_scheduler
+        if stop_scheduler:
+            console.print("[bold red]Task execution stopped.[/bold red]")
+            return
+        if args is None or len(args) < 3:
+            console.print("[bold red]Invalid task arguments![/bold red]")
+            return
+        command = " ".join(args[2:])
+        console.print(f"[bold green]Running scheduled task:[/bold green] {command}")
+        cmd_parts = shlex.split(command)
+        self.execute_command(cmd_parts)
+
+    def schedule_task(self, args):
+        if len(args) < 3:
+            console.print("Usage: schedule <interval> <unit> <command>", style="bold red")
+            console.print("Example: schedule 10 seconds say 'Hello'", style="bold yellow")
+            return
+        try:
+            interval = int(args[0])
+        except ValueError:
+            console.print("[bold red]Invalid interval! Must be an integer.[/bold red]")
+            return
+        unit = args[1].lower()
+        if unit in ["seconds", "minutes", "hours"]:
+            job = getattr(schedule.every(interval), unit).do(self.run_scheduled_task, args)
+            job_id = len(scheduled_jobs) + 1
+            scheduled_jobs[job_id] = job
+            animate_task_scheduling()
+            console.print(f"Task scheduled every {interval} {unit}. Task ID: {job_id}", style="bold cyan")
+        else:
+            console.print("[bold red]Invalid time unit! Use: seconds, minutes, or hours.[/bold red]")
+
+    def stop_running_tasks(self, *args):
+        global stop_scheduler
+        stop_scheduler = True
+        schedule.clear()
+        console.print("[bold red]Stopping all scheduled tasks...[/bold red]")
+
+    def run_scheduler(self):
+        while True:
+            schedule.run_pending()
+            time.sleep(1)
+
+    def list_scheduled_tasks(self, _=None):
+        if not scheduled_jobs:
+            console.print("No scheduled tasks.", style="bold yellow")
+        else:
+            console.print("Scheduled Tasks:", style="bold cyan")
+            for job_id, job in scheduled_jobs.items():
+                console.print(f"[{job_id}] {job}", style="bold green")
+
+    def remove_scheduled_task(self, args):
+        if not args:
+            console.print("Usage: unschedule <task_id>", style="bold red")
+            return
+        try:
+            task_id = int(args[0])
+            if task_id in scheduled_jobs:
+                schedule.cancel_job(scheduled_jobs[task_id])
+                del scheduled_jobs[task_id]
+                console.print(f"Task {task_id} unscheduled.", style="bold yellow")
+            else:
+                console.print(f"No task found with ID {task_id}.", style="bold red")
+        except ValueError:
+            console.print("[bold red]Invalid task ID! Must be an integer.[/bold red]")
+
+def show_tasks_menu():
+    options = [
+        ("📝 Create Task", "create"),
+        ("📋 List Tasks", "list"),
+        ("✅ Complete Task", "complete"),
+        ("❌ Delete Task", "delete"),
+        ("⏰ Schedule Task", "schedule"),
+        ("📊 Task Stats", "stats")
+    ]
+    task = Task()
+    def on_execute(state):
+        enabled_ops = [name for name, value in options if state[value]]
+        if not enabled_ops:
+            console.print("[bold red]No operations selected![/bold red]")
+            return
+        for op in enabled_ops:
+            if op == "📝 Create Task":
+                name = console.input("Enter task name: ")
+                task.create_task(name)
+            elif op == "📋 List Tasks":
+                task.list_tasks()
+            elif op == "✅ Complete Task":
+                idx = console.input("Enter task number to complete: ")
+                task.complete_task(idx)
+            elif op == "❌ Delete Task":
+                idx = console.input("Enter task number to delete: ")
+                task.delete_task(idx)
+            elif op == "⏰ Schedule Task":
+                args = console.input("Enter: <interval> <unit> <command>: ").split()
+                task.schedule_task(args)
+            elif op == "📊 Task Stats":
+                show_statistics_menu()
+    menu = MojiSwitchMenu(
+        title="📝 Task Operations",
+        options=options,
+        on_execute=on_execute
+    )
+    menu.run() 
\ No newline at end of file
diff --git a/terminals.py b/terminals.py
index 7f6ba1b..a170278 100644
--- a/terminals.py
+++ b/terminals.py
@@ -10,6 +10,17 @@
 from rich.prompt import Prompt
 import config
 import questionary
+import itertools
+from rich.color import Color
+from rich.segment import Segment
+from rich.style import Style
+import threading
+from rich.panel import Panel
+from rich.table import Table
+import msvcrt
+from rich.live import Live
+from menu_base import MojiSwitchMenu
+from features import smart_suggestions, nl_to_code, error_explainer, snippet_search, code_refactor
 
 console = Console()
 prompt = None
@@ -32,6 +43,118 @@ def get_prompt_flag(self):
         global prompt_flag
         return prompt_flag
 
+    def show_terminal_themes(self):
+        # Define options for terminal themes
+        options = [
+            ("🌙 Solarized Night", "solarized"),
+            ("💻 Hacker Green", "hacker"),
+            ("🧩 Agnoster", "agnoster"),
+            ("🟡 Marcduiker", "marcduiker"),
+            ("🧼 Clean Detailed", "clean"),
+            ("⚛️ Atomic-Lite", "atomic"),
+            ("🐍 PyShell Default", "default"),
+            ("🟦 Softline", "softline")
+        ]
+        
+        def on_execute(state):
+            # Find the selected theme
+            selected = [i for i, (_, value) in enumerate(options, 1) if state[value]]
+            if not selected:
+                console.print("[bold red]No theme selected![/bold red]")
+                return
+            theme_index = selected[0]
+            config.current_terminal_layout = theme_index
+            # Call the corresponding terminal_X method
+            getattr(self, f"terminal_{theme_index}")()
+            console.clear()
+            console.print(f"[bold green]Theme applied: {options[theme_index-1][0]}[/bold green]")
+        
+        # Create and run menu
+        menu = MojiSwitchMenu(
+            title="🎨 Terminal Themes",
+            options=options,
+            on_execute=on_execute
+        )
+
+        # --- SINGLE SELECTION LOGIC ---
+        orig_handle_input = menu.handle_input
+        def single_select_handle_input(choice):
+            # Only one can be True at a time
+            if choice in menu.key_map:
+                for k in menu.state:
+                    menu.state[k] = False
+                menu.state[menu.key_map[choice]] = True
+                return True
+            return orig_handle_input(choice)
+        menu.handle_input = single_select_handle_input
+        menu.run()
+        
+    def display_terminal_table(self, themes):
+        """Display terminal themes in a modern table format"""
+        table = Table(
+            show_header=True,
+            header_style="bold cyan",
+            box=None,
+            padding=(0, 1)
+        )
+        
+        # Add columns
+        table.add_column("No.", style="dim", width=4)
+        table.add_column("Theme", style="bold")
+        table.add_column("Description", style="italic")
+        table.add_column("Status", justify="center", width=4)
+        
+        # Add rows with theme types
+        features = [
+            ("1", "Solarized Night", "Dark theme with solarized colors", "solarized"),
+            ("2", "Hacker Green", "Classic terminal green on black", "hacker"),
+            ("3", "Agnoster", "Powerline-inspired theme", "agnoster"),
+            ("4", "Marcduiker", "Clean and minimal design", "marcduiker"),
+            ("5", "Clean Detailed", "Detailed information display", "clean"),
+            ("6", "Atomic-Lite", "Lightweight atomic design", "atomic"),
+            ("7", "PyShell Default", "Default PyShell theme", "default"),
+            ("8", "Softline", "Soft colors with line separators", "softline")
+        ]
+        
+        for no, name, desc, key in features:
+            status = "✅" if themes.get(key, False) else "❌"
+            table.add_row(no, name, desc, status)
+            
+        # Create panel with table
+        panel = Panel(
+            table,
+            title="🎨 Terminal Themes",
+            border_style="cyan",
+            padding=(1, 2)
+        )
+        
+        console.print(panel)
+
+    def animate_theme_change(self):
+        """Animate theme change with a progress bar effect"""
+        console.print("\n")
+        for i in range(10):
+            progress = "█" * i + "░" * (10 - i)
+            console.print(f"\033[A\033[K[bold blue]Changing theme: [{progress}] {i*10}%[/bold blue]")
+            time.sleep(0.2)
+        console.print("\n")
+
+    def animate_theme_display(self, themes):
+        """Animate theme display with a fade-in effect"""
+        console.print("\n")
+        for i in range(3):
+            console.print("\033[A\033[K", end="")
+            if i == 0:
+                for key, value in themes.items():
+                    console.print(f"[grey50]{key}: {value}[/grey50]")
+            elif i == 1:
+                for key, value in themes.items():
+                    console.print(f"[bold blue]{key}: {value}[/bold blue]")
+            else:
+                for key, value in themes.items():
+                    console.print(f"[bold green]{key}: {value}[/bold green]")
+            time.sleep(0.2)
+        console.print("\n")
 
     def terminal_1(self):
         cwd = os.getcwd().split(os.sep)
@@ -359,7 +482,7 @@ def terminal_8(self):
         # Gather information
         user = os.getenv("USER") or os.getenv("USERNAME") or "user"
         hostname = socket.gethostname().split('.')[0]
-        folder = os.path.basename(os.getcwd())
+        folder = os.getcwd().split(os.sep)[-1]
 
         # Git branch info
         try:
@@ -411,34 +534,13 @@ def change_terminal(self, *args):
 
         self.set_prompt_flag(False)  # Update the flag globally
 
-        choices = [
-            "1 - Solarized Night",
-            "2 - Hacker Green",
-            "3 - Agnoster",
-            "4 - Marcduiker",
-            "5 - Clean Detailed",
-            "6 - Atomic-Lite",
-            "7 - PyShell Default",
-            "8 - Softline"
-        ]
-
-        choice = questionary.select(
-            "Choose Terminal Layout:",
-            choices=choices
-        ).ask()
-
-        if not choice:
-            console.print("No choice made. Keeping current layout.", style="yellow")
-            return
-
-        current_terminal = int(choice.split(" - ")[0])
-        with open("config.py", "w") as f:
-            f.write(f"current_terminal_layout = {current_terminal}\n")
-        config.current_terminal_layout = current_terminal
-
+        # Use the new MojiSwitchMenu-based theme selector
+        self.show_terminal_themes()
+        # After theme selection, update config if needed
+        # (You may want to add logic here to update config.current_terminal_layout)
         console.clear()
-        console.print(f"Terminal switched to layout {current_terminal}!", style="bold green")
-
-        getattr(self, f"terminal_{current_terminal}")()
+        console.print(f"Terminal theme selection complete!", style="bold green")
+        # Optionally, update the prompt to reflect the new theme
+        # self.terminal_1() or similar, based on user selection
 
         
\ No newline at end of file
diff --git a/updates_to_read.md b/updates_to_read.md
new file mode 100644
index 0000000..73b5049
--- /dev/null
+++ b/updates_to_read.md
@@ -0,0 +1,63 @@
+# PyShell: The Future is Now! 🚀 (Recent Updates)
+
+Hey there! You've found the pulse of PyShell's latest evolution. We've been hard at work, not just adding features, but reimagining what a terminal experience can be. Think of this as a friendlier, smarter, and much more stylish version of the CLI you already love.
+
+Let's dive into what's new!
+
+---
+
+## 🤖 The AI Revolution: Your Personal Coding Assistant
+
+We've supercharged PyShell with a suite of powerful AI tools, all running on a local model to ensure your privacy and provide offline access. No more API keys needed! Just pure, unadulterated AI power at your fingertips.
+
+Access the **AI Panel** by simply typing:
+```sh
+~ai
+```
+
+This will open up a menu where you can toggle and use these amazing features:
+
+*   **🤖 Natural Language to Code:** Just describe what you want to do in plain English, and watch the AI generate the code for you.
+*   **🐞 Error Explainer:** Pasted a cryptic error message? The AI will break it down for you, explaining what went wrong and how to fix it.
+*   **🔍 Smart Snippet Search:** Find code snippets from your project or the web by describing what you're looking for.
+*   **✨ Code Refactor:** Clean up, optimize, or modernize your code with a single command.
+
+---
+
+## ✨ A Fresh New Look & Feel: UI & UX Reimagined
+
+We believe a tool should be as beautiful as it is functional. That's why we've given PyShell a complete aesthetic overhaul.
+
+### 🎨 **Vibrant & Aesthetic Animations**
+
+The first thing you'll notice is our new startup animation. We've replaced the old color scheme with a **mesmerizing wave of 16 vibrant, modern colors**.
+
+-   **Before**: A simple 8-color wave.
+-   **After**: A fluid, cyberpunk-inspired gradient of deep pinks, purples, cyans, and limes that makes starting PyShell a visual treat.
+
+The welcome message and final logo display have also been given a similar gradient treatment, making the entire startup sequence feel more dynamic and alive.
+
+### 💡 **Live Smart Suggestions**
+
+Ever get stuck wondering about a command's syntax? Worry no more! As you type, PyShell now provides **live suggestions** in a subtle toolbar at the bottom of your screen. It's like having a cheat sheet that updates in real-time, helping you learn and use commands faster.
+
+### 헬 **New `help` Command**
+
+We've added a simple and effective `help` command. Just type it in to see a clean, sorted list of all available commands.
+
+### 🧭 **Interactive Menu**
+
+Navigating menus is now a breeze. Use your **arrow keys** to move up and down, and press **Enter** to select. It's a small change that makes a world of difference in usability.
+
+---
+
+## 🔧 Core Enhancements
+
+Beyond the glitz and glamour, we've made some solid improvements to PyShell's core functionality.
+
+*   **📊 `stats` Command:** This command now opens a dedicated, interactive menu for all your statistical calculation needs.
+*   **📈 `plot` Command:** You can now create and visualize graphs directly from the terminal.
+*   **🎮 `games` Command:** We've laid the groundwork for a future gaming hub within PyShell.
+*   **Refined Command Structure:** We've cleaned up the command dictionary and argument handling to make the system more robust and easier to expand upon.
+
+We're incredibly excited about these updates and hope they make your command-line experience more productive, enjoyable, and inspiring. Happy coding! 
\ No newline at end of file
diff --git a/weather.py b/weather.py
index dce7a2e..09d2b18 100644
--- a/weather.py
+++ b/weather.py
@@ -1,37 +1,145 @@
 # Weather Information
 
-import requests, os
+import requests, os, time, msvcrt
 from rich.console import Console
+from rich.text import Text
+from prompt_toolkit import prompt
+from prompt_toolkit.key_binding import KeyBindings
+from prompt_toolkit.application import Application
+from prompt_toolkit.layout import Layout
+from prompt_toolkit.widgets import RadioList, Box, Frame
+from prompt_toolkit.layout.containers import HSplit
+from menu_base import MojiSwitchMenu
 
-class Weather:
-    def get_weather(self, args):
-        console = Console()
-        if not args:
-            console.print("Usage: weather <city>", style="bold red")
-            return
-
-        city = " ".join(args)
-        api_key = os.getenv("API_KEY")
-        url = f"http://api.openweathermap.org/data/2.5/weather?q={city}&appid={api_key}&units=metric"
+console = Console()
 
+class Weather:
+    def __init__(self):
+        self.api_key = os.getenv("OPENWEATHER_API_KEY")
+        if not self.api_key:
+            console.print("Warning: OPENWEATHER_API_KEY not set", style="bold yellow")
+    
+    def get_weather(self, city):
         try:
+            url = f"http://api.openweathermap.org/data/2.5/weather?q={city}&appid={self.api_key}&units=metric"
             response = requests.get(url)
             data = response.json()
-
-            if data["cod"] != 200:
+            
+            if response.status_code == 200:
+                weather_data = {
+                    'temp': data['main']['temp'],
+                    'wind': data['wind']['speed'],
+                    'humidity': data['main']['humidity']
+                }
+                animate_weather_loading()
+                animate_weather_display(weather_data)
+            else:
                 console.print(f"Error: {data['message']}", style="bold red")
-                return
+        except Exception as e:
+            console.print(f"Failed to fetch weather data: {e}", style="bold red")
 
-            weather_desc = data["weather"][0]["description"].capitalize()
-            temp = data["main"]["temp"]
-            humidity = data["main"]["humidity"]
-            wind_speed = data["wind"]["speed"]
+def show_weather_menu():
+    # Define options for weather operations
+    options = [
+        ("🌤️ Current Weather", "current"),
+        ("📅 5-Day Forecast", "forecast"),
+        ("🌡️ Temperature History", "history"),
+        ("🌪️ Weather Alerts", "alerts"),
+        ("📍 Change Location", "location"),
+        ("📊 Weather Stats", "stats")
+    ]
+    
+    def on_execute(state):
+        # Get list of enabled operations
+        enabled_ops = [name for name, value in options if state[value]]
+        if not enabled_ops:
+            console.print("[bold red]No operations selected![/bold red]")
+            return
+            
+        # Animate weather loading
+        animate_weather_loading()
+        
+        # Process each enabled operation
+        results = {}
+        for op in enabled_ops:
+            # Simulate weather data fetch
+            time.sleep(0.5)
+            results[op] = f"Weather data for {op}"
+            
+        # Display results
+        animate_weather_display(results)
+    
+    # Create and run menu
+    menu = MojiSwitchMenu(
+        title="🌤️ Weather Operations",
+        options=options,
+        on_execute=on_execute
+    )
+    menu.run()
 
-            console.print(f"\n[bold cyan]Weather in {city}:[/bold cyan]")
-            console.print(f"🌤️  {weather_desc}")
-            console.print(f"🌡️  Temperature: {temp}°C")
-            console.print(f"💧 Humidity: {humidity} %")
-            console.print(f"💨 Wind Speed: {wind_speed} m/s")
+def animate_weather_loading():
+    """Animate weather data loading with a spinning effect"""
+    spinner = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"]
+    console.print("\n")
+    for _ in range(20):  # 2 seconds of animation
+        for char in spinner:
+            console.print(f"\033[A\033[K[bold blue]{char} Fetching weather data...[/bold blue]")
+            time.sleep(0.1)
+    console.print("\n")
 
-        except Exception as e:
-            console.print(f"Failed to fetch weather data: {e}", style="bold red")
\ No newline at end of file
+def animate_weather_display(weather_data):
+    """Animate weather data display with a fade-in effect"""
+    console.print("\n")
+    for i in range(3):
+        console.print("\033[A\033[K", end="")
+        if i == 0:
+            for key, value in weather_data.items():
+                console.print(f"[grey50]{key}: {value}[/grey50]")
+        elif i == 1:
+            for key, value in weather_data.items():
+                console.print(f"[bold blue]{key}: {value}[/bold blue]")
+        else:
+            for key, value in weather_data.items():
+                console.print(f"[bold green]{key}: {value}[/bold green]")
+        time.sleep(0.2)
+    console.print("\n")
+
+def animate_forecast_loading():
+    """Animate forecast loading with a progress bar effect"""
+    console.print("\n")
+    for i in range(10):
+        progress = "█" * i + "░" * (10 - i)
+        console.print(f"\033[A\033[K[bold blue]Loading forecast: [{progress}] {i*10}%[/bold blue]")
+        time.sleep(0.2)
+    console.print("\n")
+
+def animate_location_change():
+    """Animate location change with a spinning effect"""
+    spinner = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"]
+    console.print("\n")
+    for _ in range(10):  # 1 second of animation
+        for char in spinner:
+            console.print(f"\033[A\033[K[bold blue]{char} Updating location...[/bold blue]")
+            time.sleep(0.1)
+    console.print("\n")
+
+def animate_forecast_display(forecast_data):
+    """Animate forecast data display with a slide-in effect"""
+    console.print("\n")
+    for day in forecast_data:
+        for i in range(3):
+            console.print("\033[A\033[K", end="")
+            if i == 0:
+                console.print(f"[grey50]📅 {day['date']}[/grey50]")
+                console.print(f"[grey50]🌡️ {day['temp']}°C[/grey50]")
+                console.print(f"[grey50]🌤️ {day['condition']}[/grey50]")
+            elif i == 1:
+                console.print(f"[bold blue]📅 {day['date']}[/bold blue]")
+                console.print(f"[bold blue]🌡️ {day['temp']}°C[/bold blue]")
+                console.print(f"[bold blue]🌤️ {day['condition']}[/bold blue]")
+            else:
+                console.print(f"[bold green]📅 {day['date']}[/bold green]")
+                console.print(f"[bold green]🌡️ {day['temp']}°C[/bold green]")
+                console.print(f"[bold green]🌤️ {day['condition']}[/bold green]")
+            time.sleep(0.2)
+        console.print("\n")
\ No newline at end of file