Update definitions.py

definitions.py

@@ -326,8 +326,12 @@ class AutonomousAgent:
         self.refinement_loop = RefinementLoop(pipeline=self.pipeline)
         self.tools_repository = self._initialize_tool_repository()
         self.chat_system = ChatSystem(self)
-        self.interface = StreamlitInterface(self)
+        self.autonomous_agent = AutonomousAgent(self)
+        self.interface = StreamlitInterface(self.autonomous_agent)
 
+    def run(self):
+        """Run the Streamlit application."""
+        self.interface.render_main_interface()
     def _initialize_tool_repository(self) -> ToolRepository:
         """Initialize the tool repository."""
         repository = ToolRepository()
@@ -374,6 +378,7 @@ class AutonomousAgent:
     def get_tools_by_type(self, tool_type: str) -> List[Dict]:
         """Get all tools of a specific type."""
 
+
 class DevelopmentPipeline:
     def __init__(self, workspace_manager, tool_manager):
         """Initialize the development pipeline with the given workspace and tool managers."""
@@ -731,13 +736,122 @@ class StreamlitInterface:
         self.metrics_history = []
         self.activity_log = []
 
-    # ... (previous methods remain the same) ...
+    def render_main_interface(self):
+        """Render the main Streamlit interface."""
+        st.title("Autonomous Agent System")
+        
+        # Initialize session state if not exists
+        if 'current_page' not in st.session_state:
+            st.session_state.current_page = 'Dashboard'
+        
+        # Sidebar for navigation
+        self.render_sidebar()
+        
+        # Main content area
+        selected_page = st.session_state.current_page
+        
+        if selected_page == 'Dashboard':
+            self.render_dashboard()
+        elif selected_page == 'Pipeline':
+            self.render_pipeline_view()
+        elif selected_page == 'Metrics':
+            self.render_metrics_view()
+        elif selected_page == 'Settings':
+            self.render_settings()
+
+    def render_sidebar(self):
+        """Render the sidebar navigation."""
+        with st.sidebar:
+            st.title("Navigation")
+            pages = ['Dashboard', 'Pipeline', 'Metrics', 'Settings']
+            selected_page = st.radio("Select Page", pages, key='nav_radio')
+            st.session_state.current_page = selected_page
+
+    def render_dashboard(self):
+        """Render the dashboard view."""
+        st.header("System Dashboard")
+        
+        # System Status
+        col1, col2, col3 = st.columns(3)
+        with col1:
+            st.metric("Pipeline Status", "Active")
+        with col2:
+            current_stage = getattr(self.agent.pipeline, 'current_stage', None)
+            stage_name = current_stage.name if current_stage else "None"
+            st.metric("Current Stage", stage_name)
+        with col3:
+            st.metric("Tasks Completed", "0")
+
+        # Recent Activity
+        st.subheader("Recent Activity")
+        activity_data = self.get_recent_activity()
+        if activity_data:
+            st.table(activity_data)
+        else:
+            st.info("No recent activity")
+
+    def render_pipeline_view(self):
+        """Render the pipeline view."""
+        st.header("Development Pipeline")
+        
+        # Pipeline Stages
+        stages = {
+            'PLANNING': "Planning",
+            'DEVELOPMENT': "Development",
+            'TESTING': "Testing"
+        }
+        
+        for stage_key, stage_name in stages.items():
+            with st.expander(f"{stage_name} Stage"):
+                current_stage = getattr(self.agent.pipeline, 'current_stage', None)
+                if current_stage and stage_key == current_stage.name:
+                    st.info("Current Stage")
+                self.render_stage_details(stage_key)
+
+    def render_metrics_view(self):
+        """Render the metrics view."""
+        st.header("System Metrics")
+        
+        # Code Quality Metrics
+        st.subheader("Code Quality Metrics")
+        metrics = self.get_metrics()
+        
+        if metrics:
+            for file, file_metrics in metrics.items():
+                with st.expander(f"Metrics for {file}"):
+                    st.json(file_metrics)
+        else:
+            st.info("No metrics available yet")
+
+    def render_settings(self):
+        """Render the settings view."""
+        st.header("System Settings")
+        
+        # General Settings
+        st.subheader("General Settings")
+        workspace_dir = st.text_input(
+            "Workspace Directory",
+            value=self.agent.workspace_manager.workspace_dir
+        )
+        
+        # Pipeline Settings
+        st.subheader("Pipeline Settings")
+        quality_threshold = st.slider(
+            "Quality Threshold",
+            min_value=0.0,
+            max_value=1.0,
+            value=0.8,
+            step=0.1
+        )
+        
+        if st.button("Save Settings"):
+            self.save_settings(workspace_dir, quality_threshold)
 
     def get_recent_activity(self) -> List[Dict]:
         """Get recent activity data for display."""
         return [
             {
-                "timestamp": activity["timestamp"],
+                "timestamp": activity["timestamp"].strftime("%Y-%m-%d %H:%M:%S"),
                 "action": activity["action"],
                 "status": activity["status"],
                 "details": activity["details"]
@@ -745,81 +859,69 @@ class StreamlitInterface:
             for activity in self.activity_log[-10:]  # Show last 10 activities
         ]
 
-    def render_stage_details(self, stage: PipelineStage):
+    def get_metrics(self) -> Dict:
+        """Get current metrics data."""
+        return getattr(self.agent.pipeline, 'metrics', {})
+
+    def render_stage_details(self, stage: str):
         """Render details for a specific pipeline stage."""
-        stage_results = self.agent.pipeline.stage_results.get(stage, {})
+        stage_results = getattr(self.agent.pipeline, f'{stage.lower()}_results', {})
         
         if not stage_results:
             st.write("No data available for this stage yet.")
             return
 
-        # Display stage-specific information
-        if stage == PipelineStage.PLANNING:
+        if stage == 'PLANNING':
             self._render_planning_details(stage_results)
-        elif stage == PipelineStage.DEVELOPMENT:
+        elif stage == 'DEVELOPMENT':
             self._render_development_details(stage_results)
-        elif stage == PipelineStage.TESTING:
+        elif stage == 'TESTING':
             self._render_testing_details(stage_results)
 
     def _render_planning_details(self, results: Dict):
         """Render planning stage details."""
         st.subheader("Tasks")
-        for task in results.get('tasks', []):
-            st.write(f"- {task['id']}: {task['status']}")
-        
-        st.subheader("Timeline")
-        timeline = results.get('timeline', {})
-        st.write(f"Start Date: {timeline.get('start_date')}")
-        st.write(f"Estimated Completion: {timeline.get('estimated_completion')}")
+        tasks = results.get('tasks', [])
+        for task in tasks:
+            st.write(f"- {task}")
 
     def _render_development_details(self, results: Dict):
         """Render development stage details."""
-        st.subheader("Code Files")
-        for file in results.get('code_files', []):
-            st.write(f"- {file}")
+        st.subheader("Development Progress")
+        progress = results.get('progress', 0)
+        st.progress(progress)
         
-        st.subheader("Metrics")
-        metrics = results.get('metrics', {})
-        if metrics:
-            st.json(metrics)
+        files = results.get('files', [])
+        if files:
+            st.subheader("Modified Files")
+            for file in files:
+                st.write(f"- {file}")
 
     def _render_testing_details(self, results: Dict):
         """Render testing stage details."""
         st.subheader("Test Results")
         
-        # Test Cases
-        st.write("Test Cases:")
-        for test in results.get('test_cases', []):
-            st.write(f"- {test}")
-        
-        # Coverage
-        st.write("Coverage:")
-        coverage = results.get('coverage', {})
-        for file, cov in coverage.items():
-            st.write(f"- {file}: {cov}%")
-        
-        # Issues
-        st.write("Issues:")
-        for issue in results.get('issues', []):
-            st.write(f"- {issue}")
+        tests = results.get('tests', {})
+        if tests:
+            passed = tests.get('passed', 0)
+            failed = tests.get('failed', 0)
+            st.write(f"Passed: {passed}")
+            st.write(f"Failed: {failed}")
+        else:
+            st.write("No test results available")
 
     def save_settings(self, workspace_dir: str, quality_threshold: float):
         """Save the system settings."""
         try:
-            # Update workspace directory
             self.agent.workspace_manager.workspace_dir = workspace_dir
+            # Add more settings as needed
             
-            # Update quality threshold
-            self.agent.pipeline.quality_threshold = quality_threshold
-            
-            # Log the activity
             self.log_activity({
                 "timestamp": datetime.now(),
                 "action": "Settings Update",
                 "status": "Success",
-                "details": "System settings updated successfully"
+                "details": "Settings updated successfully"
             })
-            
             st.success("Settings saved successfully!")
             
         except Exception as e:
@@ -828,36 +930,9 @@ class StreamlitInterface:
     def log_activity(self, activity: Dict):
         """Log an activity in the system."""
         self.activity_log.append(activity)
-        # Keep only the last 100 activities
-        if len(self.activity_log) > 100:
+        if len(self.activity_log) > 100:  # Keep only last 100 activities
             self.activity_log = self.activity_log[-100:]
 
-    def update_metrics_history(self, metrics: Dict):
-        """Update the metrics history."""
-        self.metrics_history.append({
-            "timestamp": datetime.now(),
-            **metrics
-        })
-        # Keep only the last 50 metrics records
-        if len(self.metrics_history) > 50:
-            self.metrics_history = self.metrics_history[-50:]
-
-    def show_error(self, message: str):
-        """Display an error message."""
-        st.error(message)
-
-    def show_success(self, message: str):
-        """Display a success message."""
-        st.success(message)
-
-    def show_warning(self, message: str):
-        """Display a warning message."""
-        st.warning(message)
-
-    def show_info(self, message: str):
-        """Display an info message."""
-        st.info(message)
-
 if __name__ == "__main__":
     app = AutonomousAgentApp()
-    app.interface.render_main_interface()
+    app.run()