Update app.py

app.py

@@ -14,7 +14,6 @@ class CodingCopilot:
     def __init__(self):
         """Initialize the coding copilot with AWS Bedrock client."""
         self.setup_aws_client()
-        self.chat_history = []
         
     def setup_aws_client(self):
         """Setup AWS Bedrock client with credentials from environment variables."""
@@ -23,7 +22,7 @@ class CodingCopilot:
                 'bedrock-runtime',
                 aws_access_key_id=os.getenv('AWS_ACCESS_KEY_ID'),
                 aws_secret_access_key=os.getenv('AWS_SECRET_ACCESS_KEY'),
-                region_name='us-east-1'  # Claude is available in us-east-1
+                region_name='us-east-1'
             )
         except Exception as e:
             print(f"Error setting up AWS client: {e}")
@@ -32,19 +31,13 @@ class CodingCopilot:
     def call_claude(self, prompt: str, max_tokens: int = 8000) -> str:
         """Call Claude 3 Haiku via AWS Bedrock with increased token limit."""
         if not self.bedrock_client:
-            return "Error: AWS Bedrock client not initialized. Please check your credentials."
+            return "❌ **Error**: AWS Bedrock client not initialized. Please check your credentials."
         
         try:
-            # Prepare the request payload for Claude
             body = {
                 "anthropic_version": "bedrock-2023-05-31",
                 "max_tokens": max_tokens,
-                "messages": [
-                    {
-                        "role": "user",
-                        "content": prompt
-                    }
-                ],
+                "messages": [{"role": "user", "content": prompt}],
                 "temperature": 0.1,
                 "top_p": 0.9,
             }
@@ -60,7 +53,7 @@ class CodingCopilot:
             return response_body['content'][0]['text']
             
         except Exception as e:
-            return f"Error calling Claude: {str(e)}"
+            return f"❌ **Error calling Claude**: {str(e)}"
 
     def read_python_file(self, file_path: str) -> str:
         """Read content from a Python file."""
@@ -81,14 +74,14 @@ class CodingCopilot:
                 if cell.cell_type == 'code':
                     code_cells.append(f"# Cell {len(code_cells) + 1}")
                     code_cells.append(cell.source)
-                    code_cells.append("")  # Add empty line between cells
+                    code_cells.append("")
             
             return '\n'.join(code_cells)
         except Exception as e:
             return f"Error reading notebook: {str(e)}"
 
-    def process_multiple_files(self, files: List) -> Tuple[str, str]:
-        """Process multiple uploaded files and return combined content."""
+    def process_files(self, files: List) -> Tuple[str, str]:
+        """Process uploaded files and return combined content."""
         if not files:
             return "", "No files uploaded"
         
@@ -108,215 +101,117 @@ class CodingCopilot:
                 continue
             
             if content and not content.startswith("Error"):
-                all_content.append(f"# File: {file_name}")
-                all_content.append(f"# Type: {file_extension}")
+                all_content.append(f"# 📁 File: {file_name}")
+                all_content.append(f"# 📄 Type: {file_extension}")
                 all_content.append("# " + "="*50)
                 all_content.append(content)
                 all_content.append("\n" + "="*60 + "\n")
-                file_info.append(f"{file_name} ({file_extension})")
+                file_info.append(f"{file_name}")
         
         combined_content = '\n'.join(all_content)
-        status = f"Successfully loaded {len(file_info)} files: {', '.join(file_info)}"
+        status = f"✅ Successfully loaded {len(file_info)} files: {', '.join(file_info)}"
         
         return combined_content, status
 
-    def analyze_code_with_chat(self, code_content: str, analysis_type: str, custom_prompt: str = "", chat_history: List = None) -> Tuple[str, List]:
-        """Analyze code with chat functionality and support for long responses."""
-        if chat_history is None:
-            chat_history = []
+    def process_message(self, message: str, files: List = None, history: List = None) -> str:
+        """Process user message with advanced context handling for long code generation."""
+        if history is None:
+            history = []
         
-        # If this is the first analysis, do the standard analysis
-        if not chat_history:
-            result = self.analyze_code(code_content, analysis_type, custom_prompt)
-            chat_history.append(("Initial Analysis", result))
-            return result, chat_history
-        else:
-            # This is a follow-up question
-            context = ""
-            if chat_history:
-                context = "\n\nPrevious analysis conversation:\n"
-                for i, (q, a) in enumerate(chat_history[-3:]):  # Last 3 exchanges for context
-                    context += f"Q{i+1}: {q}\nA{i+1}: {a}\n"
-            
-            prompt = f"""Given this code:
-
-```python
-{code_content}
-```
-{context}
-
-Follow-up question about the analysis: {custom_prompt}
-
-Please provide a detailed response based on the code and previous analysis. If you're providing code, make sure to include the complete implementation without truncation."""
-            
-            response = self.call_claude(prompt, max_tokens=8000)
-            chat_history.append((custom_prompt, response))
-            return response, chat_history
-
-    def analyze_code(self, code_content: str, analysis_type: str, custom_prompt: str = "") -> str:
-        """Analyze code using Claude with optional custom prompt."""
-        base_prompts = {
-            "review": f"""Please review this code and provide:
-1. Code quality assessment
-2. Potential bugs or issues
-3. Performance improvements
-4. Best practices suggestions
-5. Security considerations
-
-Make sure to provide complete analysis with detailed explanations.""",
-            
-            "explain": f"""Please explain this code in detail:
-1. What does this code do?
-2. How does it work?
-3. Key functions and their purposes
-4. Dependencies and requirements
-5. Usage examples
-
-Provide comprehensive explanations for each part.""",
-            
-            "optimize": f"""Please optimize this code:
-1. Suggest performance improvements
-2. Refactor for better readability
-3. Reduce complexity where possible
-4. Improve memory usage
-5. Provide the complete optimized version
-
-Make sure to include the full optimized code without truncation.""",
-            
-            "debug": f"""Please help debug this code:
-1. Identify potential bugs
-2. Suggest fixes
-3. Add error handling
-4. Improve robustness
-5. Provide the complete corrected version
-
-Include the full corrected code implementation.""",
-            
-            "document": f"""Please add comprehensive documentation to this code:
-1. Add docstrings to functions/classes
-2. Add inline comments
-3. Create usage examples
-4. Document parameters and return values
-5. Add type hints where appropriate
-
-Provide the complete documented version of the code.""",
-            
-            "custom": custom_prompt
-        }
+        # Process files if provided
+        file_content = ""
+        file_status = ""
+        if files:
+            file_content, file_status = self.process_files(files)
         
-        if analysis_type == "custom" and not custom_prompt.strip():
-            return "Please provide a custom prompt for analysis."
+        # Detect continuation requests
+        continue_keywords = ['continue', 'continue the code', 'continue from where', 'keep going', 'add more', 'extend', 'complete the']
+        is_continuation = any(keyword in message.lower() for keyword in continue_keywords)
         
-        prompt_text = base_prompts.get(analysis_type, base_prompts["review"])
+        # Build comprehensive context from history
+        context = ""
+        if history:
+            if is_continuation:
+                # For continuation, include more context (last 5 exchanges)
+                context = "\n\nFull conversation context for continuation:\n"
+                for i, (user_msg, assistant_msg) in enumerate(history[-5:]):
+                    context += f"Exchange {i+1}:\nUser: {user_msg}\nAssistant: {assistant_msg}\n\n"
+            else:
+                # For new topics, include recent context (last 3 exchanges)
+                context = "\n\nRecent conversation context:\n"
+                for i, (user_msg, assistant_msg) in enumerate(history[-3:]):
+                    context += f"User: {user_msg}\nAssistant: {assistant_msg}\n\n"
         
-        full_prompt = f"""{prompt_text}
+        # Build specialized prompts based on request type
+        if is_continuation:
+            prompt = f"""You are an advanced coding assistant. The user is asking you to CONTINUE or EXTEND previous code.
 
-Code:
-```python
-{code_content}
-```
+CRITICAL INSTRUCTIONS FOR CONTINUATION:
+1. Look at the previous conversation to understand what code was generated
+2. Continue from where the previous code left off - DO NOT start from the beginning
+3. Maintain the same coding style, structure, and patterns
+4. Add new functionality or complete incomplete sections
+5. Generate substantial code (aim for 500-2000+ lines if needed)
+6. Ensure the continuation integrates seamlessly with previous code
 
-Please provide a detailed response and if fixes are needed, provide the complete corrected code without any truncation."""
-        
-        return self.call_claude(full_prompt, max_tokens=8000)
+User's continuation request: {message}
+
+{file_status}
+
+{f"Code files content for reference:\n```\n{file_content}\n```" if file_content else ""}
 
-    def generate_code_with_chat(self, description: str, language: str = "python", reference_files: str = "", chat_history: List = None) -> Tuple[str, List]:
-        """Generate code with chat functionality for continuation and modifications."""
-        if chat_history is None:
-            chat_history = []
-        
-        # If this is the first generation, do the standard generation
-        if not chat_history:
-            result = self.generate_code(description, language, reference_files)
-            chat_history.append(("Initial Generation Request", description))
-            chat_history.append(("Generated Code", result))
-            return result, chat_history
-        else:
-            # This is a follow-up request (continue, modify, etc.)
-            context = ""
-            if chat_history:
-                context = "\n\nPrevious generation conversation:\n"
-                for i, (q, a) in enumerate(chat_history[-4:]):  # Last 4 exchanges for context
-                    context += f"Step {i+1}: {q}\nResponse {i+1}: {a}\n"
-            
-            prompt = f"""Based on the previous code generation context:
 {context}
 
-New request: {description}
+Based on the previous conversation, continue the code generation. Do NOT restart - pick up exactly where the previous response left off and continue building upon it. Provide substantial, complete code sections."""
 
-Please provide the requested modification/continuation. If you're continuing code, make sure to provide the complete implementation. If you're modifying existing code, provide the full modified version."""
+        else:
+            # Determine if this is a code generation request
+            generation_keywords = ['create', 'generate', 'build', 'make', 'develop', 'write code', 'implement', 'design']
+            is_generation = any(keyword in message.lower() for keyword in generation_keywords)
             
-            response = self.call_claude(prompt, max_tokens=8000)
-            chat_history.append((description, response))
-            return response, chat_history
-
-    def generate_code(self, description: str, language: str = "python", reference_files: str = "") -> str:
-        """Generate code based on description with optional reference files."""
-        reference_context = ""
-        if reference_files.strip():
-            reference_context = f"""
-
-Reference files for context:
-```
-{reference_files}
-```
-
-Please use these files as reference when generating the new code."""
-        
-        prompt = f"""Please generate {language} code based on this description:
+            if is_generation:
+                prompt = f"""You are an advanced coding assistant specialized in generating comprehensive, production-ready code.
 
-{description}
+CRITICAL INSTRUCTIONS FOR CODE GENERATION:
+1. Generate COMPLETE, COMPREHENSIVE code - aim for 500-3000+ lines when appropriate
+2. Include ALL necessary components: classes, functions, error handling, documentation
+3. Create fully functional, production-ready applications
+4. Add comprehensive comments and docstrings
+5. Include proper imports, dependencies, and structure
+6. Don't truncate or abbreviate - provide the FULL implementation
+7. If the project is large, focus on core functionality but make it complete
 
-Requirements:
-1. Write clean, well-documented code
-2. Include error handling
-3. Add type hints where appropriate
-4. Provide usage examples
-5. Follow best practices
-6. Generate complete, comprehensive code - don't truncate or abbreviate
-7. If the code is large, provide the full implementation
-{reference_context}
+User's request: {message}
 
-Please provide the complete, ready-to-use code with detailed comments. Make sure to generate comprehensive code that fully implements the requested functionality."""
-        
-        return self.call_claude(prompt, max_tokens=8000)
+{file_status}
 
-    def chat_with_code(self, code_content: str, question: str, chat_history: List = None) -> Tuple[str, List]:
-        """Chat about specific code with history and support for long responses."""
-        if chat_history is None:
-            chat_history = []
-        
-        # Add context from previous conversation
-        context = ""
-        if chat_history:
-            context = "\n\nPrevious conversation:\n"
-            for i, (q, a) in enumerate(chat_history[-3:]):  # Last 3 exchanges for context
-                context += f"Q{i+1}: {q}\nA{i+1}: {a}\n"
-        
-        prompt = f"""Given this code:
+{f"Reference code files:\n```\n{file_content}\n```" if file_content else ""}
 
-```python
-{code_content}
-```
 {context}
 
-Current question: {question}
+Generate comprehensive, complete code that fully implements the requested functionality. Provide extensive code with proper structure, documentation, and all necessary components."""
 
-Please provide a detailed answer about the code. If you're suggesting changes or providing code, make sure to include the complete implementation without truncation."""
-        
-        response = self.call_claude(prompt, max_tokens=8000)
-        
-        # Update chat history
-        chat_history.append((question, response))
-        
-        return response, chat_history
+            else:
+                # Regular analysis/chat prompt
+                prompt = f"""You are an advanced coding assistant. Provide detailed, comprehensive responses.
+
+User's request: {message}
+
+{file_status}
+
+{f"Code files content:\n```\n{file_content}\n```" if file_content else ""}
 
-    def create_downloadable_file(self, content: str, filename: str = "generated_code.py") -> str:
+{context}
+
+Provide a thorough and helpful response. If suggesting code changes, provide complete implementations."""
+
+        return self.call_claude(prompt, max_tokens=8000)
+
+    def create_download_file(self, content: str, filename: str = "code_output.py") -> str:
         """Create a downloadable file with the given content."""
         timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
         filename = f"{timestamp}_{filename}"
         
-        # Create temporary file
         temp_file = tempfile.NamedTemporaryFile(mode='w', suffix='.py', delete=False)
         temp_file.write(content)
         temp_file.close()
@@ -326,442 +221,496 @@ Please provide a detailed answer about the code. If you're suggesting changes or
 # Initialize the copilot
 copilot = CodingCopilot()
 
-# Custom CSS for black and red theme
-custom_css = """
+# Professional ChatGPT-style CSS
+chatgpt_css = """
+/* Global Styles */
 .gradio-container {
-    background: linear-gradient(135deg, #0a0a0a 0%, #1a0a0a 100%) !important;
-    color: #ffffff !important;
+    max-width: 1200px !important;
+    margin: 0 auto !important;
+    background: #ffffff !important;
+    font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', 'Roboto', sans-serif !important;
 }
 
-.dark {
-    background: #0a0a0a !important;
-    color: #ffffff !important;
+/* Header Styles */
+.header-container {
+    background: linear-gradient(90deg, #10a37f 0%, #1a7f64 100%) !important;
+    padding: 1rem 2rem !important;
+    margin: -1rem -1rem 1rem -1rem !important;
+    border-radius: 0 !important;
 }
 
-/* Tab styling */
-.tab-nav {
-    background: #1a1a1a !important;
-    border-bottom: 2px solid #dc2626 !important;
+.header-title {
+    color: white !important;
+    font-size: 1.5rem !important;
+    font-weight: 600 !important;
+    margin: 0 !important;
+    text-align: center !important;
 }
 
-.tab-nav button {
-    background: #2a2a2a !important;
-    color: #ffffff !important;
-    border: 1px solid #dc2626 !important;
-    margin-right: 5px !important;
+.header-subtitle {
+    color: rgba(255, 255, 255, 0.9) !important;
+    font-size: 0.9rem !important;
+    text-align: center !important;
+    margin: 0.5rem 0 0 0 !important;
 }
 
-.tab-nav button[aria-selected="true"] {
-    background: #dc2626 !important;
-    color: #ffffff !important;
+/* Chat Interface */
+.chat-container {
+    background: #ffffff !important;
+    border-radius: 8px !important;
+    border: 1px solid #e5e5e5 !important;
+    max-height: 600px !important;
+    overflow-y: auto !important;
+    padding: 0 !important;
 }
 
-/* Input styling */
-.gr-textbox, .gr-dropdown, .gr-file {
-    background: #2a2a2a !important;
-    border: 1px solid #dc2626 !important;
-    color: #ffffff !important;
+.chatbot {
+    background: transparent !important;
+    border: none !important;
 }
 
-.gr-textbox:focus, .gr-dropdown:focus {
-    border-color: #ef4444 !important;
-    box-shadow: 0 0 0 2px rgba(220, 38, 38, 0.2) !important;
+.message {
+    padding: 1rem 1.5rem !important;
+    border-bottom: 1px solid #f0f0f0 !important;
 }
 
-/* Button styling */
-.gr-button {
-    background: linear-gradient(135deg, #dc2626 0%, #b91c1c 100%) !important;
-    border: none !important;
-    color: #ffffff !important;
-    font-weight: bold !important;
-    transition: all 0.3s ease !important;
+.message:last-child {
+    border-bottom: none !important;
 }
 
-.gr-button:hover {
-    background: linear-gradient(135deg, #ef4444 0%, #dc2626 100%) !important;
-    transform: translateY(-2px) !important;
-    box-shadow: 0 5px 15px rgba(220, 38, 38, 0.4) !important;
+.user-message {
+    background: #f8f9fa !important;
+    margin: 0.5rem 0 !important;
+    padding: 0.75rem 1rem !important;
+    border-radius: 8px !important;
+    border: 1px solid #e9ecef !important;
 }
 
-/* Code block styling */
-.gr-code {
-    background: #1a1a1a !important;
-    border: 1px solid #dc2626 !important;
+.bot-message {
+    background: transparent !important;
+    margin: 0.5rem 0 !important;
+    padding: 0.75rem 1rem !important;
 }
 
-/* Panel styling */
-.gr-panel {
-    background: #1a1a1a !important;
-    border: 1px solid #333333 !important;
+/* Input Area */
+.input-container {
+    background: #ffffff !important;
+    border: 1px solid #d1d5db !important;
+    border-radius: 12px !important;
+    padding: 0.5rem !important;
+    margin-top: 1rem !important;
 }
 
-/* Markdown styling */
-.gr-markdown {
-    color: #ffffff !important;
+.input-row {
+    display: flex !important;
+    align-items: flex-end !important;
+    gap: 0.5rem !important;
 }
 
-.gr-markdown h1 {
-    color: #dc2626 !important;
-    text-shadow: 0 0 10px rgba(220, 38, 38, 0.5) !important;
+.chat-input {
+    flex: 1 !important;
+    border: none !important;
+    background: transparent !important;
+    resize: vertical !important;
+    min-height: 24px !important;
+    padding: 0.5rem !important;
+    font-size: 1rem !important;
+    line-height: 1.5 !important;
 }
 
-.gr-markdown h2, .gr-markdown h3 {
-    color: #ef4444 !important;
+.chat-input:focus {
+    outline: none !important;
+    box-shadow: none !important;
 }
 
-/* File upload styling */
-.gr-file-upload {
-    background: #2a2a2a !important;
-    border: 2px dashed #dc2626 !important;
-    color: #ffffff !important;
+/* Buttons */
+.send-button {
+    background: #10a37f !important;
+    color: white !important;
+    border: none !important;
+    border-radius: 8px !important;
+    padding: 0.5rem 1rem !important;
+    font-weight: 500 !important;
+    cursor: pointer !important;
+    transition: background-color 0.2s ease !important;
+    min-width: 80px !important;
 }
 
-.gr-file-upload:hover {
-    border-color: #ef4444 !important;
-    background: #3a2a2a !important;
+.send-button:hover {
+    background: #0d8c6c !important;
 }
 
-/* Chat history styling */
-.chat-history {
-    background: #1a1a1a !important;
-    border: 1px solid #dc2626 !important;
+.send-button:disabled {
+    background: #9ca3af !important;
+    cursor: not-allowed !important;
+}
+
+.secondary-button {
+    background: #f3f4f6 !important;
+    color: #374151 !important;
+    border: 1px solid #d1d5db !important;
     border-radius: 8px !important;
-    padding: 10px !important;
-    max-height: 400px !important;
+    padding: 0.5rem 1rem !important;
+    font-weight: 500 !important;
+    cursor: pointer !important;
+    transition: all 0.2s ease !important;
+}
+
+.secondary-button:hover {
+    background: #e5e7eb !important;
+    border-color: #9ca3af !important;
+}
+
+/* File Upload Area */
+.file-upload-area {
+    background: #f9fafb !important;
+    border: 2px dashed #d1d5db !important;
+    border-radius: 8px !important;
+    padding: 1rem !important;
+    text-align: center !important;
+    transition: all 0.2s ease !important;
+    margin-bottom: 1rem !important;
+}
+
+.file-upload-area:hover {
+    border-color: #10a37f !important;
+    background: #f0fdf4 !important;
+}
+
+.file-upload-text {
+    color: #6b7280 !important;
+    font-size: 0.9rem !important;
+}
+
+/* Status and Info */
+.status-message {
+    background: #f0f9ff !important;
+    border: 1px solid #7dd3fc !important;
+    border-radius: 6px !important;
+    padding: 0.75rem !important;
+    margin: 0.5rem 0 !important;
+    font-size: 0.9rem !important;
+    color: #0c4a6e !important;
+}
+
+.error-message {
+    background: #fef2f2 !important;
+    border: 1px solid #fecaca !important;
+    border-radius: 6px !important;
+    padding: 0.75rem !important;
+    margin: 0.5rem 0 !important;
+    font-size: 0.9rem !important;
+    color: #991b1b !important;
+}
+
+/* Code blocks */
+.code-block {
+    background: #f8f9fa !important;
+    border: 1px solid #e9ecef !important;
+    border-radius: 6px !important;
+    padding: 1rem !important;
+    font-family: 'Monaco', 'Menlo', 'Ubuntu Mono', monospace !important;
+    font-size: 0.9rem !important;
+    line-height: 1.4 !important;
+    overflow-x: auto !important;
+}
+
+/* Sidebar */
+.sidebar {
+    background: #f8f9fa !important;
+    border-right: 1px solid #e5e5e5 !important;
+    padding: 1rem !important;
+    height: 100vh !important;
     overflow-y: auto !important;
 }
 
-.chat-message {
-    margin: 10px 0 !important;
-    padding: 8px !important;
-    border-left: 3px solid #dc2626 !important;
-    background: #2a2a2a !important;
+.sidebar-title {
+    font-weight: 600 !important;
+    color: #374151 !important;
+    margin-bottom: 1rem !important;
+    font-size: 1.1rem !important;
 }
-"""
 
-def analyze_uploaded_code(files, analysis_type, custom_prompt, chat_history):
-    """Analyze uploaded code files with chat functionality and long response support."""
-    if not files:
-        return "Please upload at least one file.", chat_history, ""
+/* Mobile Responsiveness */
+@media (max-width: 768px) {
+    .gradio-container {
+        margin: 0 !important;
+        padding: 0.5rem !important;
+    }
     
-    content, status = copilot.process_multiple_files(files)
-    if not content or content.startswith("Error"):
-        return status or content, chat_history, ""
+    .header-container {
+        margin: -0.5rem -0.5rem 1rem -0.5rem !important;
+        padding: 1rem !important;
+    }
     
-    if chat_history is None:
-        chat_history = []
+    .chat-container {
+        max-height: 500px !important;
+    }
     
-    # Check if this is initial analysis or follow-up chat
-    if not chat_history and analysis_type != "chat":
-        # Initial analysis
-        result = copilot.analyze_code(content, analysis_type, custom_prompt)
-        chat_history.append((f"Initial {analysis_type} analysis", result))
-        status_with_result = f"**Status:** {status}\n\n**Analysis Result:**\n{result}"
-    else:
-        # Follow-up chat or direct chat
-        if not custom_prompt.strip():
-            return "Please ask a question about the analyzed code.", chat_history, ""
-        
-        result, chat_history = copilot.analyze_code_with_chat(content, analysis_type, custom_prompt, chat_history)
-        status_with_result = result
+    .input-row {
+        flex-direction: column !important;
+        gap: 0.75rem !important;
+    }
     
-    # Format chat history for display
-    chat_display = ""
-    for i, (q, a) in enumerate(chat_history):
-        chat_display += f"**Q{i+1}:** {q}\n\n**A{i+1}:** {a}\n\n---\n\n"
-    
-    return status_with_result, chat_history, chat_display
+    .send-button {
+        width: 100% !important;
+    }
+}
 
-def generate_new_code_with_chat(description, language, reference_files, generation_chat_history):
-    """Generate new code with chat support for continuation and modifications."""
-    if not description.strip():
-        return "Please provide a description of what you want to generate.", None, generation_chat_history, ""
-    
-    reference_content = ""
-    if reference_files:
-        reference_content, _ = copilot.process_multiple_files(reference_files)
-    
-    if generation_chat_history is None:
-        generation_chat_history = []
+/* Loading animation */
+.loading {
+    display: inline-block !important;
+    width: 20px !important;
+    height: 20px !important;
+    border: 3px solid #f3f3f3 !important;
+    border-top: 3px solid #10a37f !important;
+    border-radius: 50% !important;
+    animation: spin 1s linear infinite !important;
+}
+
+@keyframes spin {
+    0% { transform: rotate(0deg); }
+    100% { transform: rotate(360deg); }
+}
+
+/* Hide default gradio elements */
+.gradio-container .gr-button {
+    transition: all 0.2s ease !important;
+}
+
+/* Custom scrollbar */
+.chat-container::-webkit-scrollbar {
+    width: 6px !important;
+}
+
+.chat-container::-webkit-scrollbar-track {
+    background: #f1f1f1 !important;
+}
+
+.chat-container::-webkit-scrollbar-thumb {
+    background: #c1c1c1 !important;
+    border-radius: 3px !important;
+}
+
+.chat-container::-webkit-scrollbar-thumb:hover {
+    background: #a1a1a1 !important;
+}
+"""
+
+def process_chat_message(message, files, history):
+    """Process a new chat message with advanced continuation support."""
+    if not message.strip() and not files:
+        return history, history, ""
     
-    # Check if this is initial generation or continuation
-    if not generation_chat_history:
-        # Initial generation
-        result = copilot.generate_code(description, language, reference_content)
-        generation_chat_history.append(("Initial Generation", description))
-        generation_chat_history.append(("Generated Code", result))
-    else:
-        # Continuation or modification
-        result, generation_chat_history = copilot.generate_code_with_chat(description, language, reference_content, generation_chat_history)
+    # Add user message to history
+    if history is None:
+        history = []
     
-    # Create downloadable file
-    filename = f"generated_{language}_code.py"
-    temp_file = copilot.create_downloadable_file(result, filename)
+    user_msg = message
+    if files:
+        file_names = [os.path.basename(f.name) for f in files]
+        user_msg += f" 📁 *[Uploaded: {', '.join(file_names)}]*"
     
-    # Format chat history for display
-    chat_display = ""
-    for i, (q, a) in enumerate(generation_chat_history):
-        chat_display += f"**Step {i+1}:** {q}\n\n**Response {i+1}:** {a}\n\n---\n\n"
+    # Special handling for continuation requests
+    continue_keywords = ['continue', 'continue the code', 'continue from where', 'keep going', 'add more', 'extend', 'complete the']
+    is_continuation = any(keyword in message.lower() for keyword in continue_keywords)
     
-    return result, temp_file, generation_chat_history, chat_display
+    if is_continuation and history:
+        # For continuation, show a status message to user
+        status_msg = "🔄 **Continuing from previous code...** (Analyzing context and extending the implementation)"
+        temp_history = history + [[user_msg, status_msg]]
+        
+        # Get AI response with full context
+        ai_response = copilot.process_message(message, files, history)
+        
+        # Add both messages to history
+        history.append([user_msg, ai_response])
+        
+        return history, history, ""
+    else:
+        # Regular processing
+        ai_response = copilot.process_message(message, files, history)
+        
+        # Add both messages to history
+        history.append([user_msg, ai_response])
+        
+        return history, history, ""
 
-def chat_about_code(files, question, chat_history):
-    """Chat about uploaded code with history and long response support."""
-    if not files:
-        return "Please upload at least one file.", chat_history, "", None
-    
-    if not question.strip():
-        return "Please ask a question about the code.", chat_history, "", None
-    
-    content, status = copilot.process_multiple_files(files)
-    if not content or content.startswith("Error"):
-        return status or content, chat_history, "", None
+def smart_continue_suggestion(history):
+    """Suggest continuation if the last response seems incomplete."""
+    if not history:
+        return ""
     
-    if chat_history is None:
-        chat_history = []
+    last_response = history[-1][1] if history else ""
     
-    response, updated_history = copilot.chat_with_code(content, question, chat_history)
+    # Check if response might be incomplete
+    incomplete_indicators = [
+        "```" in last_response and last_response.count("```") % 2 != 0,  # Unclosed code block
+        last_response.endswith("..."),
+        "# TODO" in last_response,
+        "# Continue" in last_response.lower(),
+        len(last_response) > 3000  # Very long response might be cut off
+    ]
     
-    # Format chat history for display
-    chat_display = ""
-    for i, (q, a) in enumerate(updated_history):
-        chat_display += f"**Q{i+1}:** {q}\n\n**A{i+1}:** {a}\n\n---\n\n"
+    if any(incomplete_indicators):
+        return "💡 **Tip**: Type 'continue' to extend this code or add more functionality!"
     
-    # Create downloadable response file if it contains code
-    download_file = None
-    if "```" in response:
-        download_file = copilot.create_downloadable_file(response, "chat_response.md")
-    
-    return response, updated_history, chat_display, download_file
-
-# Create Gradio interface with custom theme
-with gr.Blocks(title="🔥 Advanced Coding Copilot - Long Code Support", css=custom_css, theme=gr.themes.Base()) as app:
-    gr.Markdown("""
-    # 🔥 Advanced Coding Copilot - Long Code Support
-    ### Upload multiple Python files (.py) or Jupyter notebooks (.ipynb) for intelligent analysis, or generate new code with AI assistance!
-    ### ✨ **NEW**: Support for extremely long code generation (up to 5000+ lines) with chat continuation!
+    return ""
+
+def clear_chat():
+    """Clear the chat history."""
+    return [], []
+
+def create_download_from_message(message):
+    """Create a downloadable file from the current message if it contains code."""
+    if "```" in message:
+        # Extract code blocks
+        import re
+        code_blocks = re.findall(r'```(?:\w+)?\n(.*?)\n```', message, re.DOTALL)
+        if code_blocks:
+            combined_code = "\n\n".join(code_blocks)
+            return copilot.create_download_file(combined_code)
+    return None
+
+# Create the main interface
+with gr.Blocks(css=chatgpt_css, title="Coding Copilot Pro") as app:
+    # Header
+    gr.HTML("""
+    <div class="header-container">
+        <h1 class="header-title">🤖 Coding Copilot Pro</h1>
+        <p class="header-subtitle">Your AI-powered coding assistant • Powered by Claude 3 Haiku</p>
+    </div>
     """)
     
-    with gr.Tabs():
-        # Enhanced File Analysis Tab
-        with gr.TabItem("📁 Analyze Code"):
-            gr.Markdown("### Upload multiple files and get comprehensive analysis with chat support")
-            with gr.Row():
-                with gr.Column(scale=1):
-                    file_input = gr.File(
-                        label="📂 Upload Multiple Files (.py/.ipynb)",
-                        file_count="multiple",
-                        file_types=[".py", ".ipynb"],
-                        height=120
-                    )
-                    analysis_type = gr.Dropdown(
-                        choices=["review", "explain", "optimize", "debug", "document", "custom", "chat"],
-                        value="review",
-                        label="🔍 Analysis Type"
-                    )
-                    custom_prompt = gr.Textbox(
-                        label="✏️ Custom Prompt / Chat Message",
-                        lines=3,
-                        placeholder="Write your custom analysis prompt, ask questions, or request 'continue' for more details...",
-                        visible=False
-                    )
-                    analyze_btn = gr.Button("🚀 Analyze Code", variant="primary", size="lg")
-                    clear_analysis_btn = gr.Button("🗑️ Clear Analysis Chat", variant="secondary")
-                
-                with gr.Column(scale=2):
-                    analysis_output = gr.Textbox(
-                        label="📊 Analysis Result / Current Response",
-                        lines=15,
-                        max_lines=30
-                    )
-                    analysis_chat_history = gr.Textbox(
-                        label="💬 Analysis Chat History",
-                        lines=15,
-                        max_lines=30,
-                        placeholder="Chat history will appear here after analysis..."
-                    )
-            
-            # Hidden state for analysis chat history
-            analysis_chat_state = gr.State([])
-            
-            # Show/hide custom prompt based on analysis type
-            def toggle_custom_prompt_analysis(analysis_type):
-                if analysis_type in ["custom", "chat"]:
-                    return gr.update(visible=True, label="✏️ Custom Prompt" if analysis_type == "custom" else "💬 Chat Message")
-                return gr.update(visible=False)
-            
-            def clear_analysis_chat():
-                return [], "", ""
-            
-            def update_button_text(analysis_type):
-                if analysis_type == "chat":
-                    return gr.update(value="💭 Send Message")
-                return gr.update(value="🚀 Analyze Code")
-            
-            analysis_type.change(
-                toggle_custom_prompt_analysis, 
-                inputs=analysis_type, 
-                outputs=custom_prompt
-            )
-            analysis_type.change(
-                update_button_text,
-                inputs=analysis_type,
-                outputs=analyze_btn
-            )
-            
-            analyze_btn.click(
-                analyze_uploaded_code,
-                inputs=[file_input, analysis_type, custom_prompt, analysis_chat_state],
-                outputs=[analysis_output, analysis_chat_state, analysis_chat_history]
-            )
-            
-            clear_analysis_btn.click(
-                clear_analysis_chat,
-                outputs=[analysis_chat_state, analysis_chat_history, analysis_output]
-            )
+    # Main chat interface
+    with gr.Row():
+        with gr.Column(scale=1, min_width=250):
+            # Sidebar with features
+            gr.HTML('<h3 class="sidebar-title">✨ Features</h3>')
+            gr.Markdown("""
+            **💬 Chat Features:**
+            • Long code generation (1000+ lines)
+            • Smart continuation support
+            • Code analysis & review
+            • Bug detection & fixes  
+            • Code optimization
+            • Architecture advice
+            • Best practices
+            
+            **📁 File Support:**
+            • Python files (.py)
+            • Jupyter notebooks (.ipynb)
+            • Multiple file upload
+            
+            **🛠️ Capabilities:**
+            • Generate complete applications
+            • Continue incomplete code
+            • Debug existing code
+            • Explain complex algorithms
+            • Refactor & optimize
+            • Add comprehensive documentation
+            
+            **💡 Pro Tips:**
+            • Say "continue" to extend code
+            • Upload files for context
+            • Ask for "complete implementation"
+            • Request "production-ready code"
+            """)
+            
+            # Quick actions
+            gr.HTML('<h3 class="sidebar-title">🚀 Quick Actions</h3>')
+            with gr.Column():
+                quick_review = gr.Button("📋 Code Review", size="sm", variant="secondary")
+                quick_debug = gr.Button("🐛 Debug Code", size="sm", variant="secondary")
+                quick_optimize = gr.Button("⚡ Optimize", size="sm", variant="secondary")
+                quick_explain = gr.Button("📖 Explain Code", size="sm", variant="secondary")
         
-        # Enhanced Code Generation Tab with Chat Support
-        with gr.TabItem("⚡ Generate Code"):
-            gr.Markdown("### Generate new code with chat support for continuation and modifications")
-            with gr.Row():
-                with gr.Column(scale=1):
-                    code_description = gr.Textbox(
-                        label="📝 Describe what you want to code / Chat Message",
-                        lines=5,
-                        placeholder="E.g., Create a REST API using FastAPI... OR 'continue the previous code' OR 'add more features' OR 'optimize the generated code'"
-                    )
-                    code_language = gr.Dropdown(
-                        choices=["python", "javascript", "java", "cpp", "c", "go", "rust"],
-                        value="python",
-                        label="💻 Programming Language"
-                    )
-                    reference_files = gr.File(
-                        label="📚 Reference Files (optional)",
-                        file_count="multiple",
-                        file_types=[".py", ".ipynb"]
-                    )
-                    generate_btn = gr.Button("🎯 Generate/Continue Code", variant="primary", size="lg")
-                    clear_generation_btn = gr.Button("🗑️ Clear Generation Chat", variant="secondary")
-                
-                with gr.Column(scale=2):
-                    generated_code = gr.Code(
-                        label="🔧 Generated Code",
-                        language="python",
-                        lines=25,
-                        max_lines=50
-                    )
-                    generation_chat_history = gr.Textbox(
-                        label="💬 Generation Chat History",
-                        lines=10,
-                        max_lines=20,
-                        placeholder="Generation history will appear here..."
-                    )
-                    download_generated = gr.File(
-                        label="💾 Download Generated Code",
-                        visible=False,
-                        interactive=False
-                    )
-            
-            # Hidden state for generation chat history
-            generation_chat_state = gr.State([])
-            
-            def clear_generation_chat():
-                return [], "", ""
-            
-            generate_btn.click(
-                generate_new_code_with_chat,
-                inputs=[code_description, code_language, reference_files, generation_chat_state],
-                outputs=[generated_code, download_generated, generation_chat_state, generation_chat_history]
+        with gr.Column(scale=3):
+            # Chat interface
+            chatbot = gr.Chatbot(
+                height=500,
+                show_label=False,
+                container=True,
+                bubble_full_width=False,
+                avatar_images=("👤", "🤖")
             )
             
-            clear_generation_btn.click(
-                clear_generation_chat,
-                outputs=[generation_chat_state, generation_chat_history, generated_code]
-            )
-        
-        # Enhanced Code Chat Tab
-        with gr.TabItem("💬 Chat About Code"):
-            gr.Markdown("### Interactive chat about your code with conversation history and long response support")
+            # Input area
             with gr.Row():
                 with gr.Column(scale=1):
-                    chat_file_input = gr.File(
-                        label="📂 Upload Code Files",
+                    # File upload
+                    files = gr.File(
+                        label="📎 Attach Files",
                         file_count="multiple",
                         file_types=[".py", ".ipynb"],
-                        height=120
-                    )
-                    code_question = gr.Textbox(
-                        label="❓ Ask a question about your code",
-                        lines=3,
-                        placeholder="E.g., How can I optimize this algorithm? What design patterns are used here? Continue explaining... Add more features..."
+                        show_label=False,
+                        container=False
                     )
-                    chat_btn = gr.Button("💭 Ask Question", variant="primary", size="lg")
-                    clear_chat_btn = gr.Button("🗑️ Clear Chat History", variant="secondary")
                 
-                with gr.Column(scale=2):
-                    chat_output = gr.Textbox(
-                        label="🤖 AI Response",
-                        lines=15,
-                        max_lines=30
-                    )
-                    chat_history_display = gr.Textbox(
-                        label="📜 Chat History",
-                        lines=10,
-                        max_lines=25
-                    )
-                    download_chat = gr.File(
-                        label="💾 Download Chat Response",
-                        visible=False,
-                        interactive=False
+                with gr.Column(scale=4):
+                    # Message input
+                    msg = gr.Textbox(
+                        label="Message",
+                        placeholder="Ask me anything about coding... Type 'continue' to extend previous code, or request 'complete implementation' for long code generation",
+                        show_label=False,
+                        lines=1,
+                        max_lines=5
                     )
-            
-            # Hidden state for chat history
-            chat_history_state = gr.State([])
-            
-            def handle_chat(files, question, history):
-                response, updated_history, history_display, download_file = chat_about_code(files, question, history)
-                download_visible = download_file is not None
-                return (
-                    response, 
-                    updated_history, 
-                    history_display, 
-                    gr.update(value=download_file, visible=download_visible),
-                    ""  # Clear the question input
-                )
-            
-            def clear_chat():
-                return [], "", ""
-            
-            chat_btn.click(
-                handle_chat,
-                inputs=[chat_file_input, code_question, chat_history_state],
-                outputs=[chat_output, chat_history_state, chat_history_display, download_chat, code_question]
-            )
-            
-            clear_chat_btn.click(
-                clear_chat,
-                outputs=[chat_history_state, chat_history_display, chat_output]
-            )
+                
+                with gr.Column(scale=1, min_width=100):
+                    # Send and clear buttons
+                    with gr.Row():
+                        submit = gr.Button("Send", variant="primary", scale=2)
+                        clear = gr.Button("🗑️", variant="secondary", scale=1)
+    
+    # Hidden state for chat history
+    chat_history = gr.State([])
+    
+    # Event handlers
+    def quick_action(action_type):
+        return f"Please {action_type.lower()} the uploaded code files."
+    
+    # Quick action buttons
+    quick_review.click(lambda: "Please perform a comprehensive code review of the uploaded files, including quality assessment, potential bugs, performance improvements, and security considerations.", outputs=msg)
+    quick_debug.click(lambda: "Please debug the uploaded code thoroughly and identify any issues, bugs, or potential problems with detailed fixes.", outputs=msg)
+    quick_optimize.click(lambda: "Please optimize the uploaded code for better performance, readability, and maintainability. Provide the complete optimized version.", outputs=msg)
+    quick_explain.click(lambda: "Please provide a detailed explanation of what this code does, how it works, and its key components with examples.", outputs=msg)
+    
+    # Enhanced continuation support
+    def handle_submit_with_continuation(message, files, history):
+        result_history, result_state, cleared_msg = process_chat_message(message, files, history)
+        suggestion = smart_continue_suggestion(result_history)
+        return result_history, result_state, cleared_msg, suggestion
+    
+    # Main chat functionality with continuation support
+    submit.click(
+        handle_submit_with_continuation,
+        inputs=[msg, files, chat_history],
+        outputs=[chatbot, chat_history, msg, gr.HTML(visible=False)]
+    ).then(
+        lambda: [None, None],  # Clear files after sending
+        outputs=[files, msg]
+    )
     
-    # Enhanced Footer
-    gr.Markdown("""
-    ---
-    ### 🔥 Features:
-    - **🚀 Long Code Support**: Generate up to 5000+ lines of code with continuation support
-    - **💬 Chat Continuation**: Ask "continue", "add more features", or "extend the code" in any tab
-    - **Multi-file Support**: Upload and analyze multiple files simultaneously
-    - **Custom Prompts**: Write your own analysis prompts for specific needs
-    - **Interactive Chat**: Have conversations about your code with full history
-    - **File Downloads**: Get generated code and chat responses as downloadable files
-    - **Reference Context**: Use existing files as reference when generating new code
+    # Enter key submission with continuation support
+    msg.submit(
+        handle_submit_with_continuation,
+        inputs=[msg, files, chat_history],
+        outputs=[chatbot, chat_history, msg, gr.HTML(visible=False)]
+    ).then(
+        lambda: [None, None],
+        outputs=[files, msg]
+    )
     
-    ### 💡 Pro Tips:
-    - Use "continue" or "continue the code" to extend generated code
-    - Ask "add more features" to enhance existing implementations
-    - Use "optimize" or "refactor" to improve code quality
-    - Upload reference files to generate code based on existing patterns
+    # Clear chat
+    clear.click(clear_chat, outputs=[chatbot, chat_history])
     
-    **Powered by:** Claude 3 Haiku via AWS Bedrock | **Theme:** Cyberpunk Black & Red | **Max Tokens:** 8000 per response
+    # Footer
+    gr.HTML("""
+    <div style="text-align: center; padding: 2rem 0; color: #6b7280; font-size: 0.9rem; border-top: 1px solid #e5e7eb; margin-top: 2rem;">
+        <p><strong>Coding Copilot Pro</strong> • Built with Claude 3 Haiku via AWS Bedrock</p>
+        <p>Upload your code files and start chatting for intelligent analysis, debugging, and optimization</p>
+    </div>
     """)
 
 # Launch the app
@@ -770,5 +719,6 @@ if __name__ == "__main__":
         server_name="0.0.0.0",
         server_port=7860,
         share=True,
-        show_error=True
+        show_error=True,
+        show_api=False
     )