Update app.py

app.py

@@ -5,6 +5,7 @@ import torch
 import time
 import sys
 import subprocess
+import shlex
 from io import StringIO
 import contextlib
 from transformers import AutoTokenizer, AutoModelForCausalLM, pipeline
@@ -50,114 +51,237 @@ class FileSystem:
 
 fs = FileSystem()
 
-# --- Package Manager ---
-class PackageManager:
-    """Handles pip install/uninstall operations for the HF Space runtime."""
-    
-    @staticmethod
-    def install_package(package_name: str) -> str:
-        """Install a package using pip at runtime."""
-        if not package_name or not package_name.strip():
-            return "Error: No package name provided."
+# --- Terminal Engine ---
+class Terminal:
+    """A real interactive terminal that handles pip, shell commands, and python execution."""
+    
+    WELCOME = (
+        "Axon Pro Terminal v1.1\n"
+        "─────────────────────────────────────\n"
+        "  pip install <pkg>    Install packages\n"
+        "  pip uninstall <pkg>  Remove packages\n"
+        "  pip list             Show installed\n"
+        "  python <file.py>     Run a script\n"
+        "  Any shell command    ls, cat, echo, etc.\n"
+        "─────────────────────────────────────\n"
+    )
+    
+    BLOCKED_COMMANDS = [
+        "rm -rf /", "rm -rf /*", "mkfs", "dd if=", ":(){", "fork",
+        "shutdown", "reboot", "halt", "poweroff", "init 0", "init 6",
+    ]
+    
+    def __init__(self):
+        self.history: List[str] = [self.WELCOME]
+        self.env = {}  # Persistent Python globals across exec calls
+    
+    def get_log(self) -> str:
+        return "\n".join(self.history)
+    
+    def _append(self, text: str):
+        self.history.append(text)
+        # Keep buffer from growing forever (~500 lines max)
+        total_lines = sum(s.count("\n") + 1 for s in self.history)
+        while total_lines > 500 and len(self.history) > 1:
+            removed = self.history.pop(0)
+            total_lines -= removed.count("\n") + 1
+    
+    def _is_blocked(self, cmd: str) -> bool:
+        cmd_lower = cmd.lower().strip()
+        return any(b in cmd_lower for b in self.BLOCKED_COMMANDS)
+    
+    def run_command(self, cmd: str) -> str:
+        """Process a terminal command and return the full terminal log."""
+        cmd = cmd.strip()
+        if not cmd:
+            return self.get_log()
         
-        package_name = package_name.strip()
+        self._append(f"$ {cmd}")
         
-        # Basic safety check - block obviously dangerous inputs
-        dangerous = [";", "&&", "||", "|", ">", "<", "`", "$", "(", ")"]
-        if any(ch in package_name for ch in dangerous):
-            return "Error: Invalid characters in package name."
+        if self._is_blocked(cmd):
+            self._append("⛔ Command blocked for safety.")
+            return self.get_log()
         
-        try:
-            result = subprocess.run(
-                [sys.executable, "-m", "pip", "install", package_name],
-                capture_output=True,
-                text=True,
-                timeout=120  # 2 min timeout for large packages
-            )
-            
-            output = ""
-            if result.stdout:
-                # Filter to show only the important lines
-                lines = result.stdout.strip().split("\n")
-                important = [l for l in lines if any(kw in l.lower() for kw in 
-                    ["successfully", "already satisfied", "installing", "requirement", "downloading", "error", "warning"])]
-                output = "\n".join(important) if important else lines[-1]
-            
-            if result.returncode != 0:
-                error_msg = result.stderr.strip() if result.stderr else "Unknown error"
-                # Show last few lines of error (most relevant)
-                error_lines = error_msg.split("\n")[-5:]
-                return f"pip install {package_name} failed:\n" + "\n".join(error_lines)
-            
-            return f"✅ {output}"
-            
-        except subprocess.TimeoutExpired:
-            return f"Error: Installation of '{package_name}' timed out (>120s). Package may be too large."
-        except Exception as e:
-            return f"Error: {str(e)}"
+        parts = cmd.split()
+        base = parts[0].lower()
+        
+        if base == "clear":
+            self.history = []
+            return ""
+        elif base == "help":
+            self._append(self.WELCOME)
+        elif base in ("pip", "pip3"):
+            self._handle_pip(parts)
+        elif base in ("python", "python3"):
+            self._handle_python(cmd, parts)
+        else:
+            self._handle_shell(cmd)
+        
+        return self.get_log()
     
-    @staticmethod
-    def uninstall_package(package_name: str) -> str:
-        """Uninstall a package using pip."""
-        if not package_name or not package_name.strip():
-            return "Error: No package name provided."
+    def _handle_pip(self, parts: List[str]):
+        """Handle pip install/uninstall/list/show/freeze commands."""
+        if len(parts) < 2:
+            self._append("Usage: pip install <pkg> | pip uninstall <pkg> | pip list | pip show <pkg> | pip freeze")
+            return
+        
+        subcmd = parts[1].lower()
+        
+        if subcmd == "install" and len(parts) >= 3:
+            pkgs = parts[2:]
+            self._append(f"Installing: {' '.join(pkgs)}...")
+            try:
+                result = subprocess.run(
+                    [sys.executable, "-m", "pip", "install"] + pkgs,
+                    capture_output=True, text=True, timeout=180
+                )
+                stdout = result.stdout.strip()
+                stderr = result.stderr.strip()
+                
+                if result.returncode == 0:
+                    for line in stdout.split("\n"):
+                        low = line.lower()
+                        if any(kw in low for kw in ["successfully", "already satisfied", "requirement"]):
+                            self._append(line)
+                    if not any("successfully" in l.lower() or "already satisfied" in l.lower() for l in stdout.split("\n")):
+                        self._append(stdout.split("\n")[-1] if stdout else "Done.")
+                    self._append("✅ pip install completed")
+                else:
+                    err_lines = (stderr or stdout).split("\n")[-6:]
+                    for line in err_lines:
+                        self._append(line)
+                    self._append("❌ pip install failed")
+                    
+            except subprocess.TimeoutExpired:
+                self._append("❌ Timed out (>180s). Try a smaller package or check connection.")
+            except Exception as e:
+                self._append(f"❌ Error: {e}")
         
-        package_name = package_name.strip()
+        elif subcmd == "uninstall" and len(parts) >= 3:
+            pkg = parts[2]
+            protected = ["gradio", "torch", "transformers", "pip", "setuptools", "wheel", "numpy"]
+            if pkg.lower() in protected:
+                self._append(f"⛔ '{pkg}' is protected and cannot be uninstalled.")
+                return
+            self._append(f"Uninstalling {pkg}...")
+            try:
+                result = subprocess.run(
+                    [sys.executable, "-m", "pip", "uninstall", "-y", pkg],
+                    capture_output=True, text=True, timeout=60
+                )
+                if result.returncode == 0:
+                    self._append(f"✅ Uninstalled {pkg}")
+                else:
+                    self._append(f"❌ {result.stderr.strip()}")
+            except Exception as e:
+                self._append(f"❌ Error: {e}")
         
-        # Protect critical packages from uninstall
-        protected = ["gradio", "torch", "transformers", "pip", "setuptools", "wheel"]
-        if package_name.lower() in protected:
-            return f"Error: '{package_name}' is a protected system package and cannot be uninstalled."
+        elif subcmd == "list":
+            try:
+                result = subprocess.run(
+                    [sys.executable, "-m", "pip", "list", "--format=columns"],
+                    capture_output=True, text=True, timeout=30
+                )
+                self._append(result.stdout.strip() if result.stdout else "No packages found.")
+            except Exception as e:
+                self._append(f"Error: {e}")
         
-        try:
-            result = subprocess.run(
-                [sys.executable, "-m", "pip", "uninstall", "-y", package_name],
-                capture_output=True,
-                text=True,
-                timeout=60
-            )
-            
-            if result.returncode != 0:
-                return f"Error: {result.stderr.strip()}"
-            
-            return f"✅ Uninstalled '{package_name}'"
-            
-        except Exception as e:
-            return f"Error: {str(e)}"
+        elif subcmd == "show" and len(parts) >= 3:
+            try:
+                result = subprocess.run(
+                    [sys.executable, "-m", "pip", "show", parts[2]],
+                    capture_output=True, text=True, timeout=15
+                )
+                if result.returncode == 0:
+                    self._append(result.stdout.strip())
+                else:
+                    self._append(f"Package '{parts[2]}' not found.")
+            except Exception as e:
+                self._append(f"Error: {e}")
+        
+        elif subcmd == "freeze":
+            try:
+                result = subprocess.run(
+                    [sys.executable, "-m", "pip", "freeze"],
+                    capture_output=True, text=True, timeout=30
+                )
+                self._append(result.stdout.strip() if result.stdout else "No packages.")
+            except Exception as e:
+                self._append(f"Error: {e}")
+        
+        else:
+            self._append(f"pip {subcmd}: unsupported. Use install, uninstall, list, show, freeze.")
     
-    @staticmethod
-    def list_packages() -> str:
-        """List installed packages."""
+    def _handle_python(self, cmd: str, parts: List[str]):
+        """Handle: python file.py, python -c 'code', python -m module."""
+        if len(parts) < 2:
+            self._append(f"Python {sys.version.split()[0]}")
+            return
+        
+        if parts[1] == "-c" and len(parts) >= 3:
+            code = cmd.split("-c", 1)[1].strip().strip("'\"")
+            self._exec_python(code)
+        elif parts[1] == "-m" and len(parts) >= 3:
+            try:
+                result = subprocess.run(
+                    [sys.executable] + parts[1:],
+                    capture_output=True, text=True, timeout=30
+                )
+                if result.stdout:
+                    self._append(result.stdout.strip())
+                if result.stderr:
+                    self._append(result.stderr.strip())
+            except subprocess.TimeoutExpired:
+                self._append("Process timed out (30s limit).")
+            except Exception as e:
+                self._append(f"Error: {e}")
+        else:
+            filename = parts[1]
+            if filename in fs.files:
+                self._exec_python(fs.files[filename])
+            elif os.path.exists(filename):
+                with open(filename, "r") as f:
+                    self._exec_python(f.read())
+            else:
+                self._append(f"File not found: {filename}")
+    
+    def _exec_python(self, code: str):
+        """Execute python code with persistent globals and capture output."""
+        buf = StringIO()
+        start = time.time()
         try:
-            result = subprocess.run(
-                [sys.executable, "-m", "pip", "list", "--format=columns"],
-                capture_output=True,
-                text=True,
-                timeout=30
-            )
-            return result.stdout if result.stdout else "No packages found."
+            with contextlib.redirect_stdout(buf):
+                exec(code, self.env)
+            elapsed = time.time() - start
+            out = buf.getvalue()
+            if out:
+                self._append(out.rstrip())
+            self._append(f"[Done in {elapsed:.4f}s]")
         except Exception as e:
-            return f"Error: {str(e)}"
+            out = buf.getvalue()
+            if out:
+                self._append(out.rstrip())
+            self._append(f"Error: {e}")
     
-    @staticmethod
-    def search_package_info(package_name: str) -> str:
-        """Show info about an installed package."""
-        if not package_name or not package_name.strip():
-            return "Error: No package name provided."
+    def _handle_shell(self, cmd: str):
+        """Handle generic shell commands."""
         try:
             result = subprocess.run(
-                [sys.executable, "-m", "pip", "show", package_name.strip()],
-                capture_output=True,
-                text=True,
-                timeout=15
+                cmd, shell=True,
+                capture_output=True, text=True, timeout=30
             )
-            if result.returncode != 0:
-                return f"Package '{package_name.strip()}' is not installed."
-            return result.stdout
+            if result.stdout:
+                self._append(result.stdout.rstrip())
+            if result.stderr:
+                self._append(result.stderr.rstrip())
+            if result.returncode != 0 and not result.stdout and not result.stderr:
+                self._append(f"Command exited with code {result.returncode}")
+        except subprocess.TimeoutExpired:
+            self._append("⏱ Command timed out (30s limit).")
         except Exception as e:
-            return f"Error: {str(e)}"
+            self._append(f"Error: {e}")
 
-pkg_mgr = PackageManager()
+terminal_engine = Terminal()
 
 # --- Model Loading ---
 @lru_cache(maxsize=1)
@@ -187,62 +311,29 @@ def load_model():
         print(f"Error loading model: {e}")
         return None
 
-# --- Logic Functions ---
+# --- AI Functions ---
 
-def run_code(code: str) -> Tuple[str, str]:
-    """Executes Python code and captures stdout. Supports !pip commands."""
-    
-    # Check if code contains !pip install lines (Jupyter-style)
-    lines = code.strip().split("\n")
-    pip_lines = [l for l in lines if l.strip().startswith("!pip ") or l.strip().startswith("!pip3 ")]
-    code_lines = [l for l in lines if not l.strip().startswith("!pip ") and not l.strip().startswith("!pip3 ")]
-    
-    output_parts = []
-    
-    # Handle any !pip commands first
-    for pip_line in pip_lines:
-        cmd = pip_line.strip().lstrip("!")  # Remove the "!" prefix
-        parts = cmd.split()
-        if len(parts) >= 3 and parts[1] == "install":
-            pkg = " ".join(parts[2:])  # Support version specifiers like "pygame==2.5.0"
-            result = pkg_mgr.install_package(pkg)
-            output_parts.append(f">>> {pip_line.strip()}\n{result}")
-        elif len(parts) >= 3 and parts[1] == "uninstall":
-            pkg = parts[2]
-            result = pkg_mgr.uninstall_package(pkg)
-            output_parts.append(f">>> {pip_line.strip()}\n{result}")
-        elif len(parts) >= 2 and parts[1] == "list":
-            result = pkg_mgr.list_packages()
-            output_parts.append(f">>> {pip_line.strip()}\n{result}")
-        else:
-            output_parts.append(f">>> {pip_line.strip()}\nUnsupported pip command. Use: !pip install <pkg>, !pip uninstall <pkg>, !pip list")
-    
-    # Run remaining Python code
-    remaining_code = "\n".join(code_lines).strip()
-    if remaining_code:
-        start_time = time.time()
-        output_buffer = StringIO()
-        
-        try:
-            with contextlib.redirect_stdout(output_buffer):
-                exec(remaining_code, {}, {})
-            
-            exec_time = time.time() - start_time
-            result = output_buffer.getvalue()
-            if not result:
-                result = "(No output)"
-                
-            output_parts.append(f"{result}\n[Execution time: {exec_time:.4f}s]")
-        except Exception as e:
-            output_parts.append(f"{output_buffer.getvalue()}\n=== ERROR ===\nTraceback (most recent call last):\n{str(e)}")
-    
-    combined = "\n\n".join(output_parts)
-    return combined, ""
+def run_editor_code(code: str) -> str:
+    """Run code from the ▶ Run button and pipe output into the terminal."""
+    buf = StringIO()
+    start = time.time()
+    try:
+        with contextlib.redirect_stdout(buf):
+            exec(code, {}, {})
+        elapsed = time.time() - start
+        result = buf.getvalue()
+        if not result:
+            result = "(No output)"
+        terminal_engine._append(f"$ python [editor]\n{result.rstrip()}\n[Done in {elapsed:.4f}s]")
+        return terminal_engine.get_log()
+    except Exception as e:
+        out = buf.getvalue()
+        terminal_engine._append(f"$ python [editor]\n{out}Error: {e}")
+        return terminal_engine.get_log()
 
 def generate_completion(code: str) -> str:
     model = load_model()
     if not model: return "# Error: Model failed to load."
-    
     prompt = f"<|system|>You are a Python expert. Complete the code. No explanations.</s><|user|>\n{code}\n</s><|assistant|>"
     try:
         result = model(prompt, num_return_sequences=1, return_full_text=False)
@@ -281,10 +372,8 @@ def generate_code(prompt_text: str) -> str:
         return str(e)
 
 def create_diff_view(original: str, modified: str) -> str:
-    lines_original = original.splitlines()
-    lines_modified = modified.splitlines()
     import difflib
-    diff = difflib.unified_diff(lines_original, lines_modified, lineterm="")
+    diff = difflib.unified_diff(original.splitlines(), modified.splitlines(), lineterm="")
     return "\n".join(diff)
 
 # --- Gradio UI ---
@@ -303,10 +392,20 @@ theme = gr.themes.Default(
 css = """
     * { border-radius: 0 !important; } 
     .editor-container { height: 50vh; }
-    .terminal { height: 15vh; background-color: #1e1e1e; color: #d4d4d4; font-family: 'JetBrains Mono', monospace; }
+    .terminal-box textarea { 
+        background-color: #0d0d0d !important; 
+        color: #00ff41 !important; 
+        font-family: 'JetBrains Mono', monospace !important; 
+        font-size: 13px !important;
+    }
+    .terminal-input input {
+        background-color: #0d0d0d !important;
+        color: #00ff41 !important;
+        font-family: 'JetBrains Mono', monospace !important;
+        border: 1px solid #333 !important;
+    }
     .diff-view { height: 40vh; }
     .code-wrap { white-space: pre-wrap !important; }
-    .pkg-output { font-family: 'JetBrains Mono', monospace; font-size: 0.85em; }
 """
 
 with gr.Blocks(title="Axon Pro - Python IDE") as demo:
@@ -350,14 +449,23 @@ with gr.Blocks(title="Axon Pro - Python IDE") as demo:
                         
                     with gr.Tabs():
                         with gr.Tab("Terminal", id="terminal-tab"):
-                            terminal = gr.Textbox(
-                                value=">>> Ready to run Python code...\n>>> Tip: Use !pip install <package> in your code to install packages", 
-                                lines=6, 
+                            terminal_output = gr.Textbox(
+                                value=terminal_engine.get_log(), 
+                                lines=10, 
                                 interactive=False,
-                                elem_classes="terminal",
-                                label="Output"
+                                elem_classes="terminal-box",
+                                label="Terminal",
+                                show_label=False
                             )
-                            clear_btn = gr.Button("Clear Output", variant="secondary", size="sm")
+                            with gr.Row():
+                                terminal_input = gr.Textbox(
+                                    placeholder="$ pip install pygame, ls, python main.py ...",
+                                    scale=8,
+                                    container=False,
+                                    elem_classes="terminal-input"
+                                )
+                                terminal_run_btn = gr.Button("⏎", variant="primary", scale=1, min_width=50)
+                            clear_btn = gr.Button("Clear", variant="secondary", size="sm")
                         
                         with gr.Tab("AI Chat", id="chat-tab"):
                             chat_history = gr.Chatbot(label="Axon AI", height=300)
@@ -365,42 +473,13 @@ with gr.Blocks(title="Axon Pro - Python IDE") as demo:
                                 chat_input = gr.Textbox(placeholder="Ask to generate Python code...", scale=7, container=False)
                                 send_btn = gr.Button("Generate", variant="primary", scale=1)
         
-        # --- Package Manager Tab ---
-        with gr.Tab("📦 Packages", id="pkg-tab"):
-            gr.Markdown("### Package Manager")
-            gr.Markdown("Install, uninstall, and manage Python packages at runtime.")
-            
-            with gr.Row():
-                with gr.Column(scale=3):
-                    pkg_name_input = gr.Textbox(
-                        placeholder="e.g. pygame, requests, numpy==1.24.0",
-                        label="Package Name",
-                        container=True
-                    )
-                with gr.Column(scale=1):
-                    with gr.Row():
-                        install_btn = gr.Button("📥 Install", variant="primary")
-                        uninstall_btn = gr.Button("🗑️ Uninstall", variant="secondary")
-            
-            with gr.Row():
-                list_btn = gr.Button("📋 List Installed", variant="secondary")
-                info_btn = gr.Button("ℹ️ Package Info", variant="secondary")
-            
-            pkg_output = gr.Textbox(
-                value="Package manager ready. Install any pip package here.\n\nYou can also use !pip install <package> directly in the editor.",
-                label="Output",
-                lines=12,
-                interactive=False,
-                elem_classes="pkg-output"
-            )
-        
         with gr.Tab("Diff View", id="diff-tab"):
             diff_view = gr.Code(label="AI Changes", language="python", elem_classes="diff-view code-wrap", interactive=False)
             with gr.Row():
                 apply_btn = gr.Button("Apply Changes", variant="primary")
                 discard_btn = gr.Button("Discard Changes", variant="secondary")
     
-    status_bar = gr.Markdown(f"**AXON PRO v1.1** | Python 3.x | CPU Mode | TinyLlama-1.1B | pip enabled", elem_classes="status-bar")
+    status_bar = gr.Markdown("**AXON PRO v1.1** | Python 3.x | CPU Mode | TinyLlama-1.1B | Terminal + pip", elem_classes="status-bar")
     
     # State
     current_file_state = gr.State(fs.current_file)
@@ -408,7 +487,7 @@ with gr.Blocks(title="Axon Pro - Python IDE") as demo:
     diff_modified_state = gr.State("")
     diff_mode_state = gr.State(False)
     
-    # --- Editor Functions ---
+    # --- Functions ---
     def update_file(content):
         fs.save_file(content)
         return fs.get_current_file_content()
@@ -423,11 +502,13 @@ with gr.Blocks(title="Axon Pro - Python IDE") as demo:
             return gr.update(choices=fs.get_all_files(), value=name), fs.get_current_file_content()
         return gr.update(choices=fs.get_all_files()), fs.get_current_file_content()
     
-    def run_wrapper(content):
-        out, err = run_code(content)
-        if err:
-            return f"{out}\n\n=== ERROR ===\n{err}"
-        return out
+    def terminal_command(cmd):
+        log = terminal_engine.run_command(cmd)
+        return log, ""
+    
+    def clear_terminal():
+        terminal_engine.history = []
+        return ""
     
     def complete_wrapper(content):
         comp = generate_completion(content)
@@ -453,33 +534,19 @@ with gr.Blocks(title="Axon Pro - Python IDE") as demo:
         new_hist = history + [[prompt, "Generated code available in Diff View"]]
         return diff, "", generated, True, new_hist, ""
 
-    # --- Package Manager Functions ---
-    def install_wrapper(pkg_name):
-        if not pkg_name:
-            return "Please enter a package name."
-        return pkg_mgr.install_package(pkg_name)
-    
-    def uninstall_wrapper(pkg_name):
-        if not pkg_name:
-            return "Please enter a package name."
-        return pkg_mgr.uninstall_package(pkg_name)
-    
-    def list_wrapper():
-        return pkg_mgr.list_packages()
-    
-    def info_wrapper(pkg_name):
-        if not pkg_name:
-            return "Please enter a package name."
-        return pkg_mgr.search_package_info(pkg_name)
-
-    # --- Wiring: Editor ---
+    # --- Wiring ---
     editor.change(update_file, editor, None)
     file_list.change(load_file, file_list, [editor, current_file_state])
     new_file_btn.click(create_file, new_file_name, [file_list, editor])
     
-    run_btn.click(run_wrapper, editor, terminal)
+    # Terminal — type commands and hit enter or click ⏎
+    terminal_input.submit(terminal_command, terminal_input, [terminal_output, terminal_input])
+    terminal_run_btn.click(terminal_command, terminal_input, [terminal_output, terminal_input])
+    clear_btn.click(clear_terminal, None, terminal_output)
+    
+    # Run button pipes editor code into terminal
+    run_btn.click(run_editor_code, editor, terminal_output)
     complete_btn.click(complete_wrapper, editor, editor)
-    clear_btn.click(lambda: ">>> Ready...", None, terminal)
     
     explain_btn.click(
         explain_wrapper, editor, 
@@ -503,12 +570,6 @@ with gr.Blocks(title="Axon Pro - Python IDE") as demo:
     discard_btn.click(
         lambda: (gr.update(), False), None, [editor, diff_mode_state]
     ).then(lambda: gr.Tabs(selected="editor-tab"), None, main_tabs)
-    
-    # --- Wiring: Package Manager ---
-    install_btn.click(install_wrapper, pkg_name_input, pkg_output)
-    uninstall_btn.click(uninstall_wrapper, pkg_name_input, pkg_output)
-    list_btn.click(list_wrapper, None, pkg_output)
-    info_btn.click(info_wrapper, pkg_name_input, pkg_output)
 
 if __name__ == "__main__":
     demo.launch(