Fixed missing _execute_agent_task and _execute_paths methods in EnhancedAIFlow

app.py

@@ -366,94 +366,124 @@ class AIFlow:
         except Exception as e:
             logger.error(f"Flow execution failed: {str(e)}")
             raise
-
+    
     async def _execute_paths(self, paths: List[List[AgentRole]]):
-        """Execute multiple paths through the flow in parallel."""
-        path_tasks = [self._execute_path(path) for path in paths]
-        await asyncio.gather(*path_tasks)
-
-    async def _execute_path(self, path: List[AgentRole]):
-        """Execute a single path through the flow."""
-        for role in path:
-            context = self.contexts[role]
-            if context.state != FlowState.COMPLETED:
-                await self._execute_agent(role)
-
-    async def _execute_agent(self, role: AgentRole):
-        """Execute a single agent's tasks."""
-        context = self.contexts[role]
-        context.state = FlowState.RUNNING
+        """Execute all paths in the flow graph."""
+        try:
+            results = []
+            for path in paths:
+                path_results = []
+                for role in path:
+                    # Get the agent's prompt based on previous results
+                    prompt = self._generate_prompt(role, path_results)
+                    
+                    # Execute the agent's task
+                    result = await self._execute_agent_task(role, prompt)
+                    path_results.append(result)
+                    
+                    # Store result in context
+                    self.context_manager.add_memory(
+                        f"{role.value}_result",
+                        result,
+                        {"timestamp": datetime.now()}
+                    )
+                
+                results.extend(path_results)
+            
+            # Store all results in context
+            self.context_manager.add_memory(
+                "path_results",
+                results,
+                {"timestamp": datetime.now()}
+            )
+            
+            return results
+        except Exception as e:
+            logger.error(f"Failed to execute paths: {str(e)}")
+            raise
+    
+    def _generate_prompt(self, role: AgentRole, previous_results: List[str]) -> str:
+        """Generate a prompt for an agent based on previous results."""
+        requirements = self.context_manager.global_context.get("requirements", "")
+        
+        # Base prompt with requirements
+        prompt = f"Requirements: {requirements}\n\n"
+        
+        # Add context from previous results
+        if previous_results:
+            prompt += "Previous work:\n"
+            for i, result in enumerate(previous_results):
+                prompt += f"{i+1}. {result}\n"
+        
+        # Add role-specific instructions
+        if role == AgentRole.ARCHITECT:
+            prompt += "\nAs the Architect, design the high-level system architecture."
+        elif role == AgentRole.UI_DESIGNER:
+            prompt += "\nAs the UI Designer, create the user interface design."
+        elif role == AgentRole.BACKEND_DEVELOPER:
+            prompt += "\nAs the Backend Developer, implement the server-side logic."
+        elif role == AgentRole.DATABASE_ENGINEER:
+            prompt += "\nAs the Database Engineer, design the data model and storage."
+        elif role == AgentRole.SECURITY_EXPERT:
+            prompt += "\nAs the Security Expert, ensure security best practices."
+        elif role == AgentRole.QA_ENGINEER:
+            prompt += "\nAs the QA Engineer, create test cases and validation."
+        elif role == AgentRole.DEVOPS_ENGINEER:
+            prompt += "\nAs the DevOps Engineer, set up deployment and CI/CD."
+        elif role == AgentRole.DOCUMENTATION_WRITER:
+            prompt += "\nAs the Documentation Writer, create comprehensive documentation."
         
+        return prompt
+    
+    def _compile_results(self) -> str:
+        """Compile all results into a final output."""
         try:
-            # Get agent-specific prompt
-            prompt = self._get_agent_prompt(role)
+            results = []
             
-            # Execute agent's task
+            # Get all results from memory
+            for role in AgentRole:
+                result = self.context_manager.get_memory(f"{role.value}_result")
+                if result:
+                    results.append(f"## {role.value}\n{result['value']}\n")
+            
+            return "\n".join(results)
+        except Exception as e:
+            logger.error(f"Failed to compile results: {str(e)}")
+            raise
+    
+    async def _execute_agent_task(self, role: AgentRole, prompt: str) -> str:
+        """Execute a specific agent's task with the given prompt."""
+        try:
             if role == AgentRole.ARCHITECT:
-                result = await self._execute_architect(prompt)
+                agent = get_agent("architect")
             elif role == AgentRole.UI_DESIGNER:
-                result = await self._execute_ui_designer(prompt)
+                agent = get_agent("ui_designer")
             elif role == AgentRole.BACKEND_DEVELOPER:
-                result = await self._execute_backend_developer(prompt)
-            # ... (similar for other roles)
+                agent = get_agent("backend_developer")
+            elif role == AgentRole.DATABASE_ENGINEER:
+                agent = get_agent("database_engineer")
+            elif role == AgentRole.SECURITY_EXPERT:
+                agent = get_agent("security_expert")
+            elif role == AgentRole.QA_ENGINEER:
+                agent = get_agent("qa_engineer")
+            elif role == AgentRole.DEVOPS_ENGINEER:
+                agent = get_agent("devops_engineer")
+            elif role == AgentRole.DOCUMENTATION_WRITER:
+                agent = get_agent("documentation_writer")
+            else:
+                raise ValueError(f"Unknown agent role: {role}")
             
-            # Store results in context
-            context.artifacts["output"] = result
-            context.state = FlowState.COMPLETED
+            # Execute the agent's task
+            result = agent.run(prompt)
+            
+            # Log the execution
+            logger.info(f"Agent {role.value} completed task")
             
+            return result
         except Exception as e:
-            context.state = FlowState.FAILED
-            context.feedback.append(str(e))
+            logger.error(f"Agent {role.value} failed: {str(e)}")
             raise
 
-    def _get_agent_prompt(self, role: AgentRole) -> str:
-        """Get the appropriate prompt template for each agent role."""
-        prompts = {
-            AgentRole.ARCHITECT: """You are a Software Architect designing a scalable application.
-Requirements: {requirements}
-
-Focus on:
-1. System architecture
-2. Component interactions
-3. Technology stack selection
-4. Scalability considerations
-5. Integration patterns
-
-Provide:
-- High-level architecture diagram
-- Component breakdown
-- Technology recommendations
-- Integration patterns
-- Performance considerations""",
-            # ... (other role-specific prompts)
-        }
-        
-        base_prompt = prompts.get(role, "")
-        return base_prompt.format(**self.global_context)
-
-    async def _execute_architect(self, prompt: str) -> str:
-        """Execute the Architect agent's tasks."""
-        agent = get_agent("architect")
-        return agent.run(prompt)
-
-    async def _execute_ui_designer(self, prompt: str) -> str:
-        """Execute the UI Designer agent's tasks."""
-        agent = get_agent("ui_designer")
-        return agent.run(prompt)
-
-    # ... (similar methods for other roles)
-
-    def _compile_results(self) -> str:
-        """Compile the results from all agents into a final output."""
-        results = []
-        for role, context in self.contexts.items():
-            if context.state == FlowState.COMPLETED:
-                results.append(f"## {role.value.replace('_', ' ').title()} Output")
-                results.append(context.artifacts.get("output", "No output available"))
-                results.append("")
-        
-        return "\n".join(results)
-
 @dataclass
 class FileContext:
     """Context for file operations and tracking."""
@@ -727,14 +757,66 @@ class EnhancedAIFlow(AIFlow):
         self.file_manager = FileOperationManager(self.context_manager)
         self.command_manager = CommandManager(self.context_manager)
         self.rule_system = RuleSystem()
-        
+    
+    async def _execute_agent_task(self, role: AgentRole, prompt: str) -> str:
+        """Execute a specific agent's task with the given prompt."""
+        try:
+            if role == AgentRole.ARCHITECT:
+                agent = get_agent("architect")
+            elif role == AgentRole.UI_DESIGNER:
+                agent = get_agent("ui_designer")
+            elif role == AgentRole.BACKEND_DEVELOPER:
+                agent = get_agent("backend_developer")
+            elif role == AgentRole.DATABASE_ENGINEER:
+                agent = get_agent("database_engineer")
+            elif role == AgentRole.SECURITY_EXPERT:
+                agent = get_agent("security_expert")
+            elif role == AgentRole.QA_ENGINEER:
+                agent = get_agent("qa_engineer")
+            elif role == AgentRole.DEVOPS_ENGINEER:
+                agent = get_agent("devops_engineer")
+            elif role == AgentRole.DOCUMENTATION_WRITER:
+                agent = get_agent("documentation_writer")
+            else:
+                raise ValueError(f"Unknown agent role: {role}")
+            
+            # Execute the agent's task
+            result = agent.run(prompt)
+            
+            # Log the execution
+            logger.info(f"Agent {role.value} completed task")
+            
+            return result
+        except Exception as e:
+            logger.error(f"Agent {role.value} failed: {str(e)}")
+            raise
+    
     async def execute_flow(self, requirements: str):
         """Execute the AI Flow and build the project."""
         try:
-            # Execute normal flow
-            results = await super().execute_flow(requirements)
+            # Initialize flow with context
+            self.initialize_flow()
+            self.global_context["requirements"] = requirements
+            self.context_manager.global_context.update(self.global_context)
             
-            # Extract app name and generate documentation
+            # Add memory of requirements
+            self.context_manager.add_memory(
+                "requirements",
+                requirements,
+                {"timestamp": datetime.now()}
+            )
+            
+            # Get all paths through the flow graph
+            paths = list(nx.all_simple_paths(
+                self.flow_graph,
+                AgentRole.ARCHITECT,
+                AgentRole.DOCUMENTATION_WRITER
+            ))
+            
+            # Execute paths with enhanced context
+            await self._execute_paths(paths)
+            
+            # Extract app name
             app_name = requirements.split()[0].lower().replace(" ", "_")
             
             # Create basic project structure
@@ -766,6 +848,9 @@ class EnhancedAIFlow(AIFlow):
             # Create download
             download_path = self.output_manager.create_download(app_name)
             
+            # Compile results
+            results = self._compile_results()
+            
             # Add download information to results
             results += f"""
 ## Download
@@ -784,6 +869,7 @@ The following files have been created:
                 results += f"- {rel_path}\n"
             
             return results
+            
         except Exception as e:
             logger.error(f"Enhanced flow execution failed: {str(e)}")
             raise
@@ -833,7 +919,7 @@ async def multi_agent_workflow(requirements: str) -> str:
         flow = EnhancedAIFlow()
         results = await flow.execute_flow(requirements)
         
-        # Extract app name and generate documentation
+        # Extract app name
         app_name = requirements.split()[0].lower().replace(" ", "_")
         
         # Generate project structure and documentation