Update app.py

app.py

@@ -972,71 +972,207 @@ class GradioInterface:
             generate_preview,
             outputs=[preview_status]
         )
-
-    def _create_ai_tab(self):
-        """Create the AI assistant tab"""
-        with gr.Row():
-            with gr.Column(scale=2):
-                chat_history = gr.Chatbot(label="Chat History")
-                user_input = gr.Textbox(
-                    label="Your Instructions",
-                    placeholder="Describe what you want to build or modify...",
-                    lines=3
-                )
-                with gr.Row():
-                    send_btn = gr.Button("Send", variant="primary")
-                    clear_btn = gr.Button("Clear Chat")
+def _create_ai_tab(self):
+    """Create AI assistant tab with streamlined yes/no interaction"""
+    with gr.Row():
+        with gr.Column(scale=2):
+            gr.Markdown("""### 🤖 AI Assistant - Quick Build
+            Start by selecting your main task, then answer with Yes/No to refine the solution.
             
-            with gr.Column(scale=1):
-                suggestions = gr.JSON(label="Suggested Components")
-                preview_btn = gr.Button("Update Preview")
-                preview_frame = gr.HTML(label="Live Preview")
-
-        chat_error = gr.Markdown(visible=False)
-
-        async def process_chat(message, history):
-            if not self.app_builder.ai_builder:
-                self.app_builder.ai_builder = GradioAIBuilder()
+            Available Commands:
+            1. create - New app
+            2. component - Add/modify components
+            3. layout - Change layout
+            4. style - Customize appearance
+            5. data - Data processing
+            6. api - API integration
+            7. auth - Authentication
+            8. file - File operations
+            9. viz - Visualization
+            10. db - Database
+            """)
             
-            try:
-                result = await self.app_builder.ai_builder.process_user_request(message)
-                
-                if result["status"] == "error":
-                    return (
-                        history + [[message, "Error: " + result["response"]]],
-                        [],
-                        gr.Markdown(f"⚠️ {result['error']}", visible=True)
-                    )
-                
-                new_history = history + [[message, result["response"]]]
-                
-                return new_history, [], gr.Markdown(visible=False)
+            chat_history = gr.Chatbot(label="Interaction History")
+            user_input = gr.Radio(
+                choices=["Yes", "No"],
+                label="Your Response",
+                visible=False
+            )
+            command_input = gr.Dropdown(
+                choices=["create", "component", "layout", "style", "data", "api", "auth", "file", "viz", "db"],
+                label="Select Command to Start",
+            )
+            with gr.Row():
+                send_btn = gr.Button("Send", variant="primary")
+                restart_btn = gr.Button("Restart", variant="secondary")
+
+    class ChatState:
+        def __init__(self):
+            self.current_step = 0
+            self.command = None
+            self.context = {}
             
-            except Exception as e:
-                error_msg = f"Error processing chat: {str(e)}"
-                logger.error(error_msg)
-                return (
-                    history + [[message, "An error occurred"]],
-                    [],
-                    gr.Markdown(f"⚠️ {error_msg}", visible=True)
-                )
+        def reset(self):
+            self.current_step = 0
+            self.command = None
+            self.context = {}
+
+    chat_state = ChatState()
+
+    def get_next_question(command, step, previous_answer=None):
+        """Generate next question based on command and current step"""
+        questions = {
+            "create": [
+                "Do you need user input components?",
+                "Do you need data processing functionality?",
+                "Would you like to add styling/themes?"
+            ],
+            "component": [
+                "Is this for user input?",
+                "Do you need media handling (image/audio/video)?",
+                "Should the component have real-time updates?"
+            ],
+            "layout": [
+                "Do you want a multi-tab layout?",
+                "Do you need responsive design?",
+                "Should components be arranged horizontally?"
+            ],
+            "style": [
+                "Do you want a dark theme?",
+                "Do you need custom CSS?",
+                "Should components have rounded corners?"
+            ],
+            "data": [
+                "Will you be handling file uploads?",
+                "Do you need data visualization?",
+                "Should data be stored persistently?"
+            ],
+            "api": [
+                "Do you need authentication for API?",
+                "Will you be handling JSON data?",
+                "Do you need error handling?"
+            ],
+            "auth": [
+                "Do you need user registration?",
+                "Should sessions be persistent?",
+                "Do you need role-based access?"
+            ],
+            "file": [
+                "Will you handle multiple file types?",
+                "Do you need file preprocessing?",
+                "Should files be stored locally?"
+            ],
+            "viz": [
+                "Do you need interactive plots?",
+                "Will you use real-time data?",
+                "Do you need multiple chart types?"
+            ],
+            "db": [
+                "Do you need real-time updates?",
+                "Will you use SQL database?",
+                "Do you need data caching?"
+            ]
+        }
+        
+        if step < len(questions[command]):
+            return questions[command][step]
+        return None
+
+    def generate_code(command, context):
+        """Generate code based on collected context"""
+        base_templates = {
+            "create": """
+```python
+import gradio as gr
 
-        def clear_chat_history():
-            if self.app_builder.ai_builder:
-                self.app_builder.ai_builder.chat_history = []
-            return [], [], gr.Markdown(visible=False)
+def process_input({input_params}):
+    {processing_logic}
+    return result
 
-        send_btn.click(
-            process_chat,
-            inputs=[user_input, chat_history],
-            outputs=[chat_history, suggestions, chat_error]
-        )
-        
-        clear_btn.click(
-            clear_chat_history,
-            outputs=[chat_history, suggestions, chat_error]
+with gr.Blocks({style_params}) as demo:
+    {components}
+    {layout}
+    {event_handlers}
+
+demo.launch()
+```""",
+            "component": """
+```python
+{import_statements}
+
+{component_definition}
+
+{event_handling}
+```""",
+            # Add other base templates for each command...
+        }
+
+        # Customize template based on context
+        if command == "create":
+            input_params = "user_input"
+            processing_logic = "result = user_input"
+            style_params = "theme=gr.themes.Default()" if not context.get("dark_theme") else "theme=gr.themes.Monochrome()"
+            components = "input_component = gr.Textbox(label='Input')\noutput_component = gr.Textbox(label='Output')"
+            layout = "gr.Button('Process')"
+            event_handlers = "input_component.change(process_input, inputs=input_component, outputs=output_component)"
+
+        return base_templates[command].format(
+            input_params=input_params,
+            processing_logic=processing_logic,
+            style_params=style_params,
+            components=components,
+            layout=layout,
+            event_handlers=event_handlers
         )
 
+    def process_chat(command, answer, history):
+        """Process chat interaction"""
+        try:
+            if command and chat_state.command != command:
+                # New command started
+                chat_state.reset()
+                chat_state.command = command
+                question = get_next_question(command, 0)
+                return history + [[None, question]], True, question
+
+            if answer:
+                # Store answer and get next question
+                chat_state.context[f"step_{chat_state.current_step}"] = answer == "Yes"
+                chat_state.current_step += 1
+                
+                next_question = get_next_question(chat_state.command, chat_state.current_step)
+                
+                if next_question:
+                    # More questions to ask
+                    return history + [[answer, next_question]], True, next_question
+                else:
+                    # Generate final code
+                    code = generate_code(chat_state.command, chat_state.context)
+                    return history + [[answer, f"Here's your code:\n{code}"]], False, None
+
+            return history, True, None
+
+        except Exception as e:
+            error_msg = f"Error: {str(e)}"
+            logger.error(error_msg)
+            return history + [[None, error_msg]], False, None
+
+    def reset_chat():
+        """Reset chat state and history"""
+        chat_state.reset()
+        return None, None, False, None
+
+    # Set up event handlers
+    send_btn.click(
+        process_chat,
+        inputs=[command_input, user_input, chat_history],
+        outputs=[chat_history, user_input, user_input]
+    )
+    
+    restart_btn.click(
+        reset_chat,
+        outputs=[chat_history, command_input, user_input, user_input]
+    )
     def _create_settings_tab(self):
         """Create the settings tab"""
         with gr.Row():