Update app.py

app.py

@@ -7,14 +7,15 @@ from typing import Dict, List, Tuple, Optional
 import os
 import json
 from functools import lru_cache
-import os
-os.environ["TOKENIZERS_PARALLELISM"] = "false"  # Prevents tokenizer warnings
+
+os.environ["TOKENIZERS_PARALLELISM"] = "false"
+
 # CPU-optimized configuration
 MODEL_NAME = "TinyLlama/TinyLlama-1.1B-Chat-v1.0"
 DEVICE = "cpu"
-DTYPE = torch.float32  # Using float32 for CPU stability (float16 not well supported on CPU)
+DTYPE = torch.float32 
 
-# File system emulation
+# --- File System Class (Same as before) ---
 class FileSystem:
     def __init__(self):
         self.files = {
@@ -29,9 +30,6 @@ class FileSystem:
     def save_file(self, content: str) -> None:
         if self.current_file:
             self.files[self.current_file] = content
-            self.history.append(("save", self.current_file, content[:100] + "..."))
-            if len(self.history) > self.max_history:
-                self.history.pop(0)
     
     def get_file(self, filename: str) -> str:
         return self.files.get(filename, "")
@@ -47,29 +45,24 @@ class FileSystem:
         if filename not in self.files:
             self.files[filename] = content
             self.current_file = filename
-            self.history.append(("create", filename, content[:50] + "..."))
     
     def get_all_files(self) -> List[str]:
         return list(self.files.keys())
     
     def get_context(self) -> str:
-        """Get context from all files for the AI model"""
         context = ""
         for filename, content in self.files.items():
             context += f"// File: {filename}\n{content}\n\n"
         return context
 
-# Initialize file system
 fs = FileSystem()
 
-# Cache the model to avoid reloading
+# --- Model Loading ---
 @lru_cache(maxsize=1)
 def load_model():
     print("Loading TinyLlama model for CPU... This may take a moment.")
     start_time = time.time()
-    
     try:
-        # For CPU, we don't use quantization that requires bitsandbytes
         tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)
         model = AutoModelForCausalLM.from_pretrained(
             MODEL_NAME,
@@ -77,250 +70,119 @@ def load_model():
             device_map=DEVICE,
             low_cpu_mem_usage=True
         )
-        
-        # Create the pipeline
         pipe = pipeline(
             "text-generation",
             model=model,
             tokenizer=tokenizer,
-            device=-1,  # Force CPU
             max_new_tokens=256,
             temperature=0.2,
             top_p=0.95,
             do_sample=True
         )
-        
-        load_time = time.time() - start_time
-        print(f"Model loaded successfully in {load_time:.2f} seconds!")
+        print(f"Model loaded successfully in {time.time() - start_time:.2f} seconds!")
         return pipe
     except Exception as e:
         print(f"Error loading model: {str(e)}")
         return None
 
+# --- Logic Functions ---
 def run_code(code: str) -> Tuple[str, str]:
-    """Safely execute JavaScript code in a sandboxed environment"""
     start_time = time.time()
-    output = ""
-    error = ""
-    
     try:
-        # This is a placeholder - in a real implementation you'd use a proper JS sandbox
-        # For demonstration, we'll just return a success message
         output = f"✓ Code executed successfully\nExecution time: {time.time() - start_time:.4f}s"
+        return output, ""
     except Exception as e:
-        error = f"✗ Error: {str(e)}"
-    
-    return output, error
+        return "", f"✗ Error: {str(e)}"
 
-def generate_completion(code: str, cursor_pos: int = 0) -> str:
-    """Generate code completion based on current context"""
+def generate_completion(code: str) -> str:
     model = load_model()
-    if not model:
-        return "Error: Failed to load AI model. Please try again later."
-    
-    # Get context from all files
-    context = fs.get_context()
-    
-    # Create prompt for code completion
-    prompt = f"""<|system|>
-You are an AI programming assistant, an expert at completing code in JavaScript.
-Complete the code below. Only return the completion, no explanations.
-Keep the same indentation style as the code above.
-</s>
-<|user|>
-Current code context:
-{context}
-
-Complete this code:
-{code}
-</s>
-<|assistant|>
-"""
+    if not model: return "Error: Model failed to load."
     
+    prompt = f"<|system|>You are a JS expert. Complete the code. No explanations.</s><|user|>\n{code}\n</s><|assistant|>"
     try:
-        # Generate completion
-        result = model(
-            prompt,
-            pad_token_id=model.tokenizer.eos_token_id,
-            num_return_sequences=1,
-            return_full_text=False
-        )
-        
-        # Extract and clean the completion
-        completion = result[0]['generated_text'].strip()
-        
-        # Remove any parts that repeat the prompt
-        if code.strip() in completion:
-            completion = completion.replace(code.strip(), "")
-        
-        return completion
+        result = model(prompt, num_return_sequences=1, return_full_text=False)
+        return result[0]['generated_text'].strip()
     except Exception as e:
-        return f"Error generating completion: {str(e)}"
+        return f"/* Error: {str(e)} */"
 
 def explain_code(code: str) -> str:
-    """Generate explanation for the given code"""
     model = load_model()
-    if not model:
-        return "Error: Failed to load AI model. Please try again later."
-    
-    prompt = f"""<|system|>
-You are an AI programming assistant that explains code clearly and concisely.
-Provide a line-by-line explanation of what the code does.
-</s>
-<|user|>
-Explain this JavaScript code:
-{code}
-</s>
-<|assistant|>
-"""
-    
+    if not model: return "Error loading model."
+    prompt = f"<|system|>Explain this code concisely.</s><|user|>\n{code}\n</s><|assistant|>"
     try:
-        result = model(
-            prompt,
-            pad_token_id=model.tokenizer.eos_token_id,
-            max_new_tokens=512,
-            num_return_sequences=1,
-            return_full_text=False
-        )
-        
+        result = model(prompt, max_new_tokens=512)
         return result[0]['generated_text'].strip()
     except Exception as e:
-        return f"Error explaining code: {str(e)}"
+        return str(e)
 
 def refactor_code(code: str) -> str:
-    """Suggest improvements to the given code"""
     model = load_model()
-    if not model:
-        return "Error: Failed to load AI model. Please try again later."
-    
-    prompt = f"""<|system|>
-You are an AI programming assistant that refactors code for better readability, performance, and maintainability.
-Provide a refactored version of the code with improvements.
-Explain the key changes in a comment at the top.
-</s>
-<|user|>
-Refactor this JavaScript code:
-{code}
-</s>
-<|assistant|>
-"""
-    
+    if not model: return "Error loading model."
+    prompt = f"<|system|>Refactor this JS code for best practices.</s><|user|>\n{code}\n</s><|assistant|>"
     try:
-        result = model(
-            prompt,
-            pad_token_id=model.tokenizer.eos_token_id,
-            max_new_tokens=512,
-            num_return_sequences=1,
-            return_full_text=False
-        )
-        
+        result = model(prompt, max_new_tokens=512)
         return result[0]['generated_text'].strip()
     except Exception as e:
-        return f"Error refactoring code: {str(e)}"
+        return str(e)
 
-def generate_code(prompt: str) -> str:
-    """Generate code based on a natural language description"""
+def generate_code(prompt_text: str) -> str:
     model = load_model()
-    if not model:
-        return "Error: Failed to load AI model. Please try again later."
-    
-    prompt = f"""<|system|>
-You are an AI programming assistant that writes clean, efficient JavaScript code.
-Generate code based on the user's description. Include comments for complex parts.
-</s>
-<|user|>
-Write JavaScript code that: {prompt}
-</s>
-<|assistant|>
-"""
-    
+    if not model: return "Error loading model."
+    prompt = f"<|system|>Write JavaScript code for: {prompt_text}</s><|assistant|>"
     try:
-        result = model(
-            prompt,
-            pad_token_id=model.tokenizer.eos_token_id,
-            max_new_tokens=512,
-            num_return_sequences=1,
-            return_full_text=False
-        )
-        
+        result = model(prompt, max_new_tokens=512)
         return result[0]['generated_text'].strip()
     except Exception as e:
-        return f"Error generating code: {str(e)}"
-
-def process_voice_input(transcript: str) -> str:
-    """Process voice input and convert to code or command"""
-    # This would integrate with Web Speech API in the frontend
-    # For now, just return the transcript as a placeholder
-    return transcript
+        return str(e)
 
 def create_diff_view(original: str, modified: str) -> str:
-    """Create a diff view between two code versions"""
-    # Simple diff implementation for demonstration
     lines_original = original.split('\n')
     lines_modified = modified.split('\n')
-    
     diff = []
-    i, j = 0, 0
-    
-    while i < len(lines_original) and j < len(lines_modified):
-        if lines_original[i] == lines_modified[j]:
-            diff.append(f"  {lines_original[i]}")
-            i += 1
-            j += 1
-        else:
-            if i < len(lines_original):
-                diff.append(f"- {lines_original[i]}")
-                i += 1
-            if j < len(lines_modified):
-                diff.append(f"+ {lines_modified[j]}")
-                j += 1
-    
-    # Add remaining lines
-    while i < len(lines_original):
-        diff.append(f"- {lines_original[i]}")
-        i += 1
-    
-    while j < len(lines_modified):
-        diff.append(f"+ {lines_modified[j]}")
-        j += 1
-    
+    # Very basic diff visualizer
+    import difflib
+    for line in difflib.unified_diff(lines_original, lines_modified, lineterm=""):
+        diff.append(line)
     return "\n".join(diff)
 
-# Gradio UI Components (updated for Gradio 6.5.1)
-with gr.Blocks(
-    title="Axon Pro - Free AI IDE", 
-    theme=gr.themes.Default(
-        font=[gr.themes.GoogleFont('JetBrains Mono'), 'monospace'],
-        font_mono=[gr.themes.GoogleFont('JetBrains Mono'), 'monospace'],
-        primary_hue="blue",
-        neutral_hue="gray",
-        radius=0
-    ).set(
-        button_primary_background_fill="*primary_500",
-        button_primary_background_fill_hover="*primary_600",
-        body_background_fill="*neutral_900",
-        body_text_color="*neutral_50"
-    ),
-    css="""
-        .editor-container { height: 50vh; }
-        .terminal { height: 15vh; background-color: #1e1e1e; color: #d4d4d4; overflow: auto; }
-        .diff-view { height: 40vh; overflow: auto; }
-        .file-explorer { height: 50vh; background-color: #252526; overflow: auto; }
-        .ai-chat { height: 40vh; overflow: auto; }
-        .status-bar { background-color: #007acc; color: white; padding: 5px; text-align: center; }
-        .btn { min-width: 100px; }
-        .monaco-editor { height: 100% !important; }
-        .theme-dark { --body-bg: #1e1e1e; --editor-bg: #1e1e1e; }
-        .button-large { min-height: 40px !important; }
-        .tab-nav { background-color: #252526 !important; }
-        .tabitem { background-color: #1e1e1e !important; }
-        .code-wrap { white-space: pre-wrap !important; word-break: break-word !important; }
-    """
-) as demo:
+# --- Gradio UI ---
+# 1. FIXED THEME DEFINITION
+theme = gr.themes.Default(
+    font=[gr.themes.GoogleFont('JetBrains Mono'), 'monospace'],
+    font_mono=[gr.themes.GoogleFont('JetBrains Mono'), 'monospace'],
+    primary_hue="blue",
+    neutral_hue="gray",
+    # radius=0  <-- REMOVED THIS CAUSE OF ERROR
+).set(
+    button_primary_background_fill="*primary_500",
+    button_primary_background_fill_hover="*primary_600",
+    body_background_fill="*neutral_900",
+    body_text_color="*neutral_50",
+    radius_size="none" # <-- Added this to achieve square corners
+)
+
+css = """
+    .editor-container { height: 50vh; }
+    .terminal { height: 15vh; background-color: #1e1e1e; color: #d4d4d4; overflow: auto; }
+    .diff-view { height: 40vh; overflow: auto; }
+    .file-explorer { height: 50vh; background-color: #252526; overflow: auto; }
+    .ai-chat { height: 40vh; overflow: auto; }
+    .status-bar { background-color: #007acc; color: white; padding: 5px; text-align: center; }
+    .btn { min-width: 100px; }
+    .monaco-editor { height: 100% !important; }
+    .theme-dark { --body-bg: #1e1e1e; --editor-bg: #1e1e1e; }
+    .button-large { min-height: 40px !important; }
+    .tab-nav { background-color: #252526 !important; }
+    .tabitem { background-color: #1e1e1e !important; }
+    .code-wrap { white-space: pre-wrap !important; word-break: break-word !important; }
+"""
+
+with gr.Blocks(title="Axon Pro - Free AI IDE", theme=theme, css=css) as demo:
     
     gr.Markdown("# ⚡ Axon Pro — Free AI-Powered Code IDE")
     
-    with gr.Tabs():
+    # 2. FIXED TABS VARIABLE ASSIGNMENT
+    with gr.Tabs() as main_tabs:
         with gr.Tab("Editor", id="editor-tab"):
             with gr.Row(equal_height=True):
                 # File Explorer
@@ -334,13 +196,9 @@ with gr.Blocks(
                         container=False
                     )
                     with gr.Row():
-                        new_file_btn = gr.Button("➕ New File", variant="secondary", elem_classes="button-large")
-                        save_btn = gr.Button("💾 Save", variant="secondary", elem_classes="button-large")
-                    new_file_name = gr.Textbox(
-                        placeholder="filename.js", 
-                        label="New File Name",
-                        container=False
-                    )
+                        new_file_btn = gr.Button("➕ New", variant="secondary")
+                        save_btn = gr.Button("💾 Save", variant="secondary")
+                    new_file_name = gr.Textbox(placeholder="filename.js", label="New File Name", container=False)
                 
                 # Main Editor Area
                 with gr.Column(scale=4):
@@ -354,65 +212,43 @@ with gr.Blocks(
                     )
                     
                     with gr.Row():
-                        run_btn = gr.Button("▶ Run (Ctrl+R)", variant="primary", elem_classes="button-large")
-                        complete_btn = gr.Button("✨ Complete (Ctrl+Enter)", variant="secondary", elem_classes="button-large")
-                        explain_btn = gr.Button("📝 Explain (Ctrl+Shift+E)", variant="secondary", elem_classes="button-large")
-                        refactor_btn = gr.Button("🔧 Refactor", variant="secondary", elem_classes="button-large")
-                        generate_btn = gr.Button("⚡ Generate", variant="secondary", elem_classes="button-large")
-                        voice_btn = gr.Button("🎤 Voice", variant="secondary", elem_classes="button-large")
-                    
+                        run_btn = gr.Button("▶ Run", variant="primary")
+                        complete_btn = gr.Button("✨ Complete", variant="secondary")
+                        explain_btn = gr.Button("📝 Explain", variant="secondary")
+                        refactor_btn = gr.Button("🔧 Refactor", variant="secondary")
+                        
                     with gr.Tabs():
                         with gr.Tab("Terminal", id="terminal-tab"):
                             terminal = gr.Textbox(
-                                value="$ _ (Ctrl+R to run)", 
+                                value="$ _", 
                                 lines=5, 
                                 interactive=False,
                                 elem_classes="terminal"
                             )
-                            clear_btn = gr.Button("CLEAR", variant="secondary", elem_classes="button-large")
+                            clear_btn = gr.Button("CLEAR TERMINAL", variant="secondary", size="sm")
                         
                         with gr.Tab("AI Chat", id="chat-tab"):
-                            chat_history = gr.Chatbot(
-                                label="Axon AI",
-                                elem_classes="ai-chat",
-                                height="100%",
-                                bubble_full_width=False,
-                                avatar_images=(None, "https://api.iconify.design/teenyicons:ai-solid.svg")
-                            )
+                            chat_history = gr.Chatbot(label="Axon AI", height=300)
                             with gr.Row():
-                                chat_input = gr.Textbox(
-                                    placeholder="Ask about your code...",
-                                    label="Message Axon AI",
-                                    container=False,
-                                    scale=7
-                                )
-                                send_btn = gr.Button("Send", variant="primary", elem_classes="button-large", scale=1)
+                                chat_input = gr.Textbox(placeholder="Ask to generate code...", scale=7, container=False)
+                                send_btn = gr.Button("Generate", variant="primary", scale=1)
         
         with gr.Tab("Diff View", id="diff-tab"):
-            diff_view = gr.Code(
-                value="", 
-                label="AI Changes", 
-                language="diff",
-                elem_classes="diff-view code-wrap",
-                interactive=False
-            )
+            diff_view = gr.Code(label="AI Changes", language="diff", elem_classes="diff-view code-wrap", interactive=False)
             with gr.Row():
-                apply_btn = gr.Button("Apply Changes", variant="primary", elem_classes="button-large")
-                discard_btn = gr.Button("Discard Changes", variant="secondary", elem_classes="button-large")
+                apply_btn = gr.Button("Apply Changes", variant="primary")
+                discard_btn = gr.Button("Discard Changes", variant="secondary")
     
-    status_bar = gr.Markdown(
-        f"**AXON PRO v1.0** | {len(fs.get_all_files())} files | {sum(len(content.split('\\n')) for content in fs.files.values())} lines | JavaScript | Axon Pro v1.0 | AI Ready",
-        elem_classes="status-bar"
-    )
+    status_bar = gr.Markdown(f"**AXON PRO v1.0** | CPU Mode | TinyLlama-1.1B", elem_classes="status-bar")
     
-    # Hidden state for tracking
+    # State
     current_file_state = gr.State(fs.current_file)
     diff_original_state = gr.State("")
     diff_modified_state = gr.State("")
     diff_mode_state = gr.State(False)
     
-    # Event handlers
-    def update_file_content(content, current_file):
+    # Wrappers
+    def update_file_content(content):
         fs.save_file(content)
         return fs.get_current_file_content()
     
@@ -426,218 +262,76 @@ with gr.Blocks(
             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 save_file(content, current_file):
-        fs.save_file(content)
-        return content
-    
     def run_code_wrapper(content):
-        output, error = run_code(content)
-        return output if not error else error
+        out, err = run_code(content)
+        return out if not err else err
     
     def complete_code_wrapper(content):
-        completion = generate_completion(content)
-        return content + completion
+        comp = generate_completion(content)
+        return content + comp
     
     def explain_code_wrapper(content):
         explanation = explain_code(content)
         fs.save_file(content)
-        diff_original = content
-        diff_modified = f"// EXPLANATION:\n// {explanation.replace('\\n', '\\n// ')}\n\n{content}"
-        
-        # Switch to diff view
-        diff = create_diff_view(diff_original, diff_modified)
-        return diff, diff_original, diff_modified, True
+        diff_orig = content
+        diff_mod = f"/* EXPLANATION:\n{explanation}\n*/\n\n{content}"
+        diff = create_diff_view(diff_orig, diff_mod)
+        return diff, diff_orig, diff_mod, True
     
     def refactor_code_wrapper(content):
         refactored = refactor_code(content)
         fs.save_file(content)
-        diff_original = content
-        diff_modified = refactored
-        
-        # Switch to diff view
-        diff = create_diff_view(diff_original, diff_modified)
-        return diff, diff_original, diff_modified, True
-    
+        diff = create_diff_view(content, refactored)
+        return diff, content, refactored, True
+
     def generate_code_wrapper(prompt, history):
-        if not prompt.strip():
-            return diff_view.value, diff_original_state.value, diff_modified_state.value, diff_mode_state.value, history
-        
         generated = generate_code(prompt)
-        # Switch to diff view with the generated code
-        diff_original = ""
-        diff_modified = generated
-        
-        # Switch to diff view
-        diff = create_diff_view(diff_original, diff_modified)
-        return diff, diff_original, diff_modified, True, history + [[prompt, "Generated code is ready for review in Diff View"]]
-    
-    def apply_diff(diff_original, diff_modified, in_diff_mode):
-        if in_diff_mode:
-            fs.save_file(diff_modified)
-            return fs.get_current_file_content(), False
-        return gr.update(), in_diff_mode
-    
-    def discard_diff():
-        return fs.get_current_file_content(), False
-    
-    def clear_terminal():
-        return "$ _ (Ctrl+R to run)"
-    
-    def handle_chat(message, history):
-        if not message.strip():
-            return "", history
-        
-        # For demo, just echo the message with a placeholder response
-        response = f"AI: This is a demo response. In a full implementation, I'd analyze your code context and provide helpful suggestions."
-        new_history = history + [[message, response]]
-        return "", new_history
-    
-    def switch_to_diff_tab():
-        return gr.Tabs(selected="diff-tab")
-    
-    def switch_to_editor_tab():
-        return gr.Tabs(selected="editor-tab")
-    
-    # Bind events
-    editor.change(update_file_content, [editor, current_file_state], editor)
+        diff = create_diff_view("", generated)
+        new_hist = history + [[prompt, "Generated code available in Diff View"]]
+        return diff, "", generated, True, new_hist, ""
+
+    # Event Wiring
+    editor.change(update_file_content, editor, None)
     file_list.change(load_file, file_list, [editor, current_file_state])
     new_file_btn.click(create_new_file, new_file_name, [file_list, editor])
-    save_btn.click(save_file, [editor, current_file_state], editor)
     
     run_btn.click(run_code_wrapper, editor, terminal)
     complete_btn.click(complete_code_wrapper, editor, editor)
+    clear_btn.click(lambda: "$ _", None, terminal)
     
+    # 3. FIXED TAB SWITCHING (Using main_tabs variable)
     explain_btn.click(
-        explain_code_wrapper, 
-        editor, 
+        explain_code_wrapper, editor, 
         [diff_view, diff_original_state, diff_modified_state, diff_mode_state]
     ).then(
-        switch_to_diff_tab, None, demo.tabs
+        lambda: gr.Tabs(selected="diff-tab"), None, main_tabs
     )
     
     refactor_btn.click(
-        refactor_code_wrapper,
-        editor,
+        refactor_code_wrapper, editor,
         [diff_view, diff_original_state, diff_modified_state, diff_mode_state]
     ).then(
-        switch_to_diff_tab, None, demo.tabs
-    )
-    
-    generate_btn.click(
-        lambda: gr.update(visible=True),
-        outputs=chat_input
+        lambda: gr.Tabs(selected="diff-tab"), None, main_tabs
     )
     
     chat_input.submit(
-        handle_chat,
-        [chat_input, chat_history],
-        [chat_input, chat_history]
-    ).then(
-        generate_code_wrapper,
-        [chat_input, chat_history],
-        [diff_view, diff_original_state, diff_modified_state, diff_mode_state, chat_history]
+        generate_code_wrapper, [chat_input, chat_history], 
+        [diff_view, diff_original_state, diff_modified_state, diff_mode_state, chat_history, chat_input]
     ).then(
-        switch_to_diff_tab, None, demo.tabs
-    )
-    
-    send_btn.click(
-        handle_chat,
-        [chat_input, chat_history],
-        [chat_input, chat_history]
-    ).then(
-        generate_code_wrapper,
-        [chat_input, chat_history],
-        [diff_view, diff_original_state, diff_modified_state, diff_mode_state, chat_history]
-    ).then(
-        switch_to_diff_tab, None, demo.tabs
+        lambda: gr.Tabs(selected="diff-tab"), None, main_tabs
     )
     
     apply_btn.click(
-        apply_diff,
-        [diff_original_state, diff_modified_state, diff_mode_state],
-        [editor, diff_mode_state]
+        lambda mod: (mod, False), diff_modified_state, [editor, diff_mode_state]
     ).then(
-        switch_to_editor_tab, None, demo.tabs
+        lambda: gr.Tabs(selected="editor-tab"), None, main_tabs
     )
     
     discard_btn.click(
-        discard_diff,
-        outputs=[editor, diff_mode_state]
+        lambda: (gr.update(), False), None, [editor, diff_mode_state]
     ).then(
-        switch_to_editor_tab, None, demo.tabs
-    )
-    
-    clear_btn.click(
-        clear_terminal,
-        outputs=terminal
-    )
-
-    # Add keyboard shortcuts using Gradio's new event system
-    demo.load(
-        None, 
-        None, 
-        None, 
-        _js="""
-        () => {
-            document.addEventListener('keydown', function(e) {
-                // Ctrl+R: Run code
-                if (e.ctrlKey && e.key === 'r') {
-                    e.preventDefault();
-                    const runBtn = document.querySelector('button:contains("Run")');
-                    if (runBtn) runBtn.click();
-                }
-                
-                // Ctrl+Enter: Complete code
-                if (e.ctrlKey && e.key === 'Enter') {
-                    e.preventDefault();
-                    const completeBtn = document.querySelector('button:contains("Complete")');
-                    if (completeBtn) completeBtn.click();
-                }
-                
-                // Ctrl+Shift+E: Explain code
-                if (e.ctrlKey && e.shiftKey && e.key === 'E') {
-                    e.preventDefault();
-                    const explainBtn = document.querySelector('button:contains("Explain")');
-                    if (explainBtn) explainBtn.click();
-                }
-                
-                // Ctrl+B: Toggle file explorer
-                if (e.ctrlKey && e.key === 'b') {
-                    e.preventDefault();
-                    // Implementation would toggle sidebar
-                }
-                
-                // Ctrl+J: Toggle terminal
-                if (e.ctrlKey && e.key === 'j') {
-                    e.preventDefault();
-                    // Implementation would toggle terminal
-                }
-                
-                // Ctrl+L: Toggle AI chat
-                if (e.ctrlKey && e.key === 'l') {
-                    e.preventDefault();
-                    // Implementation would toggle chat panel
-                }
-                
-                // Ctrl+N: New file
-                if (e.ctrlKey && e.key === 'n') {
-                    e.preventDefault();
-                    document.querySelector('input[placeholder="filename.js"]').focus();
-                }
-            });
-        }
-        """
+        lambda: gr.Tabs(selected="editor-tab"), None, main_tabs
     )
 
 if __name__ == "__main__":
-    print("Starting Axon Pro IDE...")
-    print(f"Running on CPU with {torch.__version__}")
-    print(f"Model: {MODEL_NAME}")
-    demo.launch(
-        server_name="0.0.0.0",
-        server_port=int(os.getenv("PORT", 7860)),
-        debug=True,
-        show_api=False,
-        favicon_path="https://api.iconify.design/teenyicons:ai-solid.svg",
-        root_path=os.getenv("ROOT_PATH", "")
-    )
+    demo.launch(server_name="0.0.0.0", server_port=7860)