Update app.py

app.py

@@ -1,314 +1,631 @@
-import threading
-import time
 import gradio as gr
-import logging
 import json
-import re
-import torch
-import tempfile
-import os
-from pathlib import Path
-from typing import Dict, List, Tuple, Optional, Any, Union
+import logging
+from enum import Enum, auto
+from typing import Protocol, List, Dict, Any
 from dataclasses import dataclass, field
-from enum import Enum
-from transformers import AutoTokenizer, AutoModelForCausalLM, pipeline
-from sentence_transformers import SentenceTransformer
-import faiss
-import numpy as np
-from PIL import Image
-import black
-
-# Configure logging
-logging.basicConfig(
-    level=logging.INFO,
-    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
-    handlers=[
-        logging.StreamHandler(),
-        logging.FileHandler('gradio_builder.log')
-    ]
-)
+from datetime import datetime
+import difflib
+import pytest
+from concurrent.futures import ThreadPoolExecutor
+import asyncio
+
+# Initialize logger
+logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-# Configuration
+class AgentRole(Enum):
+    ARCHITECT = auto()
+    FRONTEND = auto()
+    BACKEND = auto()
+    DATABASE = auto()
+    TESTER = auto()
+    REVIEWER = auto()
+    DEPLOYER = auto()
+
+@dataclass
+class AgentDecision:
+    agent: 'Agent'
+    decision: str
+    confidence: float
+    reasoning: str
+    timestamp: datetime = field(default_factory=datetime.now)
+    dependencies: List['AgentDecision'] = field(default_factory=list)
+
+class AgentProtocol(Protocol):
+    async def decide(self, context: Dict[str, Any]) -> AgentDecision: ...
+    async def validate(self, decision: AgentDecision) -> bool: ...
+    async def implement(self, decision: AgentDecision) -> Any: ...
+    async def test(self, implementation: Any) -> bool: ...
+
 @dataclass
-class Config:
-    port: int = 7860
-    debug: bool = False
-    share: bool = False
-    model_name: str = "gpt2"
-    embedding_model: str = "all-mpnet-base-v2"
-    theme: str = "default"
-    max_code_length: int = 5000
-    
-    @classmethod
-    def from_file(cls, path: str) -> "Config":
+class Agent:
+    role: AgentRole
+    name: str
+    autonomy_level: float  # 0-10
+    expertise: List[str]
+    confidence_threshold: float = 0.7
+
+    async def reason(self, context: Dict[str, Any]) -> str:
+        """Generate reasoning based on context and expertise"""
+        prompt = f"""
+        As {self.name}, a {self.role.name} expert with expertise in {', '.join(self.expertise)},
+        analyze the following context and provide reasoning:
+
+        Context:
+        {json.dumps(context, indent=2)}
+
+        Consider:
+        1. Required components and their interactions
+        2. Potential challenges and solutions
+        3. Best practices and patterns
+        4. Security and performance implications
+
+        Reasoning:
+        """
+        return await self.rag_system.generate_reasoning(prompt)
+
+class AgentSystem:
+    def __init__(self, config: Config):
+        self.config = config
+        self.autonomy_level = 0.0  # 0-10
+        self.agents: Dict[AgentRole, Agent] = self._initialize_agents()
+        self.decision_history: List[AgentDecision] = []
+        self.executor = ThreadPoolExecutor(max_workers=10)
+        self.rag_system = RAGSystem(config)
+
+    def _initialize_agents(self) -> Dict[AgentRole, Agent]:
+        return {
+            AgentRole.ARCHITECT: Agent(
+                role=AgentRole.ARCHITECT,
+                name="System Architect",
+                autonomy_level=self.autonomy_level,
+                expertise=["system design", "architecture patterns", "integration"]
+            ),
+            AgentRole.FRONTEND: Agent(
+                role=AgentRole.FRONTEND,
+                name="Frontend Developer",
+                autonomy_level=self.autonomy_level,
+                expertise=["UI/UX", "React", "Vue", "Angular"]
+            ),
+            AgentRole.BACKEND: Agent(
+                role=AgentRole.BACKEND,
+                name="Backend Developer",
+                autonomy_level=self.autonomy_level,
+                expertise=["API design", "database", "security"]
+            ),
+            AgentRole.TESTER: Agent(
+                role=AgentRole.TESTER,
+                name="Quality Assurance",
+                autonomy_level=self.autonomy_level,
+                expertise=["testing", "automation", "quality assurance"]
+            ),
+            AgentRole.REVIEWER: Agent(
+                role=AgentRole.REVIEWER,
+                name="Code Reviewer",
+                autonomy_level=self.autonomy_level,
+                expertise=["code quality", "best practices", "security"]
+            ),
+        }
+
+    async def set_autonomy_level(self, level: float) -> None:
+        """Update autonomy level for all agents"""
+        self.autonomy_level = max(0.0, min(10.0, level))
+        for agent in self.agents.values():
+            agent.autonomy_level = self.autonomy_level
+
+    async def process_request(self, description: str, context: Dict[str, Any] = None) -> Dict[str, Any]:
+        """Process a user request with current autonomy level"""
         try:
-            with open(path) as f:
-                return cls(**json.load(f))
-        except Exception as e:
-            logger.warning(f"Failed to load config from {path}: {e}. Using defaults.")
-            return cls()
+            context = context or {}
+            context['description'] = description
+            context['autonomy_level'] = self.autonomy_level
+
+            # Start with architect's decision
+            arch_decision = await self.agents[AgentRole.ARCHITECT].decide(context)
+            self.decision_history.append(arch_decision)
+
+            if self.autonomy_level < 3:
+                # Low autonomy: Wait for user confirmation
+                return {
+                    'status': 'pending_confirmation',
+                    'decision': arch_decision,
+                    'next_steps': self._get_next_steps(arch_decision)
+                }
 
-# Constants
-CONFIG_PATH = Path("config.json")
-MODEL_CACHE_DIR = Path("model_cache")
-TEMPLATE_DIR = Path("templates")
-TEMP_DIR = Path("temp")
-DATABASE_PATH = Path("code_database.json")
+            # Medium to high autonomy: Proceed with implementation
+            implementation_plan = await self._create_implementation_plan(arch_decision)
 
-# Ensure directories exist
-for directory in [MODEL_CACHE_DIR, TEMPLATE_DIR, TEMP_DIR]:
-    directory.mkdir(exist_ok=True, parents=True)
+            if self.autonomy_level >= 7:
+                # High autonomy: Automatic implementation and testing
+                return await self._automated_implementation(implementation_plan)
 
-@dataclass
-class Template:
-    code: str
-    description: str
-    components: List[str] = field(default_factory=list)
-    created_at: str = field(default_factory=lambda: time.strftime("%Y-%m-%d %H:%M:%S"))
-    tags: List[str] = field(default_factory=list)
-
-class TemplateManager:
-    def __init__(self, template_dir: Path):
-        self.template_dir = template_dir
-        self.templates: Dict[str, Template] = {}
-
-    def load_templates(self) -> None:
-        for file_path in self.template_dir.glob("*.json"):
-            try:
-                with open(file_path, 'r') as f:
-                    template_data = json.load(f)
-                    template = Template(**template_data)
-                    self.templates[template_data['description']] = template
-                logger.info(f"Loaded template: {file_path.stem}")
-            except Exception as e:
-                logger.error(f"Error loading template from {file_path}: {e}")
+            # Medium autonomy: Return plan for user review
+            return {
+                'status': 'pending_review',
+                'plan': implementation_plan,
+                'decisions': self.decision_history
+            }
 
-    def save_template(self, name: str, template: Template) -> bool:
-        file_path = self.template_dir / f"{name}.json"
-        try:
-            with open(file_path, 'w') as f:
-                json.dump(dataclasses.asdict(template), f, indent=2)
-            self.templates[name] = template
-            return True
         except Exception as e:
-            logger.error(f"Error saving template to {file_path}: {e}")
-            return False
+            logger.error(f"Error in request processing: {e}")
+            return {'status': 'error', 'message': str(e)}
+
+    async def _create_implementation_plan(self, arch_decision: AgentDecision) -> Dict[str, Any]:
+        """Create detailed implementation plan based on architect's decision"""
+        tasks = []
+
+        # Frontend tasks
+        if 'frontend' in arch_decision.decision.lower():
+            tasks.append(self._create_frontend_tasks(arch_decision))
+
+        # Backend tasks
+        if 'backend' in arch_decision.decision.lower():
+            tasks.append(self._create_backend_tasks(arch_decision))
+
+        # Testing tasks
+        tasks.append(self._create_testing_tasks(arch_decision))
+
+        return {
+            'tasks': await asyncio.gather(*tasks),
+            'dependencies': arch_decision.dependencies,
+            'estimated_time': self._estimate_implementation_time(tasks)
+        }
+
+    async def _automated_implementation(self, plan: Dict[str, Any]) -> Dict[str, Any]:
+        """Execute implementation plan automatically"""
+        results = {
+            'frontend': None,
+            'backend': None,
+            'tests': None,
+            'review': None
+        }
 
-    def get_template(self, name: str) -> Optional[str]:
-        template = self.templates.get(name)
-        return template.code if template else ""
+        try:
+            # Parallel implementation of frontend and backend
+            impl_tasks = []
+            if 'frontend' in plan['tasks']:
+                impl_tasks.append(self._implement_frontend(plan['tasks']['frontend']))
+            if 'backend' in plan['tasks']:
+                impl_tasks.append(self._implement_backend(plan['tasks']['backend']))
+
+            implementations = await asyncio.gather(*impl_tasks)
+
+            # Testing
+            test_results = await self.agents[AgentRole.TESTER].test(implementations)
+
+            # Code review
+            review_results = await self.agents[AgentRole.REVIEWER].validate({
+                'implementations': implementations,
+                'test_results': test_results
+            })
+
+            return {
+                'status': 'completed',
+                'implementations': implementations,
+                'test_results': test_results,
+                'review': review_results,
+                'decisions': self.decision_history
+            }
 
-    def delete_template(self, name: str) -> bool:
-        file_path = self.template_dir / f"{name}.json"
+        except Exception as e:
+            return {
+                'status': 'error',
+                'message': str(e),
+                'partial_results': results
+            }
+
+    async def _handle_implementation_failure(self, error: Exception, context: Dict[str, Any]) -> Dict[str, Any]:
+        """Handle implementation failures with adaptive response"""
         try:
-            file_path.unlink()
-            self.templates.pop(name, None)
-            return True
+            # Analyze error
+            error_analysis = await self.agents[AgentRole.REVIEWER].reason({
+                'error': str(error),
+                'context': context
+            })
+
+            # Determine correction strategy
+            if self.autonomy_level >= 8:
+                # High autonomy: Attempt automatic correction
+                correction = await self._attempt_automatic_correction(error_analysis)
+                if correction['success']:
+                    return await self.process_request(context['description'], correction['context'])
+
+            return {
+                'status': 'failure',
+                'error': str(error),
+                'analysis': error_analysis,
+                'suggested_corrections': self._suggest_corrections(error_analysis)
+            }
+
         except Exception as e:
-            logger.error(f"Error deleting template {name}: {e}")
-            return False
+            logger.error(f"Error handling implementation failure: {e}")
+            return {'status': 'critical_error', 'message': str(e)}
+
+class AgentTester:
+    def __init__(self):
+        self.test_suites = {
+            'frontend': self._test_frontend,
+            'backend': self._test_backend,
+            'integration': self._test_integration
+        }
+
+    async def _test_frontend(self, implementation: Dict[str, Any]) -> Dict[str, Any]:
+        """Run frontend tests"""
+        results = {
+            'passed': [],
+            'failed': [],
+            'warnings': []
+        }
+
+        # Component rendering tests
+        for component in implementation.get('components', []):
+            try:
+                # Test component rendering
+                result = await self._test_component_render(component)
+                if result['success']:
+                    results['passed'].append(f"Component {component['name']} renders correctly")
+                else:
+                    results['failed'].append(f"Component {component['name']}: {result['error']}")
+            except Exception as e:
+                results['failed'].append(f"Error testing {component['name']}: {str(e)}")
 
-class RAGSystem:
-    def __init__(self, config: Config):
-        self.config = config
-        self.device = "cuda" if torch.cuda.is_available() else "cpu"
-        self.embedding_model = None
-        self.code_embeddings = None
-        self.index = None
-        self.database = {'codes': [], 'embeddings': []}
-        self.pipe = None
+        return results
 
-        try:
-            self.tokenizer = AutoTokenizer.from_pretrained(
-                config.model_name, 
-                cache_dir=MODEL_CACHE_DIR
-            )
-            self.model = AutoModelForCausalLM.from_pretrained(
-                config.model_name, 
-                cache_dir=MODEL_CACHE_DIR
-            ).to(self.device)
-            self.pipe = pipeline(
-                "text-generation", 
-                model=self.model, 
-                tokenizer=self.tokenizer, 
-                device=self.device
-            )
-            self.embedding_model = SentenceTransformer(config.embedding_model)
-            self.load_database()
-            logger.info("RAG system initialized successfully.")
-        except Exception as e:
-            logger.error(f"Error initializing RAG system: {e}")
+    async def _test_backend(self, implementation: Dict[str, Any]) -> Dict[str, Any]:
+        """Run backend tests"""
+        results = {
+            'passed': [],
+            'failed': [],
+            'warnings': []
+        }
 
-    def load_database(self) -> None:
-        if DATABASE_PATH.exists():
+        # API endpoint tests
+        for endpoint in implementation.get('endpoints', []):
             try:
-                with open(DATABASE_PATH, 'r', encoding='utf-8') as f:
-                    self.database = json.load(f)
-                    self.code_embeddings = np.array(self.database['embeddings'])
-                logger.info(f"Loaded {len(self.database['codes'])} code snippets from database.")
-                self._build_index()
+                # Test endpoint functionality
+                result = await self._test_endpoint(endpoint)
+                if result['success']:
+                    results['passed'].append(f"Endpoint {endpoint['path']} works correctly")
+                else:
+                    results['failed'].append(f"Endpoint {endpoint['path']}: {result['error']}")
             except Exception as e:
-                logger.error(f"Error loading database: {e}")
-                self._initialize_empty_database()
-        else:
-            logger.info("Creating new database.")
-            self._initialize_empty_database()
-
-    def _initialize_empty_database(self) -> None:
-        self.database = {'codes': [], 'embeddings': []}
-        self.code_embeddings = np.array([])
-        self._build_index()
-
-    def _build_index(self) -> None:
-        if len(self.code_embeddings) > 0 and self.embedding_model:
-            dim = self.code_embeddings.shape[1]
-            self.index = faiss.IndexFlatL2(dim)
-            self.index.add(self.code_embeddings)
-            logger.info(f"Built FAISS index with {len(self.code_embeddings)} vectors")
+                results['failed'].append(f"Error testing {endpoint['path']}: {str(e)}")
 
-class GradioInterface:
-    def __init__(self, config: Config):
-        self.config = config
-        self.template_manager = TemplateManager(TEMPLATE_DIR)
-        self.template_manager.load_templates()
-        self.rag_system = RAGSystem(config)
+        return results
 
-    def format_code(self, code: str) -> str:
-        try:
-            return black.format_str(code, mode=black.FileMode())
-        except Exception as e:
-            logger.warning(f"Code formatting failed: {e}")
-            return code
+    async def _test_integration(self, implementation: Dict[str, Any]) -> Dict[str, Any]:
+        """Run integration tests"""
+        results = {
+            'passed': [],
+            'failed': [],
+            'warnings': []
+        }
 
-    def _extract_components(self, code: str) -> List[str]:
-        components = []
+        # Test frontend-backend integration
         try:
-            function_matches = re.findall(r'def (\w+)\(', code)
-            class_matches = re.findall(r'class (\w+):', code)
-            components.extend(function_matches)
-            components.extend(class_matches)
+            result = await self._test_frontend_backend_integration(implementation)
+            if result['success']:
+                results['passed'].append("Frontend-Backend integration successful")
+            else:
+                results['failed'].append(f"Integration error: {result['error']}")
         except Exception as e:
-            logger.error(f"Error extracting components: {e}")
-        return list(set(components))
+            results['failed'].append(f"Integration test error: {str(e)}")
+
+        return results
+
+class AgentValidator:
+    def __init__(self):
+        self.validators = {
+            'code_quality': self._validate_code_quality,
+            'security': self._validate_security,
+            'performance': self._validate_performance
+        }
+
+    async def validate_implementation(self, implementation: Dict[str, Any]) -> Dict[str, Any]:
+        """Validate implementation against best practices"""
+        results = {
+            'passed': [],
+            'failed': [],
+            'warnings': []
+        }
+
+        for validator_name, validator in self.validators.items():
+            try:
+                validation_result = await validator(implementation)
+                results['passed'].extend(validation_result.get('passed', []))
+                results['failed'].extend(validation_result.get('failed', []))
+                results['warnings'].extend(validation_result.get('warnings', []))
+            except Exception as e:
+                results['warnings'].append(f"Validator {validator_name} error: {str(e)}")
+
+        return results
+
+class GradioInterface:
+    def __init__(self, config: Config):
+        self.config = config
+        self.agent_system = AgentSystem(config)
+        self.explorer = CodeExplorer()
+        self.backend_generator = BackendGenerator(config)
+        self.file_handler = FileHandler()
+        self.preview_size = {"width": "100%", "height": "600px"}
+        self.is_preview_loading = False
 
     def launch(self) -> None:
         with gr.Blocks(theme=gr.themes.Base()) as interface:
-            # Custom CSS
-            gr.Markdown(
-                """
-                <style>
-                .header {
-                    text-align: center;
-                    background-color: #f0f0f0;
-                    padding: 20px;
-                    border-radius: 10px;
-                    margin-bottom: 20px;
-                }
-                .container {
-                    max-width: 1200px;
-                    margin: 0 auto;
-                }
-                </style>
-                <div class="header">
-                <h1>Code Generation Interface</h1>
-                <p>Generate and manage code templates easily</p>
-                </div>
-                """
-            )
+            # Header
+            gr.Markdown("# AI-Powered Development Environment")
+
+            with gr.Tabs() as tabs:
+                # Code Generation Tab
+                with gr.Tab("Code Generation"):
+                    with gr.Row():
+                        with gr.Column(scale=1):
+                            code_input = gr.Code(
+                                label="Input Code",
+                                language="python",
+                                lines=20
+                            )
+                            generate_button = gr.Button("Generate")
+
+                        with gr.Column(scale=1):
+                            code_output = gr.Code(
+                                label="Generated Code",
+                                language="python",
+                                lines=20
+                            )
+                            status_message = gr.Markdown("")
+
+                # Agent Control Tab
+                with gr.Tab("Agent Control"):
+                    with gr.Row():
+                        autonomy_slider = gr.Slider(
+                            minimum=0,
+                            maximum=10,
+                            value=0,
+                            step=0.1,
+                            label="Agent Autonomy Level",
+                            info="0: Manual, 10: Fully Autonomous"
+                        )
+
+                    with gr.Row():
+                        with gr.Column(scale=1):
+                            project_description = gr.Textbox(
+                                label="Project Description",
+                                placeholder="Describe what you want to build...",
+                                lines=5
+                            )
+
+                            with gr.Accordion("Advanced Options", open=False):
+                                framework_choice = gr.Dropdown(
+                                    choices=["React", "Vue", "Angular", "FastAPI", "Flask", "Django"],
+                                    multiselect=True,
+                                    label="Preferred Frameworks"
+                                )
+                                architecture_style = gr.Radio(
+                                    choices=["Monolithic", "Microservices", "Serverless"],
+                                    label="Architecture Style",
+                                    value="Monolithic"
+                                )
+                                testing_preference = gr.Checkbox(
+                                    label="Include Tests",
+                                    value=True
+                                )
+
+                            process_button = gr.Button("Process Request")
+
+                        with gr.Column(scale=2):
+                            with gr.Tabs() as agent_tabs:
+                                with gr.Tab("Decision Log"):
+                                    decision_log = gr.JSON(
+                                        label="Agent Decisions",
+                                        show_label=True
+                                    )
+
+                                with gr.Tab("Implementation"):
+                                    with gr.Tabs() as impl_tabs:
+                                        with gr.Tab("Frontend"):
+                                            frontend_code = gr.Code(
+                                                label="Frontend Implementation",
+                                                language="javascript",
+                                                lines=20
+                                            )
+                                        with gr.Tab("Backend"):
+                                            backend_code = gr.Code(
+                                                label="Backend Implementation",
+                                                language="python",
+                                                lines=20
+                                            )
+                                        with gr.Tab("Database"):
+                                            database_code = gr.Code(
+                                                label="Database Schema",
+                                                language="sql",
+                                                lines=20
+                                            )
+
+                                with gr.Tab("Test Results"):
+                                    test_results = gr.JSON(
+                                        label="Test Results"
+                                    )
+                                    rerun_tests_button = gr.Button("Rerun Tests")
+
+                                with gr.Tab("Agent Chat"):
+                                    agent_chat = gr.Chatbot(
+                                        label="Agent Discussion",
+                                        height=400
+                                    )
+                                    chat_input = gr.Textbox(
+                                        label="Ask Agents",
+                                        placeholder="Type your question here..."
+                                    )
+                                    chat_button = gr.Button("Send")
+
+                    with gr.Row():
+                        status_output = gr.Markdown("System ready.")
+                        with gr.Column():
+                            progress = gr.Progress(
+                                label="Implementation Progress",
+                                show_progress=True
+                            )
+
+                # Explorer Tab
+                with gr.Tab("Code Explorer"):
+                    with gr.Row():
+                        with gr.Column(scale=1):
+                            component_list = gr.Dropdown(
+                                label="Components",
+                                choices=list(self.explorer.components.keys()),
+                                interactive=True
+                            )
+                            refresh_button = gr.Button("Refresh")
+
+                            with gr.Accordion("Add Component", open=False):
+                                component_name = gr.Textbox(label="Name")
+                                component_type = gr.Dropdown(
+                                    label="Type",
+                                    choices=['frontend', 'backend', 'database', 'api']
+                                )
+                                component_code = gr.Code(
+                                    label="Code",
+                                    language="python"
+                                )
+                                add_button = gr.Button("Add")
+
+                        with gr.Column(scale=2):
+                            component_details = gr.JSON(
+                                label="Component Details"
+                            )
+                            dependency_graph = gr.Plot(
+                                label="Dependencies"
+                            )
+
+            # Event Handlers
+            async def update_autonomy(level):
+                await self.agent_system.set_autonomy_level(level)
+                return f"Autonomy level set to {level}"
+
+            async def process_request(description, level):
+                try:
+                    # Update autonomy level
+                    await self.agent_system.set_autonomy_level(level)
+
+                    # Process request
+                    result = await self.agent_system.process_request(description)
+
+                    # Update UI based on result status
+                    if result['status'] == 'pending_confirmation':
+                        return {
+                            decision_log: result['decision'],
+                            frontend_code: "",
+                            backend_code: "",
+                            database_code: "",
+                            test_results: {},
+                            status_output: "Waiting for user confirmation...",
+                            progress: 0.3
+                        }
+                    elif result['status'] == 'completed':
+                        return {
+                            decision_log: result['decisions'],
+                            frontend_code: result['implementations'].get('frontend', ''),
+                            backend_code: result['implementations'].get('backend', ''),
+                            database_code: result['implementations'].get('database', ''),
+                            test_results: result['test_results'],
+                            status_output: "Implementation completed successfully!",
+                            progress: 1.0
+                        }
+                    else:
+                        return {
+                            status_output: f"Error: {result['message']}",
+                            progress: 0
+                        }
 
-            with gr.Row():
-                with gr.Column(scale=2):
-                    description_input = gr.Textbox(
-                        label="Description",
-                        placeholder="Enter a description for the code you want to generate",
-                        lines=3
-                    )
-                    template_choice = gr.Dropdown(
-                        label="Select Template",
-                        choices=list(self.template_manager.templates.keys()),
-                        value=None
-                    )
-
-            with gr.Row():
-                generate_button = gr.Button("Generate Code", variant="primary")
-                save_button = gr.Button("Save as Template", variant="secondary")
-                clear_button = gr.Button("Clear", variant="stop")
-
-            with gr.Row():
-                code_output = gr.Code(
-                    label="Generated Code",
-                    language="python",
-                    interactive=True
-                )
-
-            status_output = gr.Textbox(
-                label="Status",
-                interactive=False
-            )
+                except Exception as e:
+                    return {
+                        status_output: f"Error: {str(e)}",
+                        progress: 0
+                    }
 
-            def generate_code_wrapper(description: str, template_choice: str) -> Tuple[str, str]:
-                if not description.strip():
-                    return "", "Please provide a description"
-                
+            async def handle_chat(message, history):
                 try:
-                    template_code = self.template_manager.get_template(template_choice) if template_choice else ""
-                    generated_code = self.rag_system.generate_code(description, template_code)
-                    formatted_code = self.format_code(generated_code)
-                    
-                    if not formatted_code:
-                        return "", "Failed to generate code. Please try again."
-                        
-                    return formatted_code, "Code generated successfully."
-                    
+                    response = await self.agent_system.process_chat(message, history)
+                    history.append((message, response))
+                    return history
                 except Exception as e:
-                    logger.error(f"Error in code generation: {str(e)}")
-                    return "", f"Error: {str(e)}"
+                    logger.error(f"Chat error: {e}")
+                    return history + [(message, f"Error: {str(e)}")]
 
-            def save_template_wrapper(code: str, name: str, description: str) -> Tuple[str, str]:
+            async def refresh_components():
+                return gr.Dropdown(choices=list(self.explorer.components.keys()))
+
+            async def add_component(name, type, code):
                 try:
-                    if not name or not code:
-                        return code, "Template name and code are required."
-
-                    components = self._extract_components(code)
-                    template = Template(
-                        code=code,
-                        description=name,
-                        components=components,
-                        tags=[t.strip() for t in description.split(',') if t.strip()]
-                    )
-
-                    if self.template_manager.save_template(name, template):
-                        self.rag_system.add_to_database(code)
-                        template_choice.choices = list(self.template_manager.templates.keys())
-                        return code, f"Template '{name}' saved successfully."
-                    else:
-                        return code, "Failed to save template."
+                    success = await self.explorer.add_component(name, type, code)
+                    return {
+                        component_list: gr.Dropdown(choices=list(self.explorer.components.keys())),
+                        status_output: "Component added successfully" if success else "Failed to add component"
+                    }
+                except Exception as e:
+                    return {
+                        status_output: f"Error adding component: {str(e)}"
+                    }
+
+            async def show_component_details(name):
+                try:
+                    component = await self.explorer.get_component(name)
+                    if not component:
+                        return None, None
+
+                    graph = await self.explorer.visualize_dependencies(name)
+                    return component, graph
                 except Exception as e:
-                    return code, f"Error saving template: {e}"
-
-            def clear_outputs() -> Tuple[str, str, str]:
-                return "", "", ""
-
-            # Event handlers
-            generate_button.click(
-                fn=generate_code_wrapper,
-                inputs=[description_input, template_choice],
-                outputs=[code_output, status_output],
-                api_name="generate_code",
-                show_progress=True
+                    logger.error(f"Error showing component details: {e}")
+                    return None, None
+
+            # Connect event handlers
+            autonomy_slider.change(
+                fn=update_autonomy,
+                inputs=[autonomy_slider],
+                outputs=[status_output]
+            )
+
+            process_button.click(
+                fn=process_request,
+                inputs=[
+                    project_description,
+                    autonomy_slider,
+                ],
+                outputs=[
+                    decision_log,
+                    frontend_code,
+                    backend_code,
+                    database_code,
+                    test_results,
+                    status_output,
+                    progress
+                ]
+            )
+
+            chat_button.click(
+                fn=handle_chat,
+                inputs=[chat_input, agent_chat],
+                outputs=[agent_chat]
+            )
+
+            refresh_button.click(
+                fn=refresh_components,
+                outputs=[component_list]
             )
 
-            save_button.click(
-                fn=save_template_wrapper,
-                inputs=[code_output, template_choice, description_input],
-                outputs=[code_output, status_output]
+            add_button.click(
+                fn=add_component,
+                inputs=[component_name, component_type, component_code],
+                outputs=[component_list, status_output]
             )
 
-            clear_button.click(
-                fn=clear_outputs,
-                inputs=[],
-                outputs=[description_input, code_output, status_output]
+            component_list.change(
+                fn=show_component_details,
+                inputs=[component_list],
+                outputs=[component_details, dependency_graph]
             )
 
         # Launch the interface
@@ -316,19 +633,4 @@ class GradioInterface:
             server_port=self.config.port,
             share=self.config.share,
             debug=self.config.debug
-        )
-
-def main():
-    logger.info("=== Application Startup ===")
-    try:
-        config = Config.from_file(CONFIG_PATH)
-        interface = GradioInterface(config)
-        interface.launch()
-    except Exception as e:
-        logger.error(f"Application error: {e}")
-        raise
-    finally:
-        logger.info("=== Application Shutdown ===")
-
-if __name__ == "__main__":
-    main()
+        )