Update demo.py

demo.py

@@ -18,13 +18,12 @@ try:
 except ImportError:
     E2B_AVAILABLE = False
 
-# Import for Web Search (DuckDuckGo is much more stable than raw Google scraping)
+# Import for Web Search
 try:
     from ddgs import DDGS
     SEARCH_AVAILABLE = True
 except ImportError:
     SEARCH_AVAILABLE = False
-    print("⚠️ 'duckduckgo-search' not found. Install it via: pip install ddgs")
 
 # Setup logging
 logging.basicConfig(level=logging.INFO)
@@ -35,27 +34,66 @@ logger = logging.getLogger("FyodorIDE")
 MINIMAX_API_KEY = os.getenv("MINIMAX_API_KEY")
 E2B_API_KEY = os.getenv("E2B_API_KEY")
 
-# Client Configuration
 API_CONFIG = {
     "api_key": MINIMAX_API_KEY if MINIMAX_API_KEY else "dummy-key",
     "base_url": "https://api.minimax.io/v1",
 }
 MODEL_ID = "MiniMax-M2"
+SESSION_TIMEOUT_SEC = 15 * 60
 
-# Session Duration (in seconds)
-SESSION_TIMEOUT_SEC = 15 * 60  # 15 Minutes
+# ==================== HELPER FUNCTIONS ====================
+
+def clean_thought_process(text):
+    """Removes the <think>...</think> blocks from the text to prevent leaks."""
+    return re.sub(r"<think>.*?</think>", "", text, flags=re.DOTALL).strip()
+
+def export_script(code):
+    if not code.strip(): return None
+    try:
+        with tempfile.NamedTemporaryFile(mode='w', delete=False, suffix='.py', prefix='fyodor_script_') as f:
+            f.write(code)
+            return f.name
+    except Exception as e:
+        return None
+
+def robust_search(query):
+    if not SEARCH_AVAILABLE: return json.dumps({"error": "Missing duckduckgo-search"})
+    try:
+        results = []
+        with DDGS() as ddgs:
+            for idx, r in enumerate(list(ddgs.text(query, max_results=5)), 1):
+                results.append({
+                    "title": r.get('title'),
+                    "link": r.get('href'),
+                    "snippet": r.get('body')
+                })
+        return json.dumps(results, indent=2)
+    except Exception as e:
+        return json.dumps({"error": str(e)})
 
-# ==================== TOOL: E2B SANDBOX ====================
+# ==================== TOOL: E2B SANDBOX (MULTI-FILE) ====================
 
-def execute_code_e2b(code_block):
+def execute_code_e2b(project_state):
+    """
+    Writes ALL files in the project to the sandbox, then runs main.py.
+    """
     if not E2B_AVAILABLE or not E2B_API_KEY:
         return "❌ Error: E2B API Key missing. Cannot execute code."
 
-    logger.info("⚡ Executing in E2B Sandbox (ISOLATED - No Internet Access)...")
+    code_to_run = project_state.get("main.py", "")
+    if not code_to_run.strip():
+        return "⚠️ 'main.py' is empty. Nothing to run."
+
+    logger.info("⚡ Executing in E2B Sandbox (Multi-File)...")
     try:
-        # Create a fully isolated sandbox with NO internet access
         with Sandbox.create(allow_internet_access=False) as sandbox:
-            execution = sandbox.run_code(code_block)
+            # 1. Write all auxiliary files to the sandbox filesystem
+            for filename, content in project_state.items():
+                if filename != "main.py":
+                    sandbox.files.write(filename, content)
+            
+            # 2. Run main.py
+            execution = sandbox.run_code(code_to_run)
             
             output_parts = []
             if execution.logs.stdout:
@@ -73,258 +111,76 @@ def execute_code_e2b(code_block):
     except Exception as e:
         return f"❌ Sandbox Error: {str(e)}"
 
-# ==================== HELPER FUNCTIONS ====================
-
-def export_script(code):
-    """Saves the current code to a temporary .py file for download."""
-    if not code.strip():
-        return None
-    
-    try:
-        with tempfile.NamedTemporaryFile(mode='w', delete=False, suffix='.py', prefix='fyodor_script_') as f:
-            f.write(code)
-            return f.name
-    except Exception as e:
-        logger.error(f"Export failed: {e}")
-        return None
+# ==================== CORE LOGIC ====================
 
-def execute_modified_code(code, chatbot, session_data):
-    """Executes manually modified code and updates chat history."""
-    if session_data is None:
-        session_data = init_session()
-    
-    elapsed = time.time() - session_data["start_time"]
-    if elapsed >= SESSION_TIMEOUT_SEC:
-        logger.info("🔄 Session expired during execution - Auto-renewing...")
-        session_data = init_session()
-        
-    history = session_data["history"]
-        
-    if not code.strip():
-        # Return current history (list of dicts) if no code
-        return history
-    
-    # 1. Append User Action
-    history.append({"role": "user", "content": "🔄 **User Modified Code Execution**"})
-    
-    # 2. Execute Code
-    result = execute_code_e2b(code)
-    
-    # 3. Append Assistant Result
-    history.append({"role": "assistant", "content": f"**Execution Result:**\n\n{result}"})
-    
-    # 4. Return the updated history list (Gradio Messages format)
-    # DO NOT use legacy list of lists format: chatbot + [[msg1, msg2]]
-    return history
-
-# ==================== ROBUST WEB SEARCH (DuckDuckGo) ====================
-
-def search_web(query, max_results=6):
+def init_session():
+    return {"history": [], "start_time": time.time(), "active": True}
+
+def get_system_prompt(mode):
+    base_prompt = """
+You are Fyodor, an advanced AI-Native IDE engine.
+You are running in a FULLY ISOLATED E2B Sandbox (No Internet).
+You have access to a Multi-File Project environment.
+
+FILESYSTEM RULES:
+- The main entry point is always 'main.py'.
+- You can create helper modules (e.g., 'utils.py', 'data_loader.py') and import them in 'main.py'.
+- When providing code, specify the filename if strictly necessary, but default to 'main.py'.
+
+COMMANDS:
+- CODE: Use ```python ... ``` blocks.
+- ANSWER: Plain text explanations.
+"""
+    if mode == "Data Mode":
+        return base_prompt + "\n\nMODE: DATA ANALYSIS\n- Focus on pandas, numpy, and statistical insights.\n- Prefer tabular outputs and data cleaning suggestions.\n- Assume data files might need generation or simulation."
+    elif mode == "Visualization Mode":
+        return base_prompt + "\n\nMODE: VISUALIZATION\n- Focus on matplotlib/seaborn.\n- Create visually striking plots.\n- Always ensure `plt.show()` is called.\n- Use dark backgrounds to match the IDE theme."
+    else: # Code Mode
+        return base_prompt + "\n\nMODE: GENERAL CODING\n- Focus on clean, modular, and efficient Python code.\n- Suggest refactoring where appropriate."
+
+def parse_code_update(text, current_project, active_file):
     """
-    Searches the web using DuckDuckGo.
-    Returns strict JSON output to ensure clean data for agents.
+    Parses LLM output for code blocks. 
+    Updates the ACTIVE file with the last code block found.
     """
-    if not SEARCH_AVAILABLE:
-        return json.dumps({"error": "`duckduckgo-search` library not installed"})
-
-    logger.info(f"🔍 Searching Web for: {query}")
-    
-    try:
-        results = []
-        # DDGS() is the context manager for DuckDuckGo Search
-        with DDGS() as ddgs:
-            # .text() performs a standard text search
-            ddg_results = list(ddgs.text(query, max_results=max_results))
-            
-            if not ddg_results:
-                return json.dumps({"status": "no_results", "query": query})
-
-            for idx, r in enumerate(ddg_results, 1):
-                results.append({
-                    "position": idx,
-                    "title": r.get('title', 'No Title'),
-                    "url": r.get('href', '#'),
-                    "snippet": r.get('body', 'No description available')
-                })
-
-        # Return strictly JSON
-        return json.dumps(results, indent=2)
-
-    except Exception as e:
-        logger.error(f"Search failed: {e}")
-        return json.dumps({"error": "Search Failed", "details": str(e)})
-
-# ==================== MINI AGENT (CHAT + SEARCH) ====================
-
-def mini_agent_chat(message, history):
-    """Lightweight chat agent with robust Web Search"""
-    if not message.strip():
-        yield history
-        return
-    
-    if not isinstance(history, list):
-        history = []
-    
-    history.append({"role": "user", "content": message})
-    yield history
-    
-    try:
-        client = OpenAI(**API_CONFIG)
-        
-        # Detect if search is needed
-        search_keywords = [
-            "latest", "current", "recent", "today", "news", "who is", "search", 
-            "find", "lookup", "google", "weather", "price", "review", "meaning",
-            "location", "what happened", "how to", "top", "best"
-        ]
-        needs_search = any(keyword in message.lower() for keyword in search_keywords)
-        
-        # Build messages
-        messages = [
-            {"role": "system", "content": "You are a helpful assistant with web access. Be concise. Mention when searching."}
-        ]
-        messages.extend(history[-6:])
-        
-        # Stream response
-        response = client.chat.completions.create(
-            model=MODEL_ID,
-            messages=messages,
-            temperature=0.7,
-            max_tokens=4000,
-            stream=True
-        )
-        
-        full_response = ""
-        history.append({"role": "assistant", "content": ""})
-        
-        for chunk in response:
-            if chunk.choices and chunk.choices[0].delta:
-                delta_content = chunk.choices[0].delta.content
-                if delta_content:
-                    full_response += delta_content
-                    clean_response = re.sub(r"<think>.*?</think>", "", full_response, flags=re.DOTALL).strip()
-                    history[-1]["content"] = clean_response
-                    yield history
-        
-        # Perform search if needed
-        if needs_search:
-            history[-1]["content"] += "\n\n🔍 *Searching Web...*"
-            yield history
-            
-            # Use the new robust search function
-            search_results = search_web(message)
-            
-            # Display as JSON code block
-            history[-1]["content"] = full_response + f"\n\n---\n```json\n{search_results}\n```"
-            yield history
-    
-    except Exception as e:
-        if history and history[-1]["role"] == "assistant":
-            history[-1]["content"] = f"❌ Error: {str(e)}"
-        else:
-            history.append({"role": "assistant", "content": f"❌ Error: {str(e)}"})
-        yield history
-
-# ==================== SYSTEM PROMPT ====================
-
-SYSTEM_PROMPT = """
-You are the intelligent engine behind Fyodor IDE.
-You are running in a FULLY ISOLATED E2B Sandbox with ZERO internet access.
-
-### CRITICAL SECURITY NOTICE
-🔒 This sandbox has NO internet connectivity. All network requests are blocked.
-- Cannot access external APIs (OpenAI, HuggingFace, etc.)
-- Cannot download files from the web
-- Cannot make HTTP/HTTPS requests
-- Cannot use pip install (packages must be pre-installed)
-
-### MISSION
-- Write Python code to solve user tasks USING ONLY LOCAL RESOURCES.
-- Execute the code to verify results or generate visualizations.
-- Accept user feedback to iteratively improve the code.
-
-### COMMANDS
-1. **CODE:**
-   - Use this to write and execute Python code.
-   - Format:
-     CODE:
-     ```python
-     # code here
-     ```
-
-2. **ANSWER:**
-   - Use this for explanations or confirming completion.
-
-### RULES
-- **Fully Isolated**: This sandbox is COMPLETELY OFFLINE. Do NOT attempt any network operations.
-- **Pre-installed Libraries Only**: Use standard libraries (numpy, matplotlib, pandas, etc.) that are already installed.
-- **Visualization**: Use `matplotlib.pyplot` for plots. Always call `plt.show()`.
-- **Self-Correction**: If the user gives feedback (e.g., "Change color to red"), rewrite the code with the fix.
-- **No User Input**: Do not use `input()`. Hardcode variables for demonstration.
-- **Local Data Only**: Work with generated data, mathematical functions, or data the user provides directly.
-"""
-
-# ==================== AGENT LOGIC ====================
-
-def parse_command(text):
-    clean_text = re.sub(r"<think>.*?</think>", "", text, flags=re.DOTALL).strip()
-    
+    clean_text = clean_thought_process(text)
     if "```python" in clean_text:
         pattern = r"```python\n(.*?)```"
         matches = re.findall(pattern, clean_text, re.DOTALL)
-        code = matches[-1] if matches else None
-        return "CODE", code, clean_text
-        
-    return "ANSWER", None, clean_text
-
-def init_session():
-    return {
-        "history": [],
-        "start_time": time.time(),
-        "active": True
-    }
-
-def check_session_status(session_data):
-    """Real-time timer callback with auto-renewal."""
-    if session_data is None:
-        session_data = init_session()
-        return "🟢 Active - 15:00", session_data
-
-    elapsed = time.time() - session_data["start_time"]
-    remaining = max(0, SESSION_TIMEOUT_SEC - elapsed)
-
-    if remaining == 0:
-        logger.info("🔄 Session expired - Auto-renewing...")
-        session_data = init_session()
-        return "🟢 Active - 15:00 (Auto-renewed)", session_data
+        if matches:
+            new_code = matches[-1]
+            current_project[active_file] = new_code
+            return new_code, current_project
+    return None, current_project
+
+def process_query(user_input, session_data, project_state, active_file, mode):
+    if session_data is None: session_data = init_session()
     
-    minutes = int(remaining // 60)
-    seconds = int(remaining % 60)
-    return f"🟢 Active - {minutes}:{seconds:02d}", session_data
-
-def process_query(user_input, session_data, current_code):
-    """Main Interaction Loop with Auto-Renewal Session Management"""
-    if session_data is None:
+    # Auto-renewal check
+    if time.time() - session_data["start_time"] > SESSION_TIMEOUT_SEC:
         session_data = init_session()
-    
-    elapsed = time.time() - session_data["start_time"]
-    if elapsed >= SESSION_TIMEOUT_SEC:
-        logger.info("🔄 Session expired during query - Auto-renewing...")
-        session_data = init_session()
-    
-    history = session_data["history"]
 
+    history = session_data["history"]
     if not user_input:
-        yield history, current_code, session_data
+        yield history, project_state, project_state[active_file], session_data
         return
 
     history.append({"role": "user", "content": user_input})
-    history.append({"role": "assistant", "content": "🧠 *Fyodor is thinking...*"})
-    yield history, current_code, session_data
+    history.append({"role": "assistant", "content": f"🧠 *Fyodor is thinking in {mode}...*"})
+    yield history, project_state, project_state[active_file], session_data
 
-    messages = [{"role": "system", "content": SYSTEM_PROMPT}]
+    # Context Construction
+    sys_prompt = get_system_prompt(mode)
+    messages = [{"role": "system", "content": sys_prompt}]
     
-    for msg in history[:-2][-10:]:
+    # Inject Project Context
+    project_context = "CURRENT PROJECT FILES:\n"
+    for fname, content in project_state.items():
+        project_context += f"--- {fname} ---\n{content}\n"
+    messages.append({"role": "system", "content": project_context})
+
+    # Chat History
+    for msg in history[:-2][-8:]:
         if msg['role'] == 'user':
             messages.append({"role": "user", "content": msg['content']})
         elif msg['role'] == 'assistant':
@@ -336,43 +192,82 @@ def process_query(user_input, session_data, current_code):
     try:
         client = OpenAI(**API_CONFIG)
         response = client.chat.completions.create(
-            model=MODEL_ID,
-            messages=messages,
-            temperature=0.1,
-            max_tokens=16000,
-            stream=True
+            model=MODEL_ID, messages=messages, temperature=0.1, stream=True
         )
 
         full_response = ""
-        
         for chunk in response:
-            if not chunk.choices: continue
-            delta = chunk.choices[0].delta
-            if delta and delta.content:
-                full_response += delta.content
-                clean_display = re.sub(r"<think>.*?</think>", "", full_response, flags=re.DOTALL)
+            if chunk.choices and chunk.choices[0].delta.content:
+                full_response += chunk.choices[0].delta.content
+                # Apply filter in real-time
+                clean_display = clean_thought_process(full_response)
                 history[-1]['content'] = clean_display
-                yield history, current_code, session_data
+                yield history, project_state, project_state[active_file], session_data
 
-        action_type, payload, clean_text = parse_command(full_response)
-        history[-1]['content'] = clean_text
-        yield history, current_code, session_data
+        # Parse and Update Code
+        new_code, updated_project = parse_code_update(full_response, project_state, active_file)
+        
+        if new_code:
+            history[-1]['content'] += f"\n\n📝 *Updated {active_file}*"
+            yield history, updated_project, updated_project[active_file], session_data
 
-        if action_type == "CODE":
-            history[-1]['content'] += "\n\n⏳ *Running in Fyodor Sandbox...*"
-            current_code = payload
-            yield history, current_code, session_data
-            
-            exec_res = execute_code_e2b(payload)
-            history[-1]['content'] += f"\n\n---\n{exec_res}"
-            yield history, current_code, session_data
+            # Execution (If Code Mode or Vis Mode, or if explicitly asked)
+            # For safety, we execute mainly on specific triggers, but here we run for feedback
+            history[-1]['content'] += "\n\n⏳ *Running Project...*"
+            exec_result = execute_code_e2b(updated_project)
+            history[-1]['content'] += f"\n\n---\n{exec_result}"
+            yield history, updated_project, updated_project[active_file], session_data
 
     except Exception as e:
         history[-1]['content'] += f"\n\n❌ Error: {str(e)}"
-        yield history, current_code, session_data
+        yield history, project_state, project_state[active_file], session_data
+
+# ==================== NEW FEATURES LOGIC ====================
+
+def run_code_review(code, session_data):
+    """Dedicated Code Review Agent with Thought Filtering"""
+    if not code.strip(): return session_data["history"]
+    
+    history = session_data["history"]
+    history.append({"role": "user", "content": "🕵️ **Requesting Code Review**"})
+    history.append({"role": "assistant", "content": "🤔 *Reviewing...*"})
+    
+    messages = [
+        {"role": "system", "content": "You are a Senior Python Architect. Review the following code for: Security, Efficiency, Style (PEP8), and Potential Bugs. Be critical but constructive."},
+        {"role": "user", "content": code}
+    ]
+    
+    try:
+        client = OpenAI(**API_CONFIG)
+        response = client.chat.completions.create(model=MODEL_ID, messages=messages)
+        review = response.choices[0].message.content
+        
+        # FIX: Apply the filter here!
+        clean_review = clean_thought_process(review)
+        
+        history[-1]["content"] = f"### 🕵️ Code Review Report\n\n{clean_review}"
+    except Exception as e:
+        history[-1]["content"] = f"❌ Review Failed: {e}"
+        
+    return history
+
+def update_active_file(selected_file, project_data):
+    return project_data.get(selected_file, "")
+
+def save_file_change(new_content, selected_file, project_data):
+    project_data[selected_file] = new_content
+    return project_data
+
+def create_new_file(new_name, project_data):
+    if not new_name: return gr.update(choices=list(project_data.keys())), project_data, ""
+    if new_name in project_data: return gr.update(choices=list(project_data.keys())), project_data, "⚠️ File exists"
+    
+    project_data[new_name] = "# New file"
+    return gr.update(choices=list(project_data.keys()), value=new_name), project_data, ""
 
 # ==================== UI ====================
 
+# FULL WINDOWS TERMINAL CSS
 WINDOWS_TERMINAL_CSS = """
 /* Windows Terminal Theme - Campbell Dark */
 :root {
@@ -501,7 +396,7 @@ input[type="text"]:focus, textarea:focus {
     background-color: #1a1a1a !important;
     border: 1px solid var(--wt-border) !important;
     border-radius: 6px !important;
-    padding: 1px !important; /* Reduced padding */
+    padding: 1px !important;
 }
 
 .cm-scroller {
@@ -563,12 +458,12 @@ label {
     letter-spacing: 0.5px;
 }
 
-/* IMPROVED SESSION STATUS BAR */
+/* SESSION STATUS BAR */
 .timer-box {
     background: linear-gradient(135deg, #1a1a1a 0%, #0a0a0a 100%) !important;
     border: 1px solid var(--wt-border) !important;
     border-radius: 6px !important;
-    padding: 0px !important; /* Reset padding here */
+    padding: 0px !important;
     box-shadow: inset 0 0 10px rgba(0,0,0,0.5);
 }
 
@@ -586,258 +481,130 @@ label {
     box-shadow: none !important;
 }
 
-::-webkit-scrollbar {
-    width: 12px;
-    height: 12px;
-}
-
-::-webkit-scrollbar-track {
-    background: var(--wt-bg);
-}
-
-::-webkit-scrollbar-thumb {
-    background: var(--wt-bright-black);
-    border-radius: 6px;
-    border: 2px solid var(--wt-bg);
-}
-
-::-webkit-scrollbar-thumb:hover {
-    background: var(--wt-cyan);
-}
-
-@media (max-width: 768px) {
-    .responsive-row {
-        flex-direction: column !important;
-        display: flex !important;
-    }
-    .responsive-row > * {
-        width: 100% !important;
-        min-width: 100% !important;
-        margin-bottom: 20px;
-    }
-    .gradio-container {
-        padding: 10px !important;
-    }
-    .chatbot {
-        height: 500px !important;
-    }
-}
-
-.mini-chat .message.user {
-    background: linear-gradient(135deg, #881798 0%, #C50F1F 100%) !important;
-}
-
-.mini-chat .message.bot {
-    background-color: #0a0a0a !important;
-    border: 1px solid #444 !important;
-}
-
-.accordion {
-    background-color: #1a1a1a !important;
-    border: 1px solid var(--wt-border) !important;
-    border-radius: 8px !important;
-    margin: 8px 0 !important;
-}
-
-.success-text {
-    color: var(--wt-green) !important;
-}
+/* Radio Button Styles */
+.mode-radio { background: transparent !important; border: none !important; }
+.mode-radio label { background: #1a1a1a !important; border: 1px solid #333 !important; margin-right: 10px; padding: 5px 15px; border-radius: 4px; cursor: pointer; color: var(--wt-fg); }
+.mode-radio label.selected { background: var(--wt-cyan) !important; color: black !important; border-color: var(--wt-cyan) !important; }
 
-.error-text {
-    color: var(--wt-red) !important;
-}
-
-.warning-text {
-    color: var(--wt-yellow) !important;
-}
+/* Scrollbars */
+::-webkit-scrollbar { width: 12px; height: 12px; }
+::-webkit-scrollbar-track { background: var(--wt-bg); }
+::-webkit-scrollbar-thumb { background: var(--wt-bright-black); border-radius: 6px; border: 2px solid var(--wt-bg); }
+::-webkit-scrollbar-thumb:hover { background: var(--wt-cyan); }
 """
 
 def run_app():
-    with gr.Blocks(title="🛡️ Fyodor IDE | Search Edition") as demo:
-        gr.Markdown("# 🛡️ Fyodor IDE - Search Edition")
-        
-        # Check components status
-        search_status = "✅ Active" if SEARCH_AVAILABLE else "⚠️ Install `duckduckgo-search`"
-        e2b_status = '✅ E2B (Isolated)' if E2B_API_KEY else '❌ Missing Key'
-        
-        gr.Markdown(
-            f"**Model:** `{MODEL_ID}` | **Sandbox:** {e2b_status} | "
-            f"**Search:** {search_status}\n\n"
-            "🔒 **Main Agent:** Fully isolated sandbox | 🔍 **Mini Agent:** DuckDuckGo Web Search\n\n"
-            "⚡ Auto-reset: **15 minutes**"
-        )
+    with gr.Blocks(title="Fyodor IDE | Pro") as demo:
+        # STATE
+        session_state = gr.State(init_session())
+        project_state = gr.State({"main.py": "import numpy as np\nprint('Hello Fyodor Pro!')"})
+        active_file_state = gr.State("main.py")
+
+        # HEADER
+        with gr.Row():
+            gr.Markdown("# 🛡️ Fyodor IDE | Pro")
+            timer_display = gr.Textbox(value="⏱️ SESSION: Active", show_label=False, interactive=False, elem_classes="timer-box", container=True)
         
+        # MAIN LAYOUT
         with gr.Row(elem_classes="responsive-row"):
-            # LEFT COLUMN
+            # LEFT: CHAT
             with gr.Column(scale=1):
-                with gr.Row():
-                    # UPDATED: No label, text inside, cleaner look
-                    timer_display = gr.Textbox(
-                        value="⏱️ SESSION: Initializing...", 
-                        show_label=False,
-                        interactive=False,
-                        elem_classes="timer-box",
-                        container=True
-                    )
-                    
-                chatbot = gr.Chatbot(
-                    label="💬 Fyodor Terminal",
-                    height=600,
-                    # Removed 'type' argument as previously discussed
-                    render_markdown=True,
-                    elem_classes="chatbot"
+                mode_radio = gr.Radio(
+                    choices=["Code Mode", "Data Mode", "Visualization Mode"], 
+                    value="Code Mode", 
+                    label="IDE Mode", 
+                    elem_classes="mode-radio"
                 )
-                
-                with gr.Row():
-                    msg_input = gr.Textbox(
-                        placeholder="PS C:\\Users\\dev> _",
-                        scale=4,
-                        container=False,
-                        show_label=False
-                    )
-                    run_btn = gr.Button("⚡ EXECUTE", variant="primary", scale=1)
-
-            # MIDDLE COLUMN
+                # Removed 'type="messages"' to fix Gradio TypeError
+                chatbot = gr.Chatbot(label="Fyodor Terminal", height=500, render_markdown=True, elem_classes="chatbot")
+                msg_input = gr.Textbox(placeholder="Instruction...", show_label=False)
+                run_btn = gr.Button("⚡ EXECUTE", variant="primary")
+
+            # MIDDLE: EDITOR & TOOLS
             with gr.Column(scale=1):
-                with gr.Tabs():
-                    with gr.TabItem("💻 Code Editor", id="code_tab"):
-                        gr.Markdown("**Live Python Editor** | Edit and re-run generated code")
-                        code_view = gr.Code(
-                            language="python", 
-                            lines=28, 
-                            interactive=True,
-                            show_label=False
-                        )
-                        
-                        with gr.Row():
-                            run_mod_btn = gr.Button("▶️ Run Modified", variant="secondary", scale=1)
-                            export_btn = gr.DownloadButton("⬇️ Export", variant="secondary", scale=1)
-            
-            # RIGHT COLUMN
-            with gr.Column(scale=0.6, min_width=300):
-                with gr.Accordion("🤖 Mini Agent (Web Search)", open=False):
-                    gr.Markdown("*Robust DuckDuckGo Search*")
-                    
-                    mini_chatbot = gr.Chatbot(
-                        label="",
-                        height=400,
-                        render_markdown=True,
-                        show_label=False,
-                        elem_classes="mini-chat"
-                    )
-                    
-                    with gr.Row():
-                        mini_input = gr.Textbox(
-                            placeholder="Ask or search anything...",
-                            scale=4,
-                            show_label=False,
-                            container=False
-                        )
-                        mini_send = gr.Button("🔍", variant="secondary", scale=1)
-                    
-                    mini_clear = gr.Button("🗑️ Clear", variant="secondary", size="sm")
+                # File Manager Panel
+                with gr.Row():
+                    file_dropdown = gr.Dropdown(choices=["main.py"], value="main.py", label="Active File", scale=2)
+                    new_file_txt = gr.Textbox(placeholder="new_file.py", show_label=False, scale=1)
+                    new_file_btn = gr.Button("➕", scale=0, min_width=40)
                 
-                with gr.Accordion("ℹ️ Setup & Info", open=False):
-                    gr.Markdown(f"""
-                    ### Fyodor IDE - Search Edition
-                    
-                    **Main Terminal (Isolated):**
-                    - 🔒 E2B sandbox (no internet)
-                    - Python code execution
-                    - Live code editing
-                    - Data visualization
-                    
-                    **Mini Agent (Web Search):**
-                    - 🔍 Real-time Web Search via DuckDuckGo
-                    - No API Keys required for search
-                    - No Proxy needed
-                    - Robust JSON results
-                    
-                    **How It Works:**
-                    1. User asks question
-                    2. Agent detects search intent
-                    3. DuckDuckGo API returns clean JSON
-                    4. Results are formatted and displayed
-                    """)
-
-        # State Management
-        session_state = gr.State(init_session())
-        current_code_state = gr.State("")
+                code_editor = gr.Code(language="python", value="import numpy as np\nprint('Hello Fyodor Pro!')", lines=20, interactive=True)
+                
+                with gr.Row():
+                    save_btn = gr.Button("💾 Save", size="sm") 
+                    review_btn = gr.Button("🕵️ Review Code", size="sm")
+                    run_manual_btn = gr.Button("▶️ Run Project", variant="secondary")
+
+            # RIGHT: MINI AGENT
+            with gr.Column(scale=0.5):
+                gr.Markdown("### 🤖 Mini Agent")
+                # Removed 'type="messages"' here too
+                mini_chat = gr.Chatbot(label="Web Search", height=400, elem_classes="mini-chat")
+                mini_input = gr.Textbox(placeholder="Search...", show_label=False)
+                mini_btn = gr.Button("🔍 Search")
+
+        # EVENT WIRING
         
-        # Timer function UPDATE to match new format
-        def update_timer(session_data):
-            if session_data is None:
-                session_data = init_session()
-                return "⏱️ SESSION: Active - 15:00", session_data
-
-            elapsed = time.time() - session_data["start_time"]
-            remaining = max(0, SESSION_TIMEOUT_SEC - elapsed)
-
-            if remaining == 0:
-                session_data = init_session()
-                return "⏱️ SESSION: Active - 15:00 (Renewed)", session_data
-            
-            minutes = int(remaining // 60)
-            seconds = int(remaining % 60)
-            return f"⏱️ SESSION: Active - {minutes}:{seconds:02d}", session_data
-
-        # Timer
-        timer = gr.Timer(1)
-        timer.tick(update_timer, inputs=[session_state], outputs=[timer_display, session_state])
-
-        # Main Chat
+        # 1. Chat & Execution
         msg_input.submit(
             process_query, 
-            [msg_input, session_state, current_code_state], 
-            [chatbot, code_view, session_state]
-        ).then(lambda: "", None, [msg_input])
-        
+            [msg_input, session_state, project_state, active_file_state, mode_radio], 
+            [chatbot, project_state, code_editor, session_state]
+        )
         run_btn.click(
             process_query, 
-            [msg_input, session_state, current_code_state], 
-            [chatbot, code_view, session_state]
-        ).then(lambda: "", None, [msg_input])
-
-        # Code Execution
-        run_mod_btn.click(
-            execute_modified_code,
-            inputs=[code_view, chatbot, session_state],
-            outputs=[chatbot]
+            [msg_input, session_state, project_state, active_file_state, mode_radio], 
+            [chatbot, project_state, code_editor, session_state]
+        )
+
+        # 2. File Management
+        file_dropdown.change(
+            update_active_file, 
+            [file_dropdown, project_state], 
+            [code_editor]
+        ).then(
+            lambda f: f, [file_dropdown], [active_file_state]
         )
         
-        export_btn.click(
-            export_script,
-            inputs=[code_view],
-            outputs=[export_btn]
+        code_editor.change(
+            save_file_change,
+            [code_editor, active_file_state, project_state],
+            [project_state]
         )
         
-        # Mini Agent
-        mini_input.submit(
-            mini_agent_chat,
-            [mini_input, mini_chatbot],
-            [mini_chatbot]
-        ).then(lambda: "", None, [mini_input])
+        new_file_btn.click(
+            create_new_file,
+            [new_file_txt, project_state],
+            [file_dropdown, project_state, new_file_txt]
+        )
+
+        # 3. Manual Run & Review
+        run_manual_btn.click(
+            lambda p: execute_code_e2b(p),
+            [project_state],
+            [chatbot] 
+        )
         
-        mini_send.click(
-            mini_agent_chat,
-            [mini_input, mini_chatbot],
-            [mini_chatbot]
-        ).then(lambda: "", None, [mini_input])
+        review_btn.click(
+            run_code_review,
+            [code_editor, session_state],
+            [chatbot]
+        )
         
-        mini_clear.click(
-            lambda: [],
-            None,
-            [mini_chatbot]
+        # 4. Mini Agent
+        mini_input.submit(
+            lambda m, h: h + [{"role":"user","content":m}, {"role":"assistant", "content":robust_search(m)}],
+            [mini_input, mini_chat],
+            [mini_chat]
+        )
+        mini_btn.click(
+            lambda m, h: h + [{"role":"user","content":m}, {"role":"assistant", "content":robust_search(m)}],
+            [mini_input, mini_chat],
+            [mini_chat]
         )
 
     return demo
 
 if __name__ == "__main__":
-    MOBILE_HEAD = '<meta name="viewport" content="width=device-width, initial-scale=1.0">'
-    
-    run_app().queue().launch(
-        server_name="0.0.0.0", 
-        server_port=7860,
-        css=WINDOWS_TERMINAL_CSS,
-        head=MOBILE_HEAD
-    )
+    # Moved CSS to launch() to fix Gradio TypeError
+    run_app().queue().launch(server_name="0.0.0.0", server_port=7860, css=WINDOWS_TERMINAL_CSS)