Update app.py

app.py

@@ -2,15 +2,19 @@ import gradio as gr
 import boto3
 import json
 import os
-from typing import Optional, Tuple
+from typing import Optional, Tuple, List
 import nbformat
 from io import StringIO
 import sys
+import tempfile
+import zipfile
+from datetime import datetime
 
 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."""
@@ -83,75 +87,109 @@ class CodingCopilot:
         except Exception as e:
             return f"Error reading notebook: {str(e)}"
 
-    def analyze_code(self, code_content: str, analysis_type: str) -> str:
-        """Analyze code using Claude."""
-        prompts = {
+    def process_multiple_files(self, files: List) -> Tuple[str, str]:
+        """Process multiple uploaded files and return combined content."""
+        if not files:
+            return "", "No files uploaded"
+        
+        all_content = []
+        file_info = []
+        
+        for file in files:
+            file_path = file.name
+            file_name = os.path.basename(file_path)
+            file_extension = os.path.splitext(file_path)[1].lower()
+            
+            if file_extension == '.py':
+                content = self.read_python_file(file_path)
+            elif file_extension == '.ipynb':
+                content = self.read_notebook_file(file_path)
+            else:
+                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("# " + "="*50)
+                all_content.append(content)
+                all_content.append("\n" + "="*60 + "\n")
+                file_info.append(f"{file_name} ({file_extension})")
+        
+        combined_content = '\n'.join(all_content)
+        status = f"Successfully loaded {len(file_info)} files: {', '.join(file_info)}"
+        
+        return combined_content, status
+
+    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
-
-Code:
-```python
-{code_content}
-```""",
+5. Security considerations""",
             
             "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
-
-Code:
-```python
-{code_content}
-```""",
+5. Usage examples""",
             
             "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 optimized version
-
-Code:
-```python
-{code_content}
-```""",
+5. Provide the optimized version""",
             
             "debug": f"""Please help debug this code:
 1. Identify potential bugs
 2. Suggest fixes
 3. Add error handling
 4. Improve robustness
-5. Provide corrected version
-
-Code:
-```python
-{code_content}
-```""",
+5. Provide corrected version""",
             
             "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
+5. Add type hints where appropriate""",
+            
+            "custom": custom_prompt
+        }
+        
+        if analysis_type == "custom" and not custom_prompt.strip():
+            return "Please provide a custom prompt for analysis."
+        
+        prompt_text = base_prompts.get(analysis_type, base_prompts["review"])
+        
+        full_prompt = f"""{prompt_text}
 
 Code:
 ```python
 {code_content}
-```"""
-        }
+```
+
+Please provide a detailed response and if fixes are needed, provide the corrected code."""
         
-        prompt = prompts.get(analysis_type, prompts["review"])
-        return self.call_claude(prompt)
+        return self.call_claude(full_prompt)
+
+    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"""
 
-    def generate_code(self, description: str, language: str = "python") -> str:
-        """Generate code based on description."""
+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:
 
 {description}
@@ -162,172 +200,411 @@ Requirements:
 3. Add type hints where appropriate
 4. Provide usage examples
 5. Follow best practices
+{reference_context}
 
-Please provide only the code with comments."""
+Please provide the complete, ready-to-use code with detailed comments."""
         
         return self.call_claude(prompt)
 
-    def chat_with_code(self, code_content: str, question: str) -> str:
-        """Chat about specific code."""
+    def chat_with_code(self, code_content: str, question: str, chat_history: List = None) -> Tuple[str, List]:
+        """Chat about specific code with history."""
+        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:
 
 ```python
 {code_content}
 ```
+{context}
 
-Question: {question}
+Current question: {question}
 
-Please provide a detailed answer about the code."""
+Please provide a detailed answer about the code. If you're suggesting changes, provide the complete corrected code."""
         
-        return self.call_claude(prompt)
+        response = self.call_claude(prompt)
+        
+        # Update chat history
+        chat_history.append((question, response))
+        
+        return response, chat_history
+
+    def create_downloadable_file(self, content: str, filename: str = "generated_code.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()
+        
+        return temp_file.name
 
 # Initialize the copilot
 copilot = CodingCopilot()
 
-def process_file_upload(file) -> Tuple[str, str]:
-    """Process uploaded file and return content."""
-    if file is None:
-        return "", "No file uploaded"
-    
-    file_path = file.name
-    file_extension = os.path.splitext(file_path)[1].lower()
-    
-    if file_extension == '.py':
-        content = copilot.read_python_file(file_path)
-    elif file_extension == '.ipynb':
-        content = copilot.read_notebook_file(file_path)
-    else:
-        return "", f"Unsupported file type: {file_extension}. Please upload .py or .ipynb files."
-    
-    return content, f"Successfully loaded {file_extension} file"
+# Custom CSS for black and red theme
+custom_css = """
+.gradio-container {
+    background: linear-gradient(135deg, #0a0a0a 0%, #1a0a0a 100%) !important;
+    color: #ffffff !important;
+}
+
+.dark {
+    background: #0a0a0a !important;
+    color: #ffffff !important;
+}
+
+/* Tab styling */
+.tab-nav {
+    background: #1a1a1a !important;
+    border-bottom: 2px solid #dc2626 !important;
+}
+
+.tab-nav button {
+    background: #2a2a2a !important;
+    color: #ffffff !important;
+    border: 1px solid #dc2626 !important;
+    margin-right: 5px !important;
+}
+
+.tab-nav button[aria-selected="true"] {
+    background: #dc2626 !important;
+    color: #ffffff !important;
+}
+
+/* Input styling */
+.gr-textbox, .gr-dropdown, .gr-file {
+    background: #2a2a2a !important;
+    border: 1px solid #dc2626 !important;
+    color: #ffffff !important;
+}
+
+.gr-textbox:focus, .gr-dropdown:focus {
+    border-color: #ef4444 !important;
+    box-shadow: 0 0 0 2px rgba(220, 38, 38, 0.2) !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;
+}
 
-def analyze_uploaded_code(file, analysis_type):
-    """Analyze uploaded code file."""
-    if file is None:
-        return "Please upload a file first."
+.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;
+}
+
+/* Code block styling */
+.gr-code {
+    background: #1a1a1a !important;
+    border: 1px solid #dc2626 !important;
+}
+
+/* Panel styling */
+.gr-panel {
+    background: #1a1a1a !important;
+    border: 1px solid #333333 !important;
+}
+
+/* Markdown styling */
+.gr-markdown {
+    color: #ffffff !important;
+}
+
+.gr-markdown h1 {
+    color: #dc2626 !important;
+    text-shadow: 0 0 10px rgba(220, 38, 38, 0.5) !important;
+}
+
+.gr-markdown h2, .gr-markdown h3 {
+    color: #ef4444 !important;
+}
+
+/* File upload styling */
+.gr-file-upload {
+    background: #2a2a2a !important;
+    border: 2px dashed #dc2626 !important;
+    color: #ffffff !important;
+}
+
+.gr-file-upload:hover {
+    border-color: #ef4444 !important;
+    background: #3a2a2a !important;
+}
+
+/* Chat history styling */
+.chat-history {
+    background: #1a1a1a !important;
+    border: 1px solid #dc2626 !important;
+    border-radius: 8px !important;
+    padding: 10px !important;
+    max-height: 400px !important;
+    overflow-y: auto !important;
+}
+
+.chat-message {
+    margin: 10px 0 !important;
+    padding: 8px !important;
+    border-left: 3px solid #dc2626 !important;
+    background: #2a2a2a !important;
+}
+"""
+
+def analyze_uploaded_code(files, analysis_type, custom_prompt):
+    """Analyze uploaded code files."""
+    if not files:
+        return "Please upload at least one file."
     
-    content, status = process_file_upload(file)
+    content, status = copilot.process_multiple_files(files)
     if not content or content.startswith("Error"):
         return status or content
     
-    return copilot.analyze_code(content, analysis_type)
+    result = copilot.analyze_code(content, analysis_type, custom_prompt)
+    return f"**Status:** {status}\n\n**Analysis Result:**\n{result}"
 
-def generate_new_code(description, language):
-    """Generate new code based on description."""
+def generate_new_code(description, language, reference_files):
+    """Generate new code based on description with reference files."""
     if not description.strip():
-        return "Please provide a description of what you want to generate."
+        return "Please provide a description of what you want to generate.", None
+    
+    reference_content = ""
+    if reference_files:
+        reference_content, _ = copilot.process_multiple_files(reference_files)
     
-    return copilot.generate_code(description, language)
+    result = copilot.generate_code(description, language, reference_content)
+    
+    # Create downloadable file
+    filename = f"generated_{language}_code.py"
+    temp_file = copilot.create_downloadable_file(result, filename)
+    
+    return result, temp_file
 
-def chat_about_code(file, question):
-    """Chat about uploaded code."""
-    if file is None:
-        return "Please upload a file first."
+def chat_about_code(files, question, chat_history):
+    """Chat about uploaded code with history."""
+    if not files:
+        return "Please upload at least one file.", chat_history, ""
     
     if not question.strip():
-        return "Please ask a question about the code."
+        return "Please ask a question about the code.", chat_history, ""
     
-    content, status = process_file_upload(file)
+    content, status = copilot.process_multiple_files(files)
     if not content or content.startswith("Error"):
-        return status or content
+        return status or content, chat_history, ""
+    
+    if chat_history is None:
+        chat_history = []
+    
+    response, updated_history = copilot.chat_with_code(content, question, chat_history)
+    
+    # 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"
     
-    return copilot.chat_with_code(content, question)
+    # 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 gr.Blocks(title="Coding Copilot", theme=gr.themes.Soft()) as app:
-    gr.Markdown("# 🤖 Coding Copilot")
-    gr.Markdown("Upload your Python files (.py) or Jupyter notebooks (.ipynb) for analysis, or generate new code!")
+# Create Gradio interface with custom theme
+with gr.Blocks(title="🔥 Advanced Coding Copilot", css=custom_css, theme=gr.themes.Base()) as app:
+    gr.Markdown("""
+    # 🔥 Advanced Coding Copilot
+    ### Upload multiple Python files (.py) or Jupyter notebooks (.ipynb) for intelligent analysis, or generate new code with AI assistance!
+    """)
     
     with gr.Tabs():
-        # File Analysis Tab
+        # Enhanced File Analysis Tab
         with gr.TabItem("📁 Analyze Code"):
+            gr.Markdown("### Upload multiple files and get comprehensive analysis")
             with gr.Row():
-                with gr.Column():
+                with gr.Column(scale=1):
                     file_input = gr.File(
-                        label="Upload Python File (.py) or Jupyter Notebook (.ipynb)",
-                        file_types=[".py", ".ipynb"]
+                        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"],
+                        choices=["review", "explain", "optimize", "debug", "document", "custom"],
                         value="review",
-                        label="Analysis Type"
+                        label="🔍 Analysis Type",
+                        info="Choose analysis type or select 'custom' to write your own prompt"
+                    )
+                    custom_prompt = gr.Textbox(
+                        label="✏️ Custom Prompt (when Analysis Type = 'custom')",
+                        lines=3,
+                        placeholder="Write your custom analysis prompt here...",
+                        visible=False
                     )
-                    analyze_btn = gr.Button("Analyze Code", variant="primary")
+                    analyze_btn = gr.Button("🚀 Analyze Code", variant="primary", size="lg")
                 
-                with gr.Column():
+                with gr.Column(scale=2):
                     analysis_output = gr.Textbox(
-                        label="Analysis Result",
-                        lines=20,
-                        max_lines=30
+                        label="📊 Analysis Result",
+                        lines=25,
+                        max_lines=40,
+                        show_copy_button=True
                     )
             
+            # Show/hide custom prompt based on analysis type
+            def toggle_custom_prompt(analysis_type):
+                return gr.update(visible=(analysis_type == "custom"))
+            
+            analysis_type.change(toggle_custom_prompt, inputs=analysis_type, outputs=custom_prompt)
             analyze_btn.click(
                 analyze_uploaded_code,
-                inputs=[file_input, analysis_type],
+                inputs=[file_input, analysis_type, custom_prompt],
                 outputs=analysis_output
             )
         
-        # Code Generation Tab
+        # Enhanced Code Generation Tab
         with gr.TabItem("⚡ Generate Code"):
+            gr.Markdown("### Generate new code with optional reference files")
             with gr.Row():
-                with gr.Column():
+                with gr.Column(scale=1):
                     code_description = gr.Textbox(
-                        label="Describe what you want to code",
+                        label="📝 Describe what you want to code",
                         lines=5,
-                        placeholder="E.g., Create a function to sort a list of dictionaries by a specific key..."
+                        placeholder="E.g., Create a REST API using FastAPI with authentication, database models, and CRUD operations..."
                     )
                     code_language = gr.Dropdown(
-                        choices=["python", "javascript", "java", "cpp", "c"],
+                        choices=["python", "javascript", "java", "cpp", "c", "go", "rust"],
                         value="python",
-                        label="Programming Language"
+                        label="💻 Programming Language"
+                    )
+                    reference_files = gr.File(
+                        label="📚 Reference Files (optional)",
+                        file_count="multiple",
+                        file_types=[".py", ".ipynb"],
+                        info="Upload files to use as reference/context"
                     )
-                    generate_btn = gr.Button("Generate Code", variant="primary")
+                    generate_btn = gr.Button("🎯 Generate Code", variant="primary", size="lg")
                 
-                with gr.Column():
+                with gr.Column(scale=2):
                     generated_code = gr.Code(
-                        label="Generated Code",
+                        label="🔧 Generated Code",
                         language="python",
-                        lines=20
+                        lines=25,
+                        show_copy_button=True
                     )
+                    download_generated = gr.File(
+                        label="💾 Download Generated Code",
+                        visible=False,
+                        interactive=False
+                    )
+            
+            def handle_generation(desc, lang, ref_files):
+                code, file_path = generate_new_code(desc, lang, ref_files)
+                return code, gr.update(value=file_path, visible=True)
             
             generate_btn.click(
-                generate_new_code,
-                inputs=[code_description, code_language],
-                outputs=generated_code
+                handle_generation,
+                inputs=[code_description, code_language, reference_files],
+                outputs=[generated_code, download_generated]
             )
         
-        # Code Chat Tab
+        # Enhanced Code Chat Tab
         with gr.TabItem("💬 Chat About Code"):
+            gr.Markdown("### Interactive chat about your code with conversation history")
             with gr.Row():
-                with gr.Column():
+                with gr.Column(scale=1):
                     chat_file_input = gr.File(
-                        label="Upload Code File",
-                        file_types=[".py", ".ipynb"]
+                        label="📂 Upload Code Files",
+                        file_count="multiple",
+                        file_types=[".py", ".ipynb"],
+                        height=120
                     )
                     code_question = gr.Textbox(
-                        label="Ask a question about your code",
+                        label="❓ Ask a question about your code",
                         lines=3,
-                        placeholder="E.g., How can I improve the performance of this function?"
+                        placeholder="E.g., How can I optimize this algorithm? What design patterns are used here?"
                     )
-                    chat_btn = gr.Button("Ask Question", variant="primary")
+                    chat_btn = gr.Button("💭 Ask Question", variant="primary", size="lg")
+                    clear_chat_btn = gr.Button("🗑️ Clear Chat History", variant="secondary")
                 
-                with gr.Column():
+                with gr.Column(scale=2):
                     chat_output = gr.Textbox(
-                        label="Answer",
+                        label="🤖 AI Response",
                         lines=15,
-                        max_lines=25
+                        max_lines=25,
+                        show_copy_button=True
+                    )
+                    chat_history_display = gr.Textbox(
+                        label="📜 Chat History",
+                        lines=10,
+                        max_lines=20,
+                        show_copy_button=True,
+                        info="Complete conversation history"
                     )
+                    download_chat = gr.File(
+                        label="💾 Download Chat Response",
+                        visible=False,
+                        interactive=False
+                    )
+            
+            # 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(
-                chat_about_code,
-                inputs=[chat_file_input, code_question],
-                outputs=chat_output
+                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]
+            )
+    
+    # Enhanced Footer
+    gr.Markdown("""
+    ---
+    ### 🔥 Features:
+    - **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
     
-    # Footer
-    gr.Markdown("---")
-    gr.Markdown("**Note:** This copilot uses Claude 3 Haiku for intelligent code analysis and generation.")
+    **Powered by:** Claude 3 Haiku via AWS Bedrock | **Theme:** Cyberpunk Black & Red
+    """)
 
 # Launch the app
 if __name__ == "__main__":
-    app.launch()
+    app.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=True,
+        show_error=True
+    )