Update app.py

app.py

@@ -1,588 +1,1679 @@
-import streamlit as st
-from smolagents import CodeAgent, DuckDuckGoSearchTool, HfApiModel
-import inspect
-import datetime
-import traceback
-from abc import ABC, abstractmethod
+# Add these imports at the top of your file
+from typing import List, Dict, Optional, Any, Tuple
+from dataclasses import dataclass
+from enum import Enum
+import logging
+import time
+import ast
+import pylint.lint
+import radon.complexity
+import radon.metrics
+from pylint.lint import Run
+from pylint.reporters import JSONReporter
+from coverage import Coverage
+import bandit
+from bandit.core import manager
+from datetime import datetime
 import os
-from transformers import pipeline
-import subprocess
-import requests
-import json
+import sys
+import streamlit as st
+import asyncio
+from typing import Dict, Any
+from datetime import datetime
+from pathlib import Path
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.FileHandler('app.log'),
+        logging.StreamHandler(sys.stdout)
+    ]
+)
+
+logger = logging.getLogger(__name__)
+
+class CodeMetricsAnalyzer:
+    """Analyzes code metrics using various tools"""
+    
+    def __init__(self):
+        self.metrics_history = []
+        
+    def analyze_code_quality(self, file_path: str) -> Dict[str, Any]:
+        """Analyzes code quality using multiple metrics"""
+        try:
+            # Pylint analysis
+            pylint_score = self._run_pylint(file_path)
+            
+            # Complexity analysis
+            complexity_score = self._analyze_complexity(file_path)
+            
+            # Test coverage analysis
+            coverage_score = self._analyze_test_coverage(file_path)
+            
+            # Security analysis
+            security_score = self._analyze_security(file_path)
+            
+            # Calculate overall quality score
+            quality_score = self._calculate_overall_score(
+                pylint_score,
+                complexity_score,
+                coverage_score,
+                security_score
+            )
+            
+            metrics = {
+                "quality_score": quality_score,
+                "pylint_score": pylint_score,
+                "complexity_score": complexity_score,
+                "coverage_score": coverage_score,
+                "security_score": security_score,
+                "timestamp": datetime.now()
+            }
+            
+            self.metrics_history.append(metrics)
+            return metrics
+            
+        except Exception as e:
+            logging.error(f"Error analyzing code metrics: {str(e)}")
+            return {
+                "error": str(e),
+                "quality_score": 0.0,
+                "timestamp": datetime.now()
+            }
 
-# --- Error Handling and Logging ---
+    def _run_pylint(self, file_path: str) -> float:
+        """Runs pylint analysis"""
+        try:
+            reporter = JSONReporter()
+            Run([file_path], reporter=reporter, do_exit=False)
+            score = reporter.data.get('score', 0.0)
+            return float(score) / 10.0  # Normalize to 0-1 scale
+        except Exception as e:
+            logging.error(f"Pylint analysis error: {str(e)}")
+            return 0.0
 
-class AgentException(Exception):
-    """Custom exception for agent-related errors."""
-    pass
+    def _analyze_complexity(self, file_path: str) -> float:
+        """Analyzes code complexity"""
+        try:
+            with open(file_path, 'r') as file:
+                code = file.read()
+            
+            # Calculate cyclomatic complexity
+            complexity = radon.complexity.cc_visit(code)
+            avg_complexity = sum(item.complexity for item in complexity) / len(complexity) if complexity else 0
+            
+            # Normalize complexity score (0-1 scale, lower is better)
+            normalized_score = 1.0 - min(avg_complexity / 10.0, 1.0)
+            return normalized_score
+            
+        except Exception as e:
+            logging.error(f"Complexity analysis error: {str(e)}")
+            return 0.0
 
-def handle_agent_errors(func):
-    """Decorator to catch and display agent errors gracefully."""
-    def wrapper(*args, **kwargs):
+    def _analyze_test_coverage(self, file_path: str) -> float:
+        """Analyzes test coverage"""
         try:
-            return func(*args, **kwargs)
-        except AgentException as e:
-            st.error(f"Agent Error: {e}")
-            st.code(traceback.format_exc(), language="text")
+            cov = Coverage()
+            cov.start()
+            
+            # Execute the file to measure coverage
+            with open(file_path) as f:
+                exec(compile(f.read(), file_path, 'exec'))
+            
+            cov.stop()
+            cov.save()
+            
+            # Get coverage data
+            total_lines = 0
+            covered_lines = 0
+            
+            for filename in cov.data.measured_files():
+                _, executable, _, missing, _ = cov.analysis(filename)
+                total_lines += len(executable)
+                covered_lines += len(executable) - len(missing)
+            
+            coverage_ratio = covered_lines / total_lines if total_lines > 0 else 0
+            return coverage_ratio
+            
         except Exception as e:
-            st.error(f"An unexpected error occurred: {e}")
-            st.code(traceback.format_exc(), language="text")
-    return wrapper
-    
-# --- Abstract Base Classes ---
-class BaseTool(ABC):
-    @abstractmethod
-    def use(self, input_str: str) -> str:
-        """How the tool is used."""
-        pass
+            logging.error(f"Coverage analysis error: {str(e)}")
+            return 0.0
 
+    def _analyze_security(self, file_path: str) -> float:
+        """Analyzes code security using bandit"""
+        try:
+            conf = manager.BanditManager()
+            conf.discover_files([file_path])
+            conf.run_tests()
+            
+            # Calculate security score based on findings
+            total_issues = len(conf.get_issue_list())
+            max_severity = max((issue.severity for issue in conf.get_issue_list()), default=0)
+            
+            # Normalize security score (0-1 scale, higher is better)
+            security_score = 1.0 - (total_issues * max_severity) / 10.0
+            return max(0.0, min(1.0, security_score))
+            
+        except Exception as e:
+            logging.error(f"Security analysis error: {str(e)}")
+            return 0.0
+
+    def _calculate_overall_score(self, pylint_score: float, complexity_score: float, 
+                               coverage_score: float, security_score: float) -> float:
+        """Calculates overall code quality score"""
+        weights = {
+            'pylint': 0.3,
+            'complexity': 0.2,
+            'coverage': 0.25,
+            'security': 0.25
+        }
+        
+        overall_score = (
+            weights['pylint'] * pylint_score +
+            weights['complexity'] * complexity_score +
+            weights['coverage'] * coverage_score +
+            weights['security'] * security_score
+        )
+        
+        return max(0.0, min(1.0, overall_score))
 
-class BaseModel(ABC):
-    @abstractmethod
-    def generate(self, prompt: str) -> str:
-        """How the model generates output."""
-        pass
+    def get_metrics_history(self) -> List[Dict[str, Any]]:
+        """Returns the history of metrics measurements"""
+        return self.metrics_history
 
-# --- Concrete Tool Implementations ---
+    def get_trend_analysis(self) -> Dict[str, Any]:
+        """Analyzes trends in metrics over time"""
+        if not self.metrics_history:
+            return {"status": "No metrics history available"}
+            
+        trends = {
+            "quality_score": self._calculate_trend([m["quality_score"] for m in self.metrics_history]),
+            "coverage_score": self._calculate_trend([m["coverage_score"] for m in self.metrics_history]),
+            "security_score": self._calculate_trend([m["security_score"] for m in self.metrics_history])
+        }
+        
+        return trends
 
-class WorkspaceEmulatorTool(BaseTool):
-    """Simulates a development workspace."""
+    def _calculate_trend(self, values: List[float]) -> Dict[str, Any]:
+        """Calculates trend statistics for a metric"""
+        if not values:
+            return {"trend": "unknown", "change": 0.0}
+            
+        recent_values = values[-3:]  # Look at last 3 measurements
+        if len(recent_values) < 2:
+            return {"trend": "insufficient data", "change": 0.0}
+            
+        change = recent_values[-1] - recent_values[0]
+        trend = "improving" if change > 0 else "declining" if change < 0 else "stable"
+        
+        return {
+            "trend": trend,
+            "change": change,
+            "current": recent_values[-1],
+            "previous": recent_values[0]
+        }
+
+@dataclass
+class QualityMetrics:
+    """Advanced quality metrics tracking and analysis"""
+    code_quality_score: float = 0.0
+    test_coverage: float = 0.0
+    security_score: str = "unknown"
+    performance_score: float = 0.0
+    metrics_analyzer: CodeMetricsAnalyzer = None
     
-    def __init__(self):
-        self.name = "WorkspaceEmulatorTool"
+    def __post_init__(self):
+        self.metrics_analyzer = CodeMetricsAnalyzer()
+        self.history = []
+        self.thresholds = {
+            "code_quality": 0.85,
+            "test_coverage": 0.90,
+            "security": 0.85,
+            "performance": 0.80
+        }
     
-    def use(self, input_str: str) -> str:
+    def analyze_code(self, project_name: str) -> Dict[str, Any]:
+        """Comprehensive code analysis"""
         try:
-            # Parse the input to create directories and files
-            commands = input_str.split(';')
-            for cmd in commands:
-                cmd = cmd.strip()
-                if cmd.startswith('mkdir '):
-                    dir_name = cmd[len('mkdir '):]
-                    os.makedirs(dir_name, exist_ok=True)
-                    print(f"Directory '{dir_name}' created.")
-                elif cmd.startswith('touch '):
-                    file_name = cmd[len('touch '):]
-                    open(file_name, 'a').close()
-                    print(f"File '{file_name}' created.")
-                else:
-                    print(f"Unknown command: {cmd}")
-            return "Workspace emulated successfully."
+            # Get all Python files in the project
+            project_files = self._get_project_files(project_name)
+            
+            aggregated_metrics = {
+                "code_quality": 0.0,
+                "test_coverage": 0.0,
+                "security": 0.0,
+                "performance": 0.0,
+                "files_analyzed": len(project_files),
+                "detailed_metrics": []
+            }
+            
+            for file_path in project_files:
+                metrics = self.metrics_analyzer.analyze_code_quality(file_path)
+                aggregated_metrics["detailed_metrics"].append({
+                    "file": file_path,
+                    "metrics": metrics
+                })
+                
+                # Update aggregated scores
+                aggregated_metrics["code_quality"] += metrics["quality_score"]
+                aggregated_metrics["test_coverage"] += metrics["coverage_score"]
+                aggregated_metrics["security"] += metrics["security_score"]
+                
+            # Calculate averages
+            if project_files:
+                for key in ["code_quality", "test_coverage", "security"]:
+                    aggregated_metrics[key] /= len(project_files)
+            
+            # Update instance variables
+            self.code_quality_score = aggregated_metrics["code_quality"]
+            self.test_coverage = aggregated_metrics["test_coverage"]
+            self.security_score = str(aggregated_metrics["security"])
+            
+            # Add to history
+            self.history.append({
+                "timestamp": datetime.now(),
+                "metrics": aggregated_metrics
+            })
+            
+            return aggregated_metrics
+            
         except Exception as e:
-            return f"Error emulating workspace: {str(e)}"
+            logging.error(f"Error in code analysis: {str(e)}")
+            return {
+                "error": str(e),
+                "code_quality": 0.0,
+                "test_coverage": 0.0,
+                "security": "error",
+                "performance": 0.0
+            }
 
-class DeploymentSimulatorTool(BaseTool):
-    """Simulates deployment processes."""
-    
+    def _get_project_files(self, project_name: str) -> List[str]:
+        """Get all Python files in the project"""
+        project_dir = os.path.join(os.getcwd(), project_name)
+        python_files = []
+        
+        for root, _, files in os.walk(project_dir):
+            for file in files:
+                if file.endswith('.py'):
+                    python_files.append(os.path.join(root, file))
+        
+        return python_files
+
+    def get_improvement_suggestions(self) -> List[str]:
+        """Generate improvement suggestions based on metrics"""
+        suggestions = []
+        latest_metrics = self.history[-1]["metrics"] if self.history else None
+        
+        if not latest_metrics:
+            return ["No metrics available for analysis"]
+        
+        if latest_metrics["code_quality"] < self.thresholds["code_quality"]:
+            suggestions.append(
+                f"Code quality score ({latest_metrics['code_quality']:.2f}) is below threshold "
+                f"({self.thresholds['code_quality']}). Consider refactoring complex methods."
+            )
+        
+        if latest_metrics["test_coverage"] < self.thresholds["test_coverage"]:
+            suggestions.append(
+                f"Test coverage ({latest_metrics['test_coverage']:.2f}) is below threshold "
+                f"({self.thresholds['test_coverage']}). Add more unit tests."
+            )
+        
+        if float(latest_metrics["security"]) < self.thresholds["security"]:
+            suggestions.append(
+                f"Security score ({latest_metrics['security']}) is below threshold "
+                f"({self.thresholds['security']}). Address security vulnerabilities."
+            )
+        
+        return suggestions
+
+class ErrorTracker:
+    """Enhanced error tracking and analysis"""
     def __init__(self):
-        self.name = "DeploymentSimulatorTool"
+        self.errors: List[Dict[str, Any]] = []
+        self.error_patterns: Dict[str, int] = {}
+        self.critical_errors: List[Dict[str, Any]] = []
+    
+    def add_error(self, error_type: str, message: str, severity: str = "normal"):
+        """Add an error with enhanced tracking"""
+        error_entry = {
+            "type": error_type,
+            "message": message,
+            "severity": severity,
+            "timestamp": datetime.now(),
+            "stack_trace": traceback.format_exc()
+        }
+        
+        self.errors.append(error_entry)
+        
+        # Track error patterns
+        if error_type in self.error_patterns:
+            self.error_patterns[error_type] += 1
+        else:
+            self.error_patterns[error_type] = 1
+        
+        # Track critical errors
+        if severity == "critical":
+            self.critical_errors.append(error_entry)
+            self._notify_critical_error(error_entry)
+    
+    def _notify_critical_error(self, error: Dict[str, Any]):
+        """Handle critical error notification"""
+        logging.critical(f"Critical error detected: {error['message']}")
+        # Implement notification system here (e.g., email, Slack)
+    
+    def get_error_analysis(self) -> Dict[str, Any]:
+        """Generate comprehensive error analysis"""
+        return {
+            "total_errors": len(self.errors),
+            "error_patterns": self.error_patterns,
+            "critical_errors": len(self.critical_errors),
+            "most_common_error": max(self.error_patterns.items(), key=lambda x: x[1]) if self.error_patterns else None,
+            "error_trend": self._analyze_error_trend()
+        }
+    
+    def _analyze_error_trend(self) -> Dict[str, Any]:
+        """Analyze error trends over time"""
+        if not self.errors:
+            return {"trend": "no errors"}
+        
+        # Group errors by hour
+        error_timeline = {}
+        for error in self.errors:
+            hour = error["timestamp"].replace(minute=0, second=0, microsecond=0)
+            if hour in error_timeline:
+                error_timeline[hour] += 1
+            else:
+                error_timeline[hour] = 1
+        
+        # Calculate trend
+        timeline_values = list(error_timeline.values())
+        if len(timeline_values) < 2:
+            return {"trend": "insufficient data"}
+        
+        trend = "increasing" if timeline_values[-1] > timeline_values[0] else "decreasing"
+        return {
+            "trend": trend,
+            "current_rate": timeline_values[-1],
+            "initial_rate": timeline_values[0]
+        }
+
+class ProjectAnalytics:
+    """Enhanced project analytics and reporting"""
+    def __init__(self, workspace_manager):
+        self.workspace_manager = workspace_manager
+        self.metrics_analyzer = CodeMetricsAnalyzer()
+        self.analysis_history = []
     
-    def use(self, input_str: str) -> str:
+    def generate_project_report(self, project_name: str) -> Dict[str, Any]:
+        """Generate comprehensive project report"""
         try:
-            # Simulate deployment steps
-            steps = input_str.split(';')
-            for step in steps:
-                step = step.strip()
-                if step == 'build':
-                    print("Building the application...")
-                elif step == 'test':
-                    print("Running tests...")
-                elif step == 'deploy':
-                    print("Deploying to the server...")
-                else:
-                    print(f"Unknown step: {step}")
-            return "Deployment simulated successfully."
+            current_analysis = {
+                "timestamp": datetime.now(),
+                "basic_metrics": self._get_basic_metrics(project_name),
+                "code_quality": self._get_code_quality_metrics(project_name),
+                "performance": self._get_performance_metrics(project_name),
+                "security": self._get_security_metrics(project_name),
+                "dependencies": self._analyze_dependencies(project_name)
+            }
+            
+            self.analysis_history.append(current_analysis)
+            
+            return {
+                "current_analysis": current_analysis,
+                "historical_trends": self._analyze_trends(),
+                "recommendations": self._generate_recommendations(current_analysis)
+            }
+        
         except Exception as e:
-            return f"Error simulating deployment: {str(e)}"
+            logging.error(f"Error generating project report: {str(e)}")
+            return {"error": str(e)}
 
-class ErrorSpottingTool(BaseTool):
-    """Spots and corrects errors in code."""
-    
-    def __init__(self):
-        self.name = "ErrorSpottingTool"
+class DevelopmentPipeline:
+    """Advanced development pipeline with stage management and monitoring"""
     
-    def use(self, input_str: str) -> str:
+    class PipelineStage(Enum):
+        PLANNING = "planning"
+        DEVELOPMENT = "development"
+        TESTING = "testing"
+        DEPLOYMENT = "deployment"
+        MAINTENANCE = "maintenance"
+        ROLLBACK = "rollback"
+
+    def __init__(self, workspace_manager, tool_manager):
+        self.workspace_manager = workspace_manager
+        self.tool_manager = tool_manager
+        self.current_stage = None
+        self.stage_history = []
+        self.active_processes = {}
+        self.stage_metrics = {}
+        self.logger = self._setup_logger()
+        
+    def _setup_logger(self) -> logging.Logger:
+        logger = logging.getLogger("DevelopmentPipeline")
+        logger.setLevel(logging.DEBUG)
+        handler = logging.StreamHandler()
+        formatter = logging.Formatter(
+            '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+        )
+        handler.setFormatter(formatter)
+        logger.addHandler(handler)
+        return logger
+
+    async def execute_stage(self, stage: PipelineStage, context: Dict[str, Any]) -> Dict[str, Any]:
+        """Execute a pipeline stage with monitoring and error handling"""
+        self.logger.info(f"Starting stage: {stage.value}")
+        start_time = time.time()
+        
         try:
-            # Write the code to a temporary file
-            with open('temp_code.py', 'w') as f:
-                f.write(input_str)
+            # Record stage start
+            self.current_stage = stage
+            self._record_stage_start(stage, context)
+            
+            # Execute stage-specific logic
+            result = await self._execute_stage_logic(stage, context)
+            
+            # Validate stage output
+            self._validate_stage_output(stage, result)
             
-            # Run pylint to check for errors
-            pylint_output = subprocess.check_output(['pylint', 'temp_code.py'], text=True)
-            os.remove('temp_code.py')
+            # Update metrics
+            execution_time = time.time() - start_time
+            self._update_stage_metrics(stage, execution_time, result)
+            
+            # Record stage completion
+            self._record_stage_completion(stage, result)
+            
+            return {
+                "status": "success",
+                "stage": stage.value,
+                "result": result,
+                "execution_time": execution_time,
+                "metrics": self.stage_metrics.get(stage, {})
+            }
             
-            # Return the pylint output
-            return pylint_output
         except Exception as e:
-            return f"Error spotting and correcting code: {str(e)}"
+            error_msg = f"Error in stage {stage.value}: {str(e)}"
+            self.logger.error(error_msg)
+            
+            # Handle stage failure
+            await self._handle_stage_failure(stage, context, e)
+            
+            return {
+                "status": "error",
+                "stage": stage.value,
+                "error": error_msg,
+                "execution_time": time.time() - start_time
+            }
 
-class GitHubRepoSpongeTool(BaseTool):
-    """Fetches and analyzes GitHub repositories."""
-    
-    def __init__(self):
-        self.name = "GitHubRepoSpongeTool"
-    
-    def use(self, input_str: str) -> str:
+    async def _execute_stage_logic(self, stage: PipelineStage, context: Dict[str, Any]) -> Dict[str, Any]:
+        """Execute stage-specific logic with appropriate tools"""
+        if stage == self.PipelineStage.PLANNING:
+            return await self._execute_planning_stage(context)
+        elif stage == self.PipelineStage.DEVELOPMENT:
+            return await self._execute_development_stage(context)
+        elif stage == self.PipelineStage.TESTING:
+            return await self._execute_testing_stage(context)
+        elif stage == self.PipelineStage.DEPLOYMENT:
+            return await self._execute_deployment_stage(context)
+        elif stage == self.PipelineStage.MAINTENANCE:
+            return await self._execute_maintenance_stage(context)
+        elif stage == self.PipelineStage.ROLLBACK:
+            return await self._execute_rollback_stage(context)
+        else:
+            raise ValueError(f"Unknown pipeline stage: {stage}")
+
+    async def _execute_planning_stage(self, context: Dict[str, Any]) -> Dict[str, Any]:
+        """Execute planning stage with requirement analysis and task breakdown"""
         try:
-            # Assume input_str is the GitHub repository in the form 'owner/repo'
-            owner, repo = input_str.split('/')
-            url = f'https://api.github.com/repos/{owner}/{repo}'
-            response = requests.get(url)
-            if response.status_code == 200:
-                repo_data = response.json()
-                return f"Repository data fetched: {repo_data}"
-            else:
-                return f"Failed to fetch repository: {response.status_code}"
+            # Analyze requirements
+            requirements = await self.tool_manager.execute_tool(
+                "requirements_analyzer",
+                context.get("requirements", "")
+            )
+            
+            # Generate task breakdown
+            tasks = await self.tool_manager.execute_tool(
+                "task_breakdown",
+                requirements["result"]
+            )
+            
+            # Create project structure
+            project_structure = await self.workspace_manager.create_project_structure(
+                context["project_name"],
+                tasks["result"]
+            )
+            
+            return {
+                "requirements": requirements["result"],
+                "tasks": tasks["result"],
+                "project_structure": project_structure
+            }
         except Exception as e:
-            return f"Error fetching GitHub repository: {str(e)}"
+            raise Exception(f"Planning stage failed: {str(e)}")
 
+    async def _execute_development_stage(self, context: Dict[str, Any]) -> Dict[str, Any]:
+        """Execute development stage with code generation and quality checks"""
+        try:
+            # Generate code
+            code_generation = await self.tool_manager.execute_tool(
+                "code_generator",
+                context.get("tasks", [])
+            )
+            
+            # Run initial quality checks
+            quality_check = await self.tool_manager.execute_tool(
+                "code_quality_checker",
+                code_generation["result"]
+            )
+            
+            # Save generated code
+            saved_files = await self.workspace_manager.save_generated_code(
+                context["project_name"],
+                code_generation["result"]
+            )
+            
+            return {
+                "generated_code": code_generation["result"],
+                "quality_check": quality_check["result"],
+                "saved_files": saved_files
+            }
+        except Exception as e:
+            raise Exception(f"Development stage failed: {str(e)}")
+
+    async def _execute_testing_stage(self, context: Dict[str, Any]) -> Dict[str, Any]:
+        """Execute testing stage with comprehensive test suite"""
+        try:
+            # Generate tests
+            test_generation = await self.tool_manager.execute_tool(
+                "test_generator",
+                context.get("generated_code", "")
+            )
+            
+            # Run tests
+            test_results = await self.tool_manager.execute_tool(
+                "test_runner",
+                test_generation["result"]
+            )
+            
+            # Generate coverage report
+            coverage_report = await self.tool_manager.execute_tool(
+                "coverage_analyzer",
+                test_results["result"]
+            )
+            
+            return {
+                "test_cases": test_generation["result"],
+                "test_results": test_results["result"],
+                "coverage_report": coverage_report["result"]
+            }
+        except Exception as e:
+            raise Exception(f"Testing stage failed: {str(e)}")
+
+    def _validate_stage_output(self, stage: PipelineStage, result: Dict[str, Any]):
+        """Validate stage output against defined criteria"""
+        validation_rules = self._get_validation_rules(stage)
+        validation_errors = []
         
-class MyDuckDuckGoSearchTool(BaseTool, DuckDuckGoSearchTool):
-    """Performs a DuckDuckGo search and returns the results."""
-    
-    def __init__(self):
-        self.name = "MyDuckDuckGoSearchTool"
-    
-    def use(self, input_str: str) -> str:
-        results = self.search(input_str, max_results=5)
-        result_str = ""
-        for idx, result in enumerate(results, 1):
-            result_str += f"\n{idx}. {result.title} - {result.url}\n{result.text}\n"
-        return result_str
-
-class MyHfApiModel(BaseModel, HfApiModel):
-    """Generates text using the Hugging Face API."""
-    
-    def __init__(self, api_token=None):
-        if api_token is None:
-            api_token = os.getenv("HUGGINGFACE_API_TOKEN")
-        super().__init__()
-        self.api_token = api_token
-        self.generator = pipeline("text-generation", model="gpt2", tokenizer="gpt2")
-    
-    def generate(self, prompt: str) -> str:
-        response = self.generator(
-            prompt,
-            max_new_tokens=100,
-            num_return_sequences=1
+        for rule in validation_rules:
+            if not rule.validate(result):
+                validation_errors.append(rule.get_error_message())
+        
+        if validation_errors:
+            raise ValueError(f"Stage validation failed: {'; '.join(validation_errors)}")
+
+    def _update_stage_metrics(self, stage: PipelineStage, execution_time: float, result: Dict[str, Any]):
+        """Update metrics for the stage"""
+        if stage not in self.stage_metrics:
+            self.stage_metrics[stage] = {
+                "total_executions": 0,
+                "successful_executions": 0,
+                "failed_executions": 0,
+                "average_execution_time": 0,
+                "last_execution_time": None,
+                "error_rate": 0
+            }
+        
+        metrics = self.stage_metrics[stage]
+        metrics["total_executions"] += 1
+        metrics["last_execution_time"] = execution_time
+        
+        if result.get("status") == "success":
+            metrics["successful_executions"] += 1
+        else:
+            metrics["failed_executions"] += 1
+        
+        metrics["error_rate"] = metrics["failed_executions"] / metrics["total_executions"]
+        metrics["average_execution_time"] = (
+            (metrics["average_execution_time"] * (metrics["total_executions"] - 1) + execution_time)
+            / metrics["total_executions"]
         )
-        return response[0]["generated_text"]
 
-# --- New Tools ---
+    async def _handle_stage_failure(self, stage: PipelineStage, context: Dict[str, Any], error: Exception):
+        """Handle stage failure with rollback and recovery options"""
+        self.logger.error(f"Handling failure in stage {stage.value}: {str(error)}")
+        
+        # Record failure
+        self._record_stage_failure(stage, error)
+        
+        # Determine if rollback is needed
+        if self._should_rollback(stage, error):
+            await self._execute_rollback(stage, context)
+        
+        # Attempt recovery
+        await self._attempt_recovery(stage, context, error)
+
+    def _should_rollback(self, stage: PipelineStage, error: Exception) -> bool:
+        """Determine if a rollback is needed based on error severity"""
+        critical_errors = [
+            "DatabaseError",
+            "DeploymentError",
+            "SecurityViolation"
+        ]
+        return any(err in str(error) for err in critical_errors)
+
+    async def _execute_rollback(self, stage: PipelineStage, context: Dict[str, Any]):
+        """Execute rollback procedure for a failed stage"""
+        self.logger.info(f"Executing rollback for stage {stage.value}")
+        
+        try:
+            # Get rollback point
+            rollback_point = self._get_rollback_point(stage)
+            
+            # Execute rollback
+            await self.execute_stage(
+                self.PipelineStage.ROLLBACK,
+                {
+                    **context,
+                    "rollback_point": rollback_point,
+                    "failed_stage": stage
+                }
+            )
+            
+        except Exception as e:
+            self.logger.error(f"Rollback failed: {str(e)}")
+            # Implement emergency shutdown if rollback fails
+            self._emergency_shutdown(stage, e)
+
+    def _emergency_shutdown(self, stage: PipelineStage, error: Exception):
+        """Handle emergency shutdown when rollback fails"""
+        self.logger.critical(f"Emergency shutdown initiated for stage {stage.value}")
+        # Implement emergency shutdown procedures
+        pass
 
-class CodeInterpreterTool(BaseTool):
-    """Interprets and executes Python code."""
+class RefinementLoop:
+    """Enhanced refinement loop for code quality assurance and continuous improvement"""
     
-    def __init__(self):
-        self.name = "CodeInterpreterTool"
-    
-    def use(self, input_str: str) -> str:
+    class RefinementState(Enum):
+        INITIALIZING = "initializing"
+        ANALYZING = "analyzing"
+        REFINING = "refining"
+        VALIDATING = "validating"
+        COMPLETED = "completed"
+        FAILED = "failed"
+
+    def __init__(self, pipeline: DevelopmentPipeline, max_iterations: int = 5):
+        self.pipeline = pipeline
+        self.max_iterations = max_iterations
+        self.current_iteration = 0
+        self.refinement_history: List[Dict[str, Any]] = []
+        self.quality_metrics = QualityMetrics()
+        self.error_tracker = ErrorTracker()
+        self.improvement_suggestions: List[str] = []
+        self.state = self.RefinementState.INITIALIZING
+        self.logger = self._setup_logger()
+        self.performance_monitor = self._setup_performance_monitor()
+        self.refinement_strategies = self._initialize_refinement_strategies()
+
+    def _setup_logger(self) -> logging.Logger:
+        """Set up enhanced logging with detailed formatting"""
+        logger = logging.getLogger("RefinementLoop")
+        logger.setLevel(logging.DEBUG)
+        
+        # File handler for persistent logging
+        file_handler = logging.FileHandler("refinement_loop.log")
+        file_handler.setLevel(logging.DEBUG)
+        
+        # Console handler for immediate feedback
+        console_handler = logging.StreamHandler()
+        console_handler.setLevel(logging.INFO)
+        
+        # Create formatters and add them to the handlers
+        detailed_formatter = logging.Formatter(
+            '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+        )
+        simple_formatter = logging.Formatter(
+            '%(levelname)s: %(message)s'
+        )
+        
+        file_handler.setFormatter(detailed_formatter)
+        console_handler.setFormatter(simple_formatter)
+        
+        # Add handlers to logger
+        logger.addHandler(file_handler)
+        logger.addHandler(console_handler)
+        
+        return logger
+
+    def _setup_performance_monitor(self):
+        """Initialize performance monitoring"""
+        return {
+            "start_time": None,
+            "end_time": None,
+            "iterations": [],
+            "memory_usage": [],
+            "cpu_usage": []
+        }
+
+    def _initialize_refinement_strategies(self) -> Dict[str, Any]:
+        """Initialize available refinement strategies"""
+        return {
+            "code_optimization": self._optimize_code,
+            "test_enhancement": self._enhance_tests,
+            "security_hardening": self._harden_security,
+            "performance_tuning": self._tune_performance,
+            "documentation_improvement": self._improve_documentation
+        }
+
+    async def run_refinement_cycle(self, project_name: str) -> Dict[str, Any]:
+        """Execute refinement cycle with enhanced error handling and monitoring"""
+        self.logger.info(f"Starting refinement cycle for project: {project_name}")
+        self.state = self.RefinementState.INITIALIZING
+        self.performance_monitor["start_time"] = time.time()
+        
+        try:
+            while self.current_iteration < self.max_iterations:
+                self.logger.debug(f"Starting iteration {self.current_iteration + 1}")
+                iteration_start_time = time.time()
+                
+                # Update state and analyze current state
+                self.state = self.RefinementState.ANALYZING
+                analysis = await self._analyze_current_state(project_name)
+                
+                if analysis["meets_requirements"]:
+                    self.logger.info("Quality requirements met")
+                    break
+                
+                # Apply refinements
+                self.state = self.RefinementState.REFINING
+                refinement_result = await self._apply_refinements(project_name, analysis)
+                self.refinement_history.append(refinement_result)
+                
+                # Validate changes
+                self.state = self.RefinementState.VALIDATING
+                validation_result = await self._validate_changes(project_name)
+                
+                if not validation_result["success"]:
+                    self.logger.warning("Validation failed, initiating rollback")
+                    await self._rollback_changes(project_name)
+                    continue
+                
+                # Update metrics and record performance
+                await self._update_metrics(validation_result)
+                self._record_iteration_performance(iteration_start_time)
+                
+                self.current_iteration += 1
+                
+                if await self._check_optimal_state():
+                    self.logger.info("Optimal state reached")
+                    break
+                
+                # Prevent resource exhaustion
+                await asyncio.sleep(1)
+            
+            self.state = self.RefinementState.COMPLETED
+            return await self._generate_final_report()
+            
+        except Exception as e:
+            self.state = self.RefinementState.FAILED
+            self.logger.error(f"Error in refinement cycle: {str(e)}")
+            self.error_tracker.add_error("refinement_cycle", str(e))
+            return {
+                "success": False,
+                "error": str(e),
+                "error_details": traceback.format_exc()
+            }
+        finally:
+            self.performance_monitor["end_time"] = time.time()
+
+    async def _analyze_current_state(self, project_name: str) -> Dict[str, Any]:
+        """Analyze current project state with detailed metrics"""
         try:
-            result = subprocess.run(
-                ["python", "-c", input_str],
-                capture_output=True,
-                text=True
+            # Collect code metrics
+            code_metrics = await self._collect_code_metrics(project_name)
+            
+            # Analyze test coverage
+            test_coverage = await self._analyze_test_coverage(project_name)
+            
+            # Check security vulnerabilities
+            security_analysis = await self._analyze_security(project_name)
+            
+            # Measure performance metrics
+            performance_metrics = await self._measure_performance(project_name)
+            
+            # Determine if requirements are met
+            meets_requirements = await self._check_requirements(
+                code_metrics,
+                test_coverage,
+                security_analysis,
+                performance_metrics
             )
-            if result.returncode == 0:
-                return result.stdout
-            else:
-                return f"Error: {result.stderr}"
+            
+            return {
+                "code_metrics": code_metrics,
+                "test_coverage": test_coverage,
+                "security_analysis": security_analysis,
+                "performance_metrics": performance_metrics,
+                "meets_requirements": meets_requirements,
+                "timestamp": datetime.now()
+            }
+            
         except Exception as e:
-            return f"Execution failed: {str(e)}"
+            self.logger.error(f"Error analyzing current state: {str(e)}")
+            raise
 
-class WorkspaceEmulatorTool(BaseTool):
-    """Simulates a development workspace."""
-    
-    def __init__(self):
-        self.name = "WorkspaceEmulatorTool"
-    
-    def use(self, input_str: str) -> str:
-        return f"Workspace emulated for: {input_str}"
+    async def _apply_refinements(self, project_name: str, analysis: Dict[str, Any]) -> Dict[str, Any]:
+        """Apply necessary refinements based on analysis"""
+        try:
+            refinements_applied = []
+            
+            # Determine needed refinements
+            needed_refinements = await self._determine_needed_refinements(analysis)
+            
+            # Apply each refinement strategy
+            for refinement_type, refinement_data in needed_refinements.items():
+                if refinement_type in self.refinement_strategies:
+                    refinement_result = await self.refinement_strategies[refinement_type](
+                        project_name,
+                        refinement_data
+                    )
+                    refinements_applied.append(refinement_result)
+            
+            return {
+                "refinements_applied": refinements_applied,
+                "timestamp": datetime.now()
+            }
+            
+        except Exception as e:
+            self.logger.error(f"Error applying refinements: {str(e)}")
+            raise
 
-class DeploymentSimulatorTool(BaseTool):
-    """Simulates deployment processes."""
-    
-    def __init__(self):
-        self.name = "DeploymentSimulatorTool"
-    
-    def use(self, input_str: str) -> str:
-        return f"Deployment simulated for: {input_str}"
+    async def _validate_changes(self, project_name: str) -> Dict[str, Any]:
+        """Validate applied changes with comprehensive testing"""
+        try:
+            # Run test suite
+            test_results = await self._run_test_suite(project_name)
+            
+            # Validate code quality
+            quality_validation = await self._validate_code_quality(project_name)
+            
+            # Check for regressions
+            regression_check = await self._check_for_regressions(project_name)
+            
+            # Verify performance impact
+            performance_impact = await self._verify_performance_impact(project_name)
+            
+            validation_success = all([
+                test_results["success"],
+                quality_validation["success"],
+                not regression_check["regressions_found"],
+                performance_impact["acceptable"]
+            ])
+            
+            return {
+                "success": validation_success,
+                "test_results": test_results,
+                "quality_validation": quality_validation,
+                "regression_check": regression_check,
+                "performance_impact": performance_impact,
+                "timestamp": datetime.now()
+            }
+            
+        except Exception as e:
+            self.logger.error(f"Error validating changes: {str(e)}")
+            raise
 
-class ErrorSpottingTool(BaseTool):
-    """Spots and corrects errors in code."""
-    
-    def __init__(self):
-        self.name = "ErrorSpottingTool"
-    
-    def use(self, input_str: str) -> str:
-        return f"Errors spotted and corrected in: {input_str}"
+        async def _optimize_code(self, project_name: str, optimization_data: Dict[str, Any]) -> Dict[str, Any]:
+        """Optimize code based on analysis results"""
+        try:
+            self.logger.info(f"Starting code optimization for {project_name}")
+            optimizations_applied = []
+            
+            # Apply code optimizations
+            for file_path, file_data in optimization_data.items():
+                # Complexity reduction
+                if file_data.get("complexity_score", 0) > 0.7:
+                    complexity_result = await self._reduce_complexity(file_path)
+                    optimizations_applied.append({"type": "complexity", "result": complexity_result})
+                
+                # Performance optimization
+                if file_data.get("performance_score", 0) < 0.8:
+                    performance_result = await self._optimize_performance(file_path)
+                    optimizations_applied.append({"type": "performance", "result": performance_result})
+                
+                # Memory optimization
+                if file_data.get("memory_score", 0) < 0.8:
+                    memory_result = await self._optimize_memory(file_path)
+                    optimizations_applied.append({"type": "memory", "result": memory_result})
+            
+            return {
+                "status": "success",
+                "optimizations_applied": optimizations_applied,
+                "timestamp": datetime.now()
+            }
+            
+        except Exception as e:
+            self.logger.error(f"Error in code optimization: {str(e)}")
+            raise
 
-class GitHubRepoSpongeTool(BaseTool):
-    """Fetches and analyzes GitHub repositories."""
-    
-    def __init__(self):
-        self.name = "GitHubRepoSpongeTool"
-    
-    def use(self, input_str: str) -> str:
-        repo_url = input_str.strip()
-        repo_name = repo_url.split("/")[-1]
-        api_url = f"https://api.github.com/repos/{repo_name}"
-        response = requests.get(api_url)
-        if response.status_code == 200:
-            repo_data = response.json()
-            return f"Repository data: {json.dumps(repo_data, indent=2)}"
-        else:
-            return f"Failed to fetch repository: {response.status_code}"
+    async def _enhance_tests(self, project_name: str, test_data: Dict[str, Any]) -> Dict[str, Any]:
+        """Enhance test coverage and quality"""
+        try:
+            self.logger.info(f"Starting test enhancement for {project_name}")
+            enhancements_applied = []
+            
+            # Generate missing tests
+            missing_tests = await self._identify_missing_tests(project_name)
+            if missing_tests:
+                generated_tests = await self._generate_tests(missing_tests)
+                enhancements_applied.append({"type": "new_tests", "tests": generated_tests})
+            
+            # Improve existing tests
+            weak_tests = await self._identify_weak_tests(project_name)
+            if weak_tests:
+                improved_tests = await self._improve_test_quality(weak_tests)
+                enhancements_applied.append({"type": "improved_tests", "tests": improved_tests})
+            
+            # Add property-based tests
+            property_tests = await self._generate_property_tests(project_name)
+            if property_tests:
+                enhancements_applied.append({"type": "property_tests", "tests": property_tests})
+            
+            return {
+                "status": "success",
+                "enhancements_applied": enhancements_applied,
+                "timestamp": datetime.now()
+            }
+            
+        except Exception as e:
+            self.logger.error(f"Error in test enhancement: {str(e)}")
+            raise
 
-class IssueSnifferTool(BaseTool):
-    """Fetches and analyzes GitHub issues."""
-    
-    def __init__(self):
-        self.name = "IssueSnifferTool"
-    
-    def use(self, input_str: str) -> str:
-        repo_url = input_str.strip()
-        repo_name = repo_url.split("/")[-1]
-        api_url = f"https://api.github.com/repos/{repo_name}/issues"
-        response = requests.get(api_url)
-        if response.status_code == 200:
-            issues = response.json()
-            return f"Issues found: {json.dumps(issues, indent=2)}"
-        else:
-            return f"Failed to fetch issues: {response.status_code}"
+    async def _harden_security(self, project_name: str, security_data: Dict[str, Any]) -> Dict[str, Any]:
+        """Implement security improvements"""
+        try:
+            self.logger.info(f"Starting security hardening for {project_name}")
+            security_improvements = []
+            
+            # Fix security vulnerabilities
+            vulnerabilities = await self._identify_vulnerabilities(project_name)
+            if vulnerabilities:
+                fixed_vulnerabilities = await self._fix_vulnerabilities(vulnerabilities)
+                security_improvements.append({"type": "vulnerability_fixes", "fixes": fixed_vulnerabilities})
+            
+            # Implement security best practices
+            security_best_practices = await self._implement_security_practices(project_name)
+            security_improvements.append({"type": "best_practices", "implementations": security_best_practices})
+            
+            # Add security tests
+            security_tests = await self._add_security_tests(project_name)
+            security_improvements.append({"type": "security_tests", "tests": security_tests})
+            
+            return {
+                "status": "success",
+                "security_improvements": security_improvements,
+                "timestamp": datetime.now()
+            }
+            
+        except Exception as e:
+            self.logger.error(f"Error in security hardening: {str(e)}")
+            raise
 
-# --- Agent Definitions ---
+    async def _tune_performance(self, project_name: str, performance_data: Dict[str, Any]) -> Dict[str, Any]:
+        """Tune application performance"""
+        try:
+            self.logger.info(f"Starting performance tuning for {project_name}")
+            performance_improvements = []
+            
+            # Optimize database queries
+            if performance_data.get("database_issues"):
+                query_optimizations = await self._optimize_database_queries(project_name)
+                performance_improvements.append({"type": "database_optimization", "optimizations": query_optimizations})
+            
+            # Optimize algorithms
+            if performance_data.get("algorithm_issues"):
+                algorithm_optimizations = await self._optimize_algorithms(project_name)
+                performance_improvements.append({"type": "algorithm_optimization", "optimizations": algorithm_optimizations})
+            
+            # Implement caching
+            if performance_data.get("caching_recommended"):
+                caching_implementations = await self._implement_caching(project_name)
+                performance_improvements.append({"type": "caching", "implementations": caching_implementations})
+            
+            return {
+                "status": "success",
+                "performance_improvements": performance_improvements,
+                "timestamp": datetime.now()
+            }
+            
+        except Exception as e:
+            self.logger.error(f"Error in performance tuning: {str(e)}")
+            raise
 
-class CodeInterpreterAgent(CodeAgent):
-    def __init__(self):
-        tools = [CodeInterpreterTool()]
-        model = MyHfApiModel()
-        super().__init__(tools, model)
+    async def _improve_documentation(self, project_name: str, doc_data: Dict[str, Any]) -> Dict[str, Any]:
+        """Improve code documentation"""
+        try:
+            self.logger.info(f"Starting documentation improvement for {project_name}")
+            documentation_improvements = []
+            
+            # Generate missing docstrings
+            missing_docs = await self._identify_missing_docs(project_name)
+            if missing_docs:
+                generated_docs = await self._generate_docstrings(missing_docs)
+                documentation_improvements.append({"type": "docstrings", "docs": generated_docs})
+            
+            # Update README
+            readme_updates = await self._update_readme(project_name)
+            documentation_improvements.append({"type": "readme", "updates": readme_updates})
+            
+            # Generate API documentation
+            api_docs = await self._generate_api_docs(project_name)
+            documentation_improvements.append({"type": "api_docs", "docs": api_docs})
+            
+            return {
+                "status": "success",
+                "documentation_improvements": documentation_improvements,
+                "timestamp": datetime.now()
+            }
+            
+        except Exception as e:
+            self.logger.error(f"Error in documentation improvement: {str(e)}")
+            raise
 
-class WorkspaceEmulatorAgent(CodeAgent):
-    def __init__(self):
-        tools = [WorkspaceEmulatorTool()]
-        model = MyHfApiModel()
-        super().__init__(tools, model)
+    async def _generate_final_report(self) -> Dict[str, Any]:
+        """Generate comprehensive final report"""
+        total_duration = self.performance_monitor["end_time"] - self.performance_monitor["start_time"]
+        
+        return {
+            "status": "success",
+            "iterations_completed": self.current_iteration,
+            "total_duration": total_duration,
+            "refinement_history": self.refinement_history,
+            "final_metrics": await self._get_final_metrics(),
+            "performance_summary": self._get_performance_summary(),
+            "improvement_suggestions": self.improvement_suggestions,
+            "error_summary": self.error_tracker.get_error_analysis()
+        }
+
+    def _get_performance_summary(self) -> Dict[str, Any]:
+        """Generate performance summary"""
+        return {
+            "total_iterations": len(self.performance_monitor["iterations"]),
+            "average_iteration_time": statistics.mean(self.performance_monitor["iterations"]),
+            "memory_usage": {
+                "average": statistics.mean(self.performance_monitor["memory_usage"]),
+                "peak": max(self.performance_monitor["memory_usage"])
+            },
+            "cpu_usage": {
+                "average": statistics.mean(self.performance_monitor["cpu_usage"]),
+                "peak": max(self.performance_monitor["cpu_usage"])
+            }
+        }
+
+    async def _get_final_metrics(self) -> Dict[str, Any]:
+        """Get final quality metrics"""
+        return {
+            "code_quality": self.quality_metrics.code_quality_score,
+            "test_coverage": self.quality_metrics.test_coverage,
+            "security_score": self.quality_metrics.security_score,
+            "performance_score": self.quality_metrics.performance_score,
+            "improvement_percentage": await self._calculate_improvement_percentage()
+        }
+
+    async def _calculate_improvement_percentage(self) -> float:
+        """Calculate overall improvement percentage"""
+        if not self.refinement_history:
+            return 0.0
+            
+        initial_metrics = self.refinement_history[0].get("metrics", {})
+        final_metrics = self.refinement_history[-1].get("metrics", {})
+        
+        improvements = []
+        for metric in ["code_quality", "test_coverage", "security_score", "performance_score"]:
+            if metric in initial_metrics and metric in final_metrics:
+                improvement = (final_metrics[metric] - initial_metrics[metric]) / initial_metrics[metric] * 100
+                improvements.append(improvement)
+        
+        return statistics.mean(improvements) if improvements else 0.0
 
-class DeploymentSimulatorAgent(CodeAgent):
-    def __init__(self):
-        tools = [DeploymentSimulatorTool()]
-        model = MyHfApiModel()
-        super().__init__(tools, model)
+class StreamlitInterface:
+    """Streamlit UI integration for the RefinementLoop system"""
+    
+    def __init__(self, refinement_loop: RefinementLoop):
+        self.refinement_loop = refinement_loop
+        self.session_state = self._initialize_session_state()
+        self.theme = self._setup_theme()
+        self.metrics_cache = {}
+
+    def _initialize_session_state(self) -> Dict[str, Any]:
+        """Initialize Streamlit session state"""
+        if 'project_history' not in st.session_state:
+            st.session_state.project_history = []
+        if 'current_project' not in st.session_state:
+            st.session_state.current_project = None
+        if 'refinement_status' not in st.session_state:
+            st.session_state.refinement_status = None
+        return st.session_state
+
+    def _setup_theme(self) -> Dict[str, Any]:
+        """Setup custom theme for the interface"""
+        return {
+            'primary_color': '#1f77b4',
+            'background_color': '#ffffff',
+            'secondary_background_color': '#f0f2f6',
+            'text_color': '#262730',
+            'font': 'sans serif'
+        }
+
+    def render_main_interface(self):
+        """Render the main Streamlit interface"""
+        st.set_page_config(
+            page_title="Code Refinement System",
+            page_icon="🔄",
+            layout="wide"
+        )
 
-class ErrorSpottingAgent(CodeAgent):
-    def __init__(self):
-        tools = [ErrorSpottingTool()]
-        model = MyHfApiModel()
-        super().__init__(tools, model)
+        st.title("Advanced Code Refinement System")
+        
+        # Sidebar navigation
+        self._render_sidebar()
+        
+        # Main content area
+        selected_tab = st.tabs(["Dashboard", "Project Analysis", "Refinement History", "Settings"])
+        
+        with selected_tab[0]:
+            self._render_dashboard()
+        
+        with selected_tab[1]:
+            self._render_project_analysis()
+            
+        with selected_tab[2]:
+            self._render_refinement_history()
+            
+        with selected_tab[3]:
+            self._render_settings()
 
-class GitHubRepoSpongeAgent(CodeAgent):
-    def __init__(self):
-        tools = [GitHubRepoSpongeTool()]
-        model = MyHfApiModel()
-        super().__init__(tools, model)
+    def _render_sidebar(self):
+        """Render sidebar with project controls"""
+        with st.sidebar:
+            st.header("Project Controls")
+            
+            # Project selection/creation
+            project_name = st.text_input("Project Name")
+            
+            if st.button("Start New Refinement"):
+                if project_name:
+                    self._start_new_refinement(project_name)
+            
+            # Current project status
+            if st.session_state.current_project:
+                st.subheader("Current Project")
+                st.info(f"Active: {st.session_state.current_project}")
+                
+                if st.session_state.refinement_status:
+                    st.progress(self._calculate_progress())
+                    
+            # Quick actions
+            st.subheader("Quick Actions")
+            if st.button("Stop Refinement"):
+                self._stop_refinement()
+            if st.button("Export Report"):
+                self._export_report()
+
+    def _render_dashboard(self):
+        """Render main dashboard with key metrics"""
+        col1, col2, col3 = st.columns(3)
+        
+        with col1:
+            self._render_quality_metrics()
+        
+        with col2:
+            self._render_performance_metrics()
+            
+        with col3:
+            self._render_security_metrics()
+            
+        # Detailed charts
+        self._render_trend_charts()
+        
+        # Recent activity
+        self._render_recent_activity()
 
-class IssueSnifferAgent(CodeAgent):
-    def __init__(self):
-        tools = [IssueSnifferTool()]
-        model = MyHfApiModel()
-        super().__init__(tools, model)
+    def _render_quality_metrics(self):
+        """Render code quality metrics"""
+        st.subheader("Code Quality")
+        
+        if self.metrics_cache.get('quality_metrics'):
+            metrics = self.metrics_cache['quality_metrics']
+            
+            # Display metrics with gauges
+            col1, col2 = st.columns(2)
+            with col1:
+                self._render_gauge(
+                    "Code Quality Score",
+                    metrics['code_quality_score'],
+                    0,
+                    100,
+                    "Higher is better"
+                )
+            with col2:
+                self._render_gauge(
+                    "Test Coverage",
+                    metrics['test_coverage'],
+                    0,
+                    100,
+                    "Target: 80%"
+                )
+            
+            # Show improvement suggestions
+            if metrics.get('suggestions'):
+                st.write("Improvement Suggestions:")
+                for suggestion in metrics['suggestions']:
+                    st.info(suggestion)
+
+    def _render_performance_metrics(self):
+        """Render performance metrics"""
+        st.subheader("Performance Metrics")
+        
+        if self.metrics_cache.get('performance_metrics'):
+            metrics = self.metrics_cache['performance_metrics']
+            
+            # Display key performance indicators
+            cols = st.columns(3)
+            with cols[0]:
+                st.metric(
+                    "Response Time",
+                    f"{metrics['response_time']}ms",
+                    delta=metrics['response_time_change']
+                )
+            with cols[1]:
+                st.metric(
+                    "Memory Usage",
+                    f"{metrics['memory_usage']}MB",
+                    delta=metrics['memory_usage_change']
+                )
+            with cols[2]:
+                st.metric(
+                    "CPU Usage",
+                    f"{metrics['cpu_usage']}%",
+                    delta=metrics['cpu_usage_change']
+                )
+            
+            # Performance trend chart
+            if metrics.get('history'):
+                self._render_line_chart(
+                    "Performance Trend",
+                    metrics['history'],
+                    'timestamp',
+                    'response_time'
+                )
+
+    def _render_security_metrics(self):
+        """Render security metrics and vulnerabilities"""
+        st.subheader("Security Analysis")
+        
+        if self.metrics_cache.get('security_metrics'):
+            metrics = self.metrics_cache['security_metrics']
+            
+            # Security score
+            st.metric(
+                "Security Score",
+                f"{metrics['security_score']}/100",
+                delta=metrics['security_score_change']
+            )
+            
+            # Vulnerabilities
+            if metrics.get('vulnerabilities'):
+                st.write("Detected Vulnerabilities:")
+                for vuln in metrics['vulnerabilities']:
+                    severity_color = {
+                        'HIGH': 'red',
+                        'MEDIUM': 'orange',
+                        'LOW': 'yellow'
+                    }.get(vuln['severity'], 'grey')
+                    
+                    st.markdown(
+                        f"<span style='color: {severity_color}'>"
+                        f"[{vuln['severity']}] {vuln['description']}"
+                        f"</span>",
+                        unsafe_allow_html=True
+                    )
+
+    async def _start_new_refinement(self, project_name: str):
+        """Start a new refinement cycle"""
+        try:
+            st.session_state.current_project = project_name
+            st.session_state.refinement_status = "running"
+            
+            # Create progress placeholder
+            progress_bar = st.progress(0)
+            status_text = st.empty()
+            
+            # Run refinement cycle
+            result = await self.refinement_loop.run_refinement_cycle(project_name)
+            
+            # Update session state with results
+            st.session_state.project_history.append({
+                "project_name": project_name,
+                "timestamp": datetime.now(),
+                "result": result
+            })
+            
+            # Update metrics cache
+            self.metrics_cache = await self._fetch_latest_metrics(project_name)
+            
+            st.session_state.refinement_status = "completed"
+            status_text.success("Refinement completed successfully!")
+            
+        except Exception as e:
+            st.session_state.refinement_status = "failed"
+            st.error(f"Refinement failed: {str(e)}")
 
-# --- Refinement Loop Integration ---
+    def _render_trend_charts(self):
+        """Render trend charts for various metrics"""
+        st.subheader("Trend Analysis")
+        
+        # Create tabs for different trend views
+        trend_tabs = st.tabs(["Quality Trends", "Performance Trends", "Security Trends"])
+        
+        with trend_tabs[0]:
+            if self.metrics_cache.get('quality_history'):
+                self._render_line_chart(
+                    "Code Quality Trend",
+                    self.metrics_cache['quality_history'],
+                    'timestamp',
+                    'quality_score'
+                )
+        
+        with trend_tabs[1]:
+            if self.metrics_cache.get('performance_history'):
+                self._render_line_chart(
+                    "Performance Trend",
+                    self.metrics_cache['performance_history'],
+                    'timestamp',
+                    'response_time'
+                )
+        
+        with trend_tabs[2]:
+            if self.metrics_cache.get('security_history'):
+                self._render_line_chart(
+                    "Security Score Trend",
+                    self.metrics_cache['security_history'],
+                    'timestamp',
+                    'security_score'
+                )
+
+    def _render_recent_activity(self):
+        """Render recent activity log"""
+        st.subheader("Recent Activity")
+        
+        if st.session_state.project_history:
+            for activity in reversed(st.session_state.project_history[-5:]):
+                with st.expander(
+                    f"{activity['project_name']} - {activity['timestamp'].strftime('%Y-%m-%d %H:%M:%S')}"
+                ):
+                    st.json(activity['result'])
+
+    async def _fetch_latest_metrics(self, project_name: str) -> Dict[str, Any]:
+        """Fetch latest metrics for the project"""
+        try:
+            # Get quality metrics
+            quality_metrics = await self.refinement_loop.quality_metrics.analyze_code(project_name)
+            
+            # Get performance metrics
+            performance_metrics = await self._get_performance_metrics(project_name)
+            
+            # Get security metrics
+            security_metrics = await self._get_security_metrics(project_name)
+            
+            return {
+                'quality_metrics': quality_metrics,
+                'performance_metrics': performance_metrics,
+                'security_metrics': security_metrics,
+                'last_updated': datetime.now()
+            }
+            
+        except Exception as e:
+            st.error(f"Error fetching metrics: {str(e)}")
+            return {}
 
-class AutonomousAgent(CodeAgent):
-    """An agent capable of creating other agents to complete tasks."""
-    
-    def __init__(self, tools, model):
-        super().__init__(tools, model)
-        self.sub_agents = []
-        self.refinement_loop = RefinementLoop(DevelopmentPipeline(
-            workspace_manager=st.session_state.workspace_manager,
-            tool_manager=st.session_state.tool_manager
+    def _calculate_progress(self) -> float:
+        """Calculate current refinement progress"""
+        if not st.session_state.refinement_status:
+            return 0.0
+            
+        if st.session_state.refinement_status == "completed":
+            return 1.0
+            
+        current_iteration = self.refinement_loop.current_iteration
+        max_iterations = self.refinement_loop.max_iterations
+        
+        return current_iteration / max_iterations
+
+    @staticmethod
+    def _render_gauge(title: str, value: float, min_value: float, max_value: float, help_text: str):
+        """Render a gauge chart"""
+        fig = go.Figure(go.Indicator(
+            mode="gauge+number",
+            value=value,
+            domain={'x': [0, 1], 'y': [0, 1]},
+            title={'text': title},
+            gauge={
+                'axis': {'range': [min_value, max_value]},
+                'bar': {'color': "darkblue"},
+                'steps': [
+                    {'range': [min_value, max_value * 0.6], 'color': "red"},
+                    {'range': [max_value * 0.6, max_value * 0.8], 'color': "yellow"},
+                    {'range': [max_value * 0.8, max_value], 'color': "green"}
+                ]
+            }
         ))
+        
+        st.plotly_chart(fig, use_container_width=True, help=help_text)
+
+    @staticmethod
+    def _render_line_chart(title: str, data: List[Dict[str, Any]], x_key: str, y_key: str):
+        """Render a line chart"""
+        df = pd.DataFrame(data)
+        fig = px.line(df, x=x_key, y=y_key, title=title)
+        st.plotly_chart(fig, use_container_width=True)
+
+class CodeRefinementApp:
+    """Main application class for the Code Refinement System"""
 
-    def analyze_task(self, task: str) -> str:
-        """Analyzes the task and determines necessary actions."""
-        prompt = f"Analyze this task and suggest actions: {task}"
-        analysis = self.model.generate(prompt)
-        return analysis
-    
-    def create_tool(self, tool_name: str):
-        """Dynamically creates a new tool based on the name."""
-        if tool_name == "CodeInterpreterTool":
-            return CodeInterpreterTool()
-        # Add more tools as needed
-        return None
-    
-    def create_sub_agent(self, task: str):
-        """Creates a new agent to handle a specific subtask."""
-        tools = [self.create_tool("CodeInterpreterTool")]
-        model = MyHfApiModel()
-        sub_agent = AutonomousAgent(tools, model)
-        self.sub_agents.append(sub_agent)
-        return sub_agent
-    
-    def delegate_task(self, task: str):
-        """Delegates a task to a sub-agent."""
-        sub_agent = self.create_sub_agent(task)
-        result = sub_agent.run(task)
-        return result
-    
-    def collaborate(self, task: str):
-        """Collaborates with sub-agents to complete a task."""
-        analysis = self.analyze_task(task)
-        if "subtask" in analysis.lower():
-            subtasks = analysis.split("\n")  # Example: Split analysis into subtasks
-            results = []
-            for subtask in subtasks:
-                result = self.delegate_task(subtask)
-                results.append(result)
-            return results
-        else:
-            return [self.run(task)]
-
-    def run_quality_assurance(self, project_name: str):
-        """Runs the quality assurance pipeline and refinement loop."""
-        results = self.refinement_loop.run_refinement_cycle(project_name)
-        return results
-
-# --- Tool Menu ---
-
-def get_available_tools():
-    """Returns a dictionary of available tools."""
-    return {
-        "MyDuckDuckGoSearchTool": MyDuckDuckGoSearchTool(),
-        "CodeInterpreterTool": CodeInterpreterTool(),
-        "WorkspaceEmulatorTool": WorkspaceEmulatorTool(),
-        "DeploymentSimulatorTool": DeploymentSimulatorTool(),
-        "ErrorSpottingTool": ErrorSpottingTool(),
-        "GitHubRepoSpongeTool": GitHubRepoSpongeTool(),
-        "IssueSnifferTool": IssueSnifferTool(),
-    }
-
-# --- Tool and Model Discovery ---
-
-def discover_tools_and_models():
-    """Automatically discovers and returns dictionaries of available tools and models."""
-    tools = {}
-    models = {}
-
-    for name, obj in inspect.getmembers(inspect.getmodule(inspect.currentframe())):
-        if inspect.isclass(obj):
-            if issubclass(obj, BaseTool) and obj is not BaseTool:
-                tools[name] = obj
-            if issubclass(obj, BaseModel) and obj is not BaseModel:
-                models[name] = obj
-
-    return tools, models
-
-# --- Agent Registry ---
-
-class AgentRegistry:
     def __init__(self):
-        self.agents = {}
-
-    @handle_agent_errors
-    def add_agent(self, name, agent):
-        if not isinstance(agent, CodeAgent):
-            raise TypeError("Agent must be an instance of CodeAgent.")
-        if name in self.agents:
-            raise ValueError(f"Agent with name '{name}' already exists.")
-        self.agents[name] = agent
-
-    def get_agent(self, name):
-        if name not in self.agents:
-            raise AgentException(f"Agent '{name}' not found.")
-        return self.agents.get(name)
-
-    def list_agents(self):
-        return list(self.agents.keys())
-
-# --- State Management ---
-
-def initialize_state():
-    """Initializes the Streamlit session state."""
-    if "agent_registry" not in st.session_state:
-        st.session_state.agent_registry = AgentRegistry()
-        available_tools, available_models = discover_tools_and_models()
-        st.session_state.available_tools = available_tools
-        st.session_state.available_models = available_models
-
-        # Add pre-generated supplemental agents
-        st.session_state.agent_registry.add_agent("CodeInterpreterAgent", CodeInterpreterAgent())
-        st.session_state.agent_registry.add_agent("WorkspaceEmulatorAgent", WorkspaceEmulatorAgent())
-        st.session_state.agent_registry.add_agent("DeploymentSimulatorAgent", DeploymentSimulatorAgent())
-        st.session_state.agent_registry.add_agent("ErrorSpottingAgent", ErrorSpottingAgent())
-        st.session_state.agent_registry.add_agent("GitHubRepoSpongeAgent", GitHubRepoSpongeAgent())
-        st.session_state.agent_registry.add_agent("IssueSnifferAgent", IssueSnifferAgent())
-
-        # Add a default autonomous agent
-        st.session_state.agent_registry.add_agent(
-            "AutonomousDevAgent",
-            AutonomousAgent(
-                tools=[MyDuckDuckGoSearchTool()],
-                model=MyHfApiModel()
+        self.config = self._load_config()
+        self.pipeline = self._initialize_pipeline()
+        self.refinement_loop = self._initialize_refinement_loop()
+        self.interface = StreamlitInterface(self.refinement_loop)
+        
+    def _load_config(self) -> Dict[str, Any]:
+        """Load application configuration"""
+        return {
+            'app_name': 'Code Refinement System',
+            'version': '1.0.0',
+            'max_iterations': int(os.getenv('MAX_ITERATIONS', 5)),
+            'workspace_dir': os.getenv('WORKSPACE_DIR', './workspace'),
+            'model_config': {
+                'model_name': os.getenv('LLM_MODEL', 'gemini/gemini-1.5-pro'),
+                'api_key': os.getenv('GEMINI_API_KEY'),
+                'temperature': float(os.getenv('MODEL_TEMPERATURE', 0.7)),
+                'max_tokens': int(os.getenv('MAX_TOKENS', 2000))
+            },
+            'performance': {
+                'cache_enabled': bool(os.getenv('ENABLE_CACHE', True)),
+                'max_concurrent_tasks': int(os.getenv('MAX_CONCURRENT_TASKS', 3)),
+                'timeout': int(os.getenv('OPERATION_TIMEOUT', 300))
+            },
+            'security': {
+                'enable_vulnerability_scan': bool(os.getenv('ENABLE_VULNERABILITY_SCAN', True)),
+                'max_file_size_mb': int(os.getenv('MAX_FILE_SIZE_MB', 10))
+            }
+        }
+
+    def _initialize_pipeline(self) -> DevelopmentPipeline:
+        """Initialize the development pipeline"""
+        try:
+            workspace_path = Path(self.config['workspace_dir'])
+            workspace_path.mkdir(parents=True, exist_ok=True)
+            
+            return DevelopmentPipeline(
+                workspace_manager=self._setup_workspace_manager(),
+                tool_manager=self._setup_tool_manager()
             )
-        )
-    if "logs" not in st.session_state:
-        st.session_state.logs = []
-    if "autonomous_output" not in st.session_state:
-        st.session_state.autonomous_output = []
-    if "chat_output" not in st.session_state:
-        st.session_state.chat_output = []
-
-# --- Logging ---
-
-def log_agent_action(prompt, result, agent_name):
-    timestamp = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-    log_entry = {
-        "timestamp": timestamp,
-        "agent": agent_name,
-        "prompt": prompt,
-        "result": result
-    }
-    st.session_state.logs.append(log_entry)
-
-# --- Chat Output ---
-
-def add_to_chat_output(agent_name: str, message: str):
-    """Adds a message to the chat output."""
-    timestamp = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-    chat_entry = {
-        "timestamp": timestamp,
-        "agent": agent_name,
-        "message": message
-    }
-    st.session_state.chat_output.append(chat_entry)
-
-# --- Streamlit UI ---
+        except Exception as e:
+            logger.error(f"Failed to initialize pipeline: {str(e)}")
+            raise
 
-def main():
-    st.title("AI Agent Sandbox - Autonomous Mode")
-    st.write("Create, test, and manage autonomous AI agents that can create other agents to complete tasks.")
+    def _initialize_refinement_loop(self) -> RefinementLoop:
+        """Initialize the refinement loop"""
+        try:
+            return RefinementLoop(
+                pipeline=self.pipeline,
+                max_iterations=self.config['max_iterations']
+            )
+        except Exception as e:
+            logger.error(f"Failed to initialize refinement loop: {str(e)}")
+            raise
 
-    initialize_state()
+    def _setup_workspace_manager(self):
+        """Setup workspace manager with configuration"""
+        from workspace_manager import WorkspaceManager
+        
+        return WorkspaceManager(
+            base_path=self.config['workspace_dir'],
+            max_file_size=self.config['security']['max_file_size_mb'] * 1024 * 1024
+        )
 
-    # --- Sidebar: Agent Management ---
-    with st.sidebar:
-        st.subheader("Agent Management")
-        selected_agent_name = st.selectbox(
-            "Select an Agent:",
-            st.session_state.agent_registry.list_agents() + ["Create New Agent"]
+    def _setup_tool_manager(self):
+        """Setup tool manager with configuration"""
+        from tool_manager import ToolManager
+        
+        return ToolManager(
+            model_config=self.config['model_config'],
+            max_concurrent=self.config['performance']['max_concurrent_tasks'],
+            timeout=self.config['performance']['timeout']
         )
 
-        # --- Create New Agent ---
-        if selected_agent_name == "Create New Agent":
-            st.subheader("Create a New Agent")
-            new_agent_name = st.text_input("Agent Name:")
+    async def _setup_async_components(self):
+        """Setup async components and background tasks"""
+        try:
+            # Initialize cache if enabled
+            if self.config['performance']['cache_enabled']:
+                await self._initialize_cache()
             
-            tool_options = {
-                name: f"{name} - {cls.__doc__ or 'No description available.'}"
-                for name, cls in st.session_state.available_tools.items()
-            }
-            selected_tool_names = st.multiselect(
-                "Agent Tools:",
-                options=list(tool_options.keys()),
-                format_func=lambda x: tool_options[x],
-                default=["MyDuckDuckGoSearchTool"] if "MyDuckDuckGoSearchTool" in tool_options else []
-            )
+            # Setup background tasks
+            asyncio.create_task(self._monitor_system_health())
+            asyncio.create_task(self._cleanup_old_workspaces())
+            
+        except Exception as e:
+            logger.error(f"Failed to setup async components: {str(e)}")
+            raise
 
-            model_options = {
-                name: f"{name} - {cls.__doc__ or 'No description available.'}"
-                for name, cls in st.session_state.available_models.items()
-            }
-            selected_model_name = st.selectbox(
-                "Model:",
-                options=list(model_options.keys())
-            )
+    async def _initialize_cache(self):
+        """Initialize caching system"""
+        try:
+            from caching import CacheManager
+            
+            cache_manager = CacheManager()
+            await cache_manager.initialize()
+            return cache_manager
+        except Exception as e:
+            logger.warning(f"Cache initialization failed: {str(e)}")
+            return None
+
+    async def _monitor_system_health(self):
+        """Monitor system health in background"""
+        while True:
+            try:
+                # Check system resources
+                memory_usage = self._check_memory_usage()
+                cpu_usage = self._check_cpu_usage()
+                disk_usage = self._check_disk_usage()
+                
+                # Log metrics
+                logger.info(
+                    f"System Health - Memory: {memory_usage}%, "
+                    f"CPU: {cpu_usage}%, "
+                    f"Disk: {disk_usage}%"
+                )
+                
+                # Alert if thresholds exceeded
+                self._check_resource_thresholds(memory_usage, cpu_usage, disk_usage)
+                
+                await asyncio.sleep(300)  # Check every 5 minutes
+                
+            except Exception as e:
+                logger.error(f"Health monitoring error: {str(e)}")
+                await asyncio.sleep(60)  # Retry after 1 minute
+
+    async def _cleanup_old_workspaces(self):
+        """Cleanup old workspace directories"""
+        while True:
+            try:
+                workspace_path = Path(self.config['workspace_dir'])
+                current_time = datetime.now()
+                
+                for item in workspace_path.glob("*"):
+                    if item.is_dir():
+                        # Check if directory is older than 7 days
+                        age = current_time - datetime.fromtimestamp(item.stat().st_mtime)
+                        if age.days > 7:
+                            logger.info(f"Cleaning up old workspace: {item}")
+                            self._safe_remove_directory(item)
+                
+                await asyncio.sleep(86400)  # Run daily
+                
+            except Exception as e:
+                logger.error(f"Workspace cleanup error: {str(e)}")
+                await asyncio.sleep(3600)  # Retry after 1 hour
+
+    def run(self):
+        """Main application entry point"""
+        try:
+            logger.info(f"Starting {self.config['app_name']} v{self.config['version']}")
+            
+            # Setup async components
+            asyncio.run(self._setup_async_components())
+            
+            # Launch Streamlit interface
+            self.interface.render_main_interface()
+            
+        except Exception as e:
+            logger.error(f"Application error: {str(e)}")
+            st.error("An error occurred while starting the application. Please check the logs.")
+            raise
 
-            if st.button("Create Agent"):
-                create_agent(new_agent_name, selected_tool_names, selected_model_name)
-
-    # --- Tool Menu for Autonomous Agent ---
-    st.header("Tool Menu for Autonomous Agent")
-    available_tools = get_available_tools()
-    selected_tools = st.multiselect(
-        "Select tools for the autonomous agent:",
-        options=list(available_tools.keys()),
-        default=["MyDuckDuckGoSearchTool"]
-    )
-
-    # --- Autonomous Mode ---
-    st.header("Autonomous Mode")
-    task = st.text_area("Enter a task for the autonomous agent:", "Develop a tool to automate software development tasks.")
-
-    # --- Quality Assurance Pipeline ---
-    if st.button("Run Quality Assurance Pipeline"):
-        if "AutonomousDevAgent" in st.session_state.agent_registry.list_agents():
-            agent = st.session_state.agent_registry.get_agent("AutonomousDevAgent")
-            if isinstance(agent, AutonomousAgent):
-                project_name = "SampleProject"  # Replace with actual project name
-                qa_results = agent.run_quality_assurance(project_name)
-                st.session_state.autonomous_output.append(f"Quality Assurance Results: {qa_results}")
-                add_to_chat_output("AutonomousDevAgent", "Quality Assurance completed.")
-            else:
-                st.error("Selected agent is not an AutonomousAgent.")
-        else:
-            st.error("AutonomousDevAgent not available.")
-
-    # Initialize a flag for continuous refinement
-    if "refining" not in st.session_state:
-        st.session_state.refining = False
-
-    if st.button("Start Continuous Refinement"):
-        st.session_state.refining = True
-        # Initialize the autonomous agent with selected tools
-        tools = [available_tools[tool] for tool in selected_tools]
-        autonomous_agent = AutonomousAgent(tools=tools, model=MyHfApiModel())
-        
-        # Add initial task to chat output
-        add_to_chat_output("AutonomousDevAgent", f"Starting task: {task}")
-        
-        while st.session_state.refining:
-            # Run the autonomous agent
-            results = autonomous_agent.collaborate(task)
-            
-            # Display results in-app
-            st.session_state.autonomous_output = []
-            for result in results:
-                st.session_state.autonomous_output.append(result)
-                add_to_chat_output("AutonomousDevAgent", f"Task result: {result}")
-            
-            # Log the results
-            log_agent_action(task, results, "AutonomousDevAgent")
-
-            # Allow for user interjection
-            user_message = st.text_input("Enter a message to steer/redirect/modify the developmental course:", key="user_interjection")
-            if st.button("Submit Message"):
-                if user_message:
-                    add_to_chat_output("User", f"Interjection: {user_message}")
-                    st.session_state.autonomous_output.append(f"User Interjection: {user_message}")
-                    st.write(f"**User Interjection:**\n{user_message}")
-
-            # Check if the user wants to stop the refinement
-            if st.button("Stop Continuous Refinement"):
-                st.session_state.refining = False
-                st.write("Continuous refinement stopped.")
-
-    # --- Chat Output ---
-    st.header("Chat Output")
-    for entry in st.session_state.chat_output:
-        st.write(f"{entry['timestamp']} - {entry['agent']}: {entry['message']}")
-
-    # --- Display Autonomous Output ---
-    st.header("Autonomous Output")
-    for output in st.session_state.autonomous_output:
-        st.write(f"**Output:**\n{output}")
-
-    # --- Display Logs ---
-    st.header("Logs")
-    if st.session_state.logs:
-        for log in st.session_state.logs:
-            st.write(f"{log['timestamp']} - {log['agent']}: {log['prompt']} -> {log['result']}")
-    else:
-        st.write("No logs available.")
+def main():
+    """Application entry point"""
+    try:
+        # Enable wide mode
+        st.set_page_config(
+            page_title="Code Refinement System",
+            page_icon="🔄",
+            layout="wide",
+            initial_sidebar_state="expanded"
+        )
+        
+        # Initialize and run application
+        app = CodeRefinementApp()
+        app.run()
+        
+    except Exception as e:
+        st.error(f"Failed to start application: {str(e)}")
+        logger.critical(f"Application failed to start: {str(e)}", exc_info=True)
+        sys.exit(1)
 
 if __name__ == "__main__":
     main()