devhive 0.1.18__tar.gz → 0.1.19__tar.gz

{devhive-0.1.18 → devhive-0.1.19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devhive
-Version: 0.1.18
+Version: 0.1.19
 Summary: DevHive MCP Server
 Requires-Python: >=3.10
 License-File: LICENSE

devhive-0.1.19/devhive/agents/ceo.py

@@ -0,0 +1,95 @@
+import json
+from typing import Dict, Any
+from mcp.server.fastmcp import Context
+from devhive.agents.base_agent import BaseAgent
+from devhive.core.project_state_manager import ProjectStateManager
+
+class CEOAgent(BaseAgent):
+    role = "CEO"
+    
+    def get_next_agent_deterministic(self) -> Dict[str, Any]:
+        """
+        Determine next agent to run based on dynamic workflow_plan from the state.
+        
+        Returns:
+            Dict with 'agent' (role name) and 'reason' (explanation)
+        """
+        state = self.state_manager.get_state()
+        artifacts = state.get("artifacts", {})
+        
+        # If the CEO hasn't planned the workflow yet, run the CEO.
+        if artifacts.get("workflow_plan") is None:
+            return {
+                "agent": "CEO",
+                "reason": "Need initial workflow planning based on requirements"
+            }
+            
+        # Get the workflow plan created by the CEO
+        try:
+            plan_id = artifacts.get("workflow_plan")
+            plan_data = self.artifact_manager.load_artifact(plan_id)
+            workflow_plan = plan_data.get("workflow_plan", [])
+            # Fallback if workflow_plan is malformed
+            if not workflow_plan:
+                workflow_plan = ["Explorer", "Developer", "QA", "Archivist"]
+        except Exception:
+            # Fallback if something is broken
+            workflow_plan = ["Explorer", "Developer", "QA", "Archivist"]
+            
+        # Map agent names to artifact keys
+        mapping = {
+            "Explorer": "exploration",
+            "Proposal": "proposal",
+            "Architect": "architecture",
+            "TaskPlanner": "tasks",
+            "Developer": "implementation",
+            "QA": "tests",
+            "Auditor": "verification",
+            "Archivist": "archive"
+        }
+        
+        # Iterate over the plan and find the first incomplete agent
+        for agent in workflow_plan:
+            artifact_key = mapping.get(agent)
+            
+            if artifact_key == "implementation":
+                # Special iterative Developer logic
+                if artifacts.get("implementation") is None:
+                    dev_progress = state.get("developer_progress", {})
+                    pending_tasks = dev_progress.get("pending_tasks", [])
+                    completed_tasks = dev_progress.get("completed_tasks", [])
+                    
+                    if not dev_progress or pending_tasks:
+                        task_count = len(pending_tasks) if pending_tasks else "tasks"
+                        return {
+                            "agent": "Developer",
+                            "reason": f"Need to execute {task_count} pending tasks sequentially"
+                        }
+                    elif not pending_tasks and completed_tasks:
+                        # Implementation is complete based on tasks
+                        continue
+                    else:
+                        return {
+                            "agent": "Developer",
+                            "reason": "Ready for implementation"
+                        }
+                continue
+                
+            if artifacts.get(artifact_key) is None:
+                return {
+                    "agent": agent,
+                    "reason": f"Next agent in workflow plan: {agent}"
+                }
+        
+        # All done
+        return {
+            "agent": "Complete",
+            "reason": "All pipeline stages in the workflow plan have finished, project is complete"
+        }
+    
+    async def execute(self, ctx: Context, **kwargs) -> Dict[str, Any]:
+        """
+        CEO Agent execution logic is handled by TaskOrchestrator in the new task-based workflow.
+        This legacy method is not used.
+        """
+        pass

{devhive-0.1.18 → devhive-0.1.19}/devhive/cli.py

@@ -95,7 +95,7 @@ def configure():
     # 3. Configure OpenCode
     if choice in ["opencode", "both"]:
         dest_dir = Path.home() / ".config" / "opencode" / "agents"
-        dest_file = dest_dir / "DevHive0118.md"
+        dest_file = dest_dir / "DevHive0119.md"
         _copy_agent_file(source_to_use, dest_dir, dest_file, "OpenCode Agent")
         _configure_devhive()
 

{devhive-0.1.18 → devhive-0.1.19}/devhive/core/prompt_builder.py

@@ -27,7 +27,9 @@ Note: You have access to the devhive_search_memory tool if you need to find spec
             Dictionary with 'system_prompt' and 'user_prompt' keys
         """
         
-        if agent_role == "Explorer":
+        if agent_role == "CEO":
+            return PromptBuilder._build_ceo_prompts(context, **kwargs)
+        elif agent_role == "Explorer":
             return PromptBuilder._build_explorer_prompts(context, **kwargs)
         elif agent_role == "Proposal":
             return PromptBuilder._build_proposal_prompts(context)
@@ -47,43 +49,155 @@ Note: You have access to the devhive_search_memory tool if you need to find spec
             raise ValueError(f"Unknown agent role: {agent_role}")
 
     @staticmethod
-    def _build_explorer_prompts(context: Dict[str, Any], **kwargs) -> Dict[str, str]:
+    def _build_ceo_prompts(context: Dict[str, Any], **kwargs) -> Dict[str, str]:
         requirements = kwargs.get("requirements", "No requirements provided")
         
-        system_prompt = "You are the Analyst (Explorer). Output JSON only."
+        system_prompt = """
+You are an AI orchestration agent called "CEO".
+
+Your job is to orchestrate an AI software development pipeline by selecting and ordering agents to fulfill a feature request.
+
+Available agents:
+- Explorer
+- Proposal
+- Architect
+- TaskPlanner
+- Developer
+- QA
+- Auditor
+- Archivist
+
+Agent roles:
+
+Explorer
+Analyzes requirements, constraints and dependencies.
+
+Proposal
+Creates a structured feature proposal and acceptance criteria.
+
+Architect
+Designs technical architecture and system structure.
+
+TaskPlanner
+Breaks the feature into development tasks.
+
+Developer
+Implements the feature.
+
+QA
+Creates tests for the implementation.
+
+Auditor
+Reviews architecture, consistency, and security.
+
+Archivist
+Archives the final project state.
+
+Pipeline rules:
+- Explorer should normally run first
+- Developer must run before Archivist
+- Archivist must always be the final step
+- Agents must appear only once
+- The workflow must be logically ordered
+
+Agent selection guidelines:
+
+Proposal
+Use when the feature requires product clarification or acceptance criteria.
+
+Architect
+Use when backend systems, APIs, or architecture are involved.
+
+TaskPlanner
+Use when the implementation requires multiple tasks or moderate complexity.
+
+QA
+Use when code with logic is implemented.
+
+Auditor
+Use when architecture or security should be reviewed.
+
+Simple features may skip Proposal, Architect, TaskPlanner, QA, and Auditor.
+
+Output rules:
+- Return valid JSON only
+- Do not include explanations outside the JSON
+- Follow the schema exactly
+
+Schema:
+{
+  "workflow_plan": string[],
+  "reasoning": string
+}
+"""
         
-        user_prompt = f"""Analyze the following feature request: {requirements}
+        user_prompt = f"""
+Feature request:
 
-Context: {json.dumps(context, default=str)}
+{requirements}
 
-Your task is to perform initial analysis and exploration.
-Check 'project_guidelines' in the context. 
-- If it says "Guidelines not found.", you MUST establish the technology stack.
-  - If the stack is clear from the request (e.g. "Use Python/Flask"), generate a Markdown string for 'new_guidelines_content'.
-  - If the stack is unclear, providing a question in 'clarification_question'.
+Determine the optimal sequence of agents to execute.
+"""
+        
+        return {
+            "system_prompt": system_prompt,
+            "user_prompt": user_prompt
+        }
 
-Return JSON with the following keys:
-- user_needs: String describing what users need from this feature
-- constraints: List of technical or business constraints
-- dependencies: List of external dependencies or requirements
-- risks: List of potential risks or challenges
-- complexity: "low", "medium", or "high". 
-  - "low": Simple changes, no architecture needed.
-  - "medium": Moderate changes, needs proposal but no complex architecture.
-  - "high": Complex changes, needs full architecture and planning.
-- suggested_workflow: "fast_track" (low), "standard" (medium), or "comprehensive" (high)
-- new_guidelines_content: (Optional) Markdown string with best practices if guidelines were missing.
-- clarification_question: (Optional) Question to ask user if tech stack is unclear.
+    @staticmethod
+    def _build_explorer_prompts(context: Dict[str, Any], **kwargs) -> Dict[str, str]:
+        requirements = kwargs.get("requirements", "No requirements provided")
+        
+        system_prompt = """
+You are an AI software architecture analyst called "Analyst (Explorer)".
+
+Your role is to analyze feature requests and produce structured technical analysis for downstream agents.
+
+Responsibilities:
+- Identify user needs
+- Detect constraints
+- List dependencies
+- Identify risks
+- Estimate complexity
+- Suggest workflow
+
+Context may include project information such as technology guidelines.
+
+Guidelines handling:
+- If project_guidelines says "Guidelines not found.", determine the likely technology stack.
+- If the stack is clear, generate new guidelines.
+- If the stack is unclear, ask a clarification question.
+
+Complexity levels:
+- low: simple changes, minimal architecture
+- medium: moderate implementation work
+- high: architectural changes or major system impact
+
+Output rules:
+- Output valid JSON only
+- Do not include explanations outside JSON
+- Follow the schema strictly
+
+Schema:
+{
+  "user_needs": string,
+  "constraints": string[],
+  "dependencies": string[],
+  "risks": string[],
+  "complexity": "low" | "medium" | "high",
+  "suggested_workflow": "fast_track" | "standard" | "comprehensive",
+  "new_guidelines_content": string | null,
+  "clarification_question": string | null
+}
+"""
+        
+        user_prompt = f"""
+Analyze the following feature request: {requirements}
 
-Example format:
-{{
-  "user_needs": "Users need to export data in CSV format for analysis",
-  "constraints": ["Must work with existing authentication", "Limited to 10MB file size"],
-  "dependencies": ["CSV library", "File storage system"],
-  "risks": ["Large datasets may cause performance issues", "Security concerns with file downloads"],
-  "complexity": "medium",
-  "suggested_workflow": "standard"
-}}"""
+Context: {json.dumps(context, default=str)}
+
+Perform the analysis and exploration and return the JSON response.
+"""
         
         return {
             "system_prompt": system_prompt,

{devhive-0.1.18 → devhive-0.1.19}/devhive/core/task_orchestrator.py

@@ -279,6 +279,7 @@ class TaskOrchestrator:
     def _validate_response(self, agent_name: str, response: Dict[str, Any]) -> tuple[bool, str]:
         """Validate response using appropriate validator method."""
         validators = {
+            "CEO": ResponseValidator.validate_ceo,
             "Explorer": ResponseValidator.validate_explorer,
             "Proposal": ResponseValidator.validate_proposal,
             "Architect": ResponseValidator.validate_architect,
@@ -303,6 +304,7 @@ class TaskOrchestrator:
     def _get_artifact_key(self, agent_name: str) -> str:
         """Map agent name to artifact key used in state."""
         mapping = {
+            "CEO": "workflow_plan",
             "Explorer": "exploration",
             "Proposal": "proposal",
             "Architect": "architecture",
@@ -313,7 +315,7 @@ class TaskOrchestrator:
             "Archivist": "archive"
         }
         return mapping.get(agent_name, agent_name.lower())
-    
+
     def _generate_summary(self, agent_name: str, data: Dict[str, Any]) -> str:
         """
         Generate 1-3 sentence executive summary of agent's work.
@@ -322,6 +324,7 @@ class TaskOrchestrator:
         via their generate_summary() method for more specific summaries.
         """
         summaries = {
+            "CEO": self._summarize_ceo,
             "Explorer": self._summarize_explorer,
             "Proposal": self._summarize_proposal,
             "Architect": self._summarize_architect,
@@ -334,7 +337,12 @@ class TaskOrchestrator:
         
         summarizer = summaries.get(agent_name, lambda x: f"{agent_name} completed successfully.")
         return summarizer(data)
-    
+
+    def _summarize_ceo(self, data: Dict[str, Any]) -> str:
+        """Generate summary for CEO agent."""
+        plan = data.get("workflow_plan", [])
+        return f"Planned workflow with {len(plan)} agents: {' -> '.join(plan)}."
+
     def _summarize_explorer(self, data: Dict[str, Any]) -> str:
         """Generate summary for Explorer agent."""
         constraints_count = len(data.get("constraints", []))

{devhive-0.1.18 → devhive-0.1.19}/devhive/server.py

@@ -75,7 +75,7 @@ def devhive_start_pipeline(project_name: str, requirements: str) -> str:
     Returns:
         JSON with Task launch instructions:
         - status: "pending" (next task ready) or "complete" (pipeline done)
-        - agent: Next agent to run (Explorer, Proposal, etc.)
+        - agent: Next agent to run (CEO, Explorer, Proposal, etc.)
         - reason: Why this agent needs to run
         - system_prompt: System prompt for the Task
         - user_prompt: User prompt for the Task
@@ -94,7 +94,7 @@ def devhive_start_pipeline(project_name: str, requirements: str) -> str:
         # Initialize orchestrator (creates project if needed)
         orchestrator = TaskOrchestrator(project_name)
         
-        # Get first task (Explorer)
+        # Get first task (CEO)
         task_info = orchestrator.get_next_task(requirements=requirements)
         
         return json.dumps(task_info, indent=2)
@@ -116,7 +116,7 @@ def devhive_submit_result(project_name: str, agent_name: str, llm_response: str)
     
     Args:
         project_name: Project identifier
-        agent_name: Name of agent that produced result (Explorer, Proposal, Architect,
+        agent_name: Name of agent that produced result (CEO, Explorer, Proposal, Architect,
                    TaskPlanner, Developer, QA, Auditor, or Archivist)
         llm_response: Raw LLM response (JSON string, can include markdown code blocks)
     
@@ -182,7 +182,7 @@ def get_next_step(project_name: str) -> str:
     
     Returns:
         JSON string with:
-        - agent: The agent role name (Explorer, Proposal, etc.)
+        - agent: The agent role name (CEO, Explorer, Proposal, etc.)
         - reason: Why this agent needs to run
         - system_prompt: System prompt to send to LLM
         - user_prompt: User prompt to send to LLM  
@@ -211,9 +211,9 @@ def get_next_step(project_name: str) -> str:
         context = agent.get_context()
         
         # Build prompts using PromptBuilder
-        # For Explorer, we need to check if requirements are in kwargs
-        if agent_role == "Explorer":
-            # Requirements should be provided when executing Explorer
+        # For Explorer/CEO, we need to check if requirements are in kwargs
+        if agent_role in ["Explorer", "CEO"]:
+            # Requirements should be provided when executing
             prompts = PromptBuilder.build_prompts(agent_role, context, requirements="[Requirements will be provided when executing]")
         else:
             prompts = PromptBuilder.build_prompts(agent_role, context)

{devhive-0.1.18 → devhive-0.1.19}/devhive/utils/validation.py

@@ -7,6 +7,28 @@ class ResponseValidator:
     Ensures responses contain required keys and valid data structures.
     """
 
+    @staticmethod
+    def validate_ceo(response: Dict[str, Any]) -> Tuple[bool, str]:
+        """
+        Validate CEO agent response.
+        
+        Expected keys: workflow_plan, reasoning
+        """
+        required_keys = ["workflow_plan", "reasoning"]
+        is_valid, error = ResponseValidator._validate_keys(response, required_keys, "CEO")
+        if not is_valid:
+            return is_valid, error
+            
+        if not isinstance(response.get("workflow_plan"), list):
+            return False, "CEO: 'workflow_plan' must be a list of agent names"
+            
+        valid_agents = ["Explorer", "Proposal", "Architect", "TaskPlanner", "Developer", "QA", "Auditor", "Archivist"]
+        for agent in response["workflow_plan"]:
+            if agent not in valid_agents:
+                return False, f"CEO: Invalid agent name '{agent}' in workflow_plan. Valid agents are: {', '.join(valid_agents)}"
+                
+        return True, ""
+
     @staticmethod
     def validate_explorer(response: Dict[str, Any]) -> Tuple[bool, str]:
         """
@@ -191,6 +213,7 @@ class ResponseValidator:
             List of expected key names
         """
         key_mapping = {
+            "CEO": ["workflow_plan", "reasoning"],
             "Explorer": ["user_needs", "constraints", "dependencies", "risks", "complexity", "suggested_workflow", "new_guidelines_content", "clarification_question"],
             "Proposal": ["feature_description", "user_value", "acceptance_criteria", "scope"],
             "Architect": ["architecture_pattern", "components", "data_models", "apis"],

{devhive-0.1.18 → devhive-0.1.19}/devhive.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devhive
-Version: 0.1.18
+Version: 0.1.19
 Summary: DevHive MCP Server
 Requires-Python: >=3.10
 License-File: LICENSE

{devhive-0.1.18 → devhive-0.1.19}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "devhive"
-version = "0.1.18"
+version = "0.1.19"
 description = "DevHive MCP Server"
 requires-python = ">=3.10"
 

{devhive-0.1.18 → devhive-0.1.19}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="devhive",
-    version="0.1.18",
+    version="0.1.19",
     packages=find_packages(),
     package_data={
         "devhive": ["skills/*.md", "skills/*/*.md"],

devhive-0.1.18/devhive/agents/ceo.py

@@ -1,190 +0,0 @@
-import json
-from typing import Dict, Any
-from mcp.server.fastmcp import Context
-from devhive.agents.base_agent import BaseAgent
-from devhive.core.project_state_manager import ProjectStateManager
-
-class CEOAgent(BaseAgent):
-    role = "CEO"
-    
-    def get_next_agent_deterministic(self) -> Dict[str, Any]:
-        """
-        Determine next agent to run based on current state (no LLM needed).
-        This is a rule-based decision making process following the strict pipeline sequence.
-        
-        Pipeline order:
-        1. Explorer
-        2. Proposal
-        3. Architect
-        4. TaskPlanner
-        5. Developer (Iterative)
-        6. QA
-        7. Auditor
-        8. Archivist
-        
-        Returns:
-            Dict with 'agent' (role name) and 'reason' (explanation)
-        """
-        state = self.state_manager.get_state()
-        artifacts = state.get("artifacts", {})
-        
-        # Check each stage in order
-        if artifacts.get("exploration") is None:
-            return {
-                "agent": "Explorer",
-                "reason": "Need initial feature analysis and exploration"
-            }
-            
-        # Determine complexity from exploration artifact
-        complexity = "high" # Default to high safety
-        try:
-            expl_id = artifacts.get("exploration")
-            if expl_id:
-                expl_data = self.artifact_manager.load_artifact(expl_id)
-                complexity = expl_data.get("complexity", "high").lower()
-        except Exception:
-            pass # Fallback to high complexity on error
-        
-        # Dynamic Routing based on Complexity
-        # Low: Explorer -> Developer -> QA -> Archivist
-        # Medium: Explorer -> Proposal -> Developer -> QA -> Archivist
-        # High: Full Suite
-        
-        if artifacts.get("proposal") is None:
-            if complexity == "low":
-                pass # Skip Proposal
-            else:
-                return {
-                    "agent": "Proposal",
-                    "reason": "Exploration complete, need feature proposal"
-                }
-        
-        if artifacts.get("architecture") is None:
-            if complexity in ["low", "medium"]:
-                pass # Skip Architecture
-            else:
-                return {
-                    "agent": "Architect",
-                    "reason": "Proposal complete, need technical architecture design"
-                }
-        
-        if artifacts.get("tasks") is None:
-            if complexity in ["low", "medium"]:
-                pass # Skip Task Planning
-            else:
-                return {
-                    "agent": "TaskPlanner",
-                    "reason": "Architecture complete, need task breakdown"
-                }
-        
-        if artifacts.get("implementation") is None:
-            # Iterative Developer Workflow
-            dev_progress = state.get("developer_progress", {})
-            pending_tasks = dev_progress.get("pending_tasks", [])
-            completed_tasks = dev_progress.get("completed_tasks", [])
-            
-            # If we haven't initialized developer progress yet, we need to route to developer
-            # Or if there are still pending tasks to complete
-            if not dev_progress or pending_tasks:
-                task_count = len(pending_tasks) if pending_tasks else "tasks"
-                return {
-                    "agent": "Developer",
-                    "reason": f"Need to execute {task_count} pending tasks sequentially"
-                }
-            elif not pending_tasks and completed_tasks:
-                # This state shouldn't normally happen (orchestrator should create implementation artifact)
-                # But just in case, if pending is empty but completed is not, we're done with implementation
-                pass
-            else:
-                # No tasks found at all? Fallback to single run
-                return {
-                    "agent": "Developer",
-                    "reason": "Ready for implementation"
-                }
-        
-        if artifacts.get("tests") is None:
-            return {
-                "agent": "QA",
-                "reason": "Implementation complete, need tests"
-            }
-        
-        if artifacts.get("verification") is None:
-            if complexity in ["low", "medium"]:
-                pass # Skip Auditor
-            else:
-                return {
-                    "agent": "Auditor",
-                    "reason": "Tests complete, need final verification"
-                }
-        
-        if artifacts.get("archive") is None:
-            return {
-                "agent": "Archivist",
-                "reason": "All stages complete, ready to archive project"
-            }
-        
-        # All done
-        return {
-            "agent": "Complete",
-            "reason": "All pipeline stages finished, project is complete"
-        }
-    
-    async def execute(self, ctx: Context, **kwargs) -> Dict[str, Any]:
-        """
-        Original LLM-based decision making (requires sampling support).
-        Currently not used in manual workflow.
-        """
-        state_manager = ProjectStateManager(self.project_name)
-        state = state_manager.get_state()
-
-        context = {
-            "project_status": state.get('status'),
-            "artifacts_summary": state.get("artifacts", {})
-        }
-
-        sys_prompt = """
-        You are the CEO orchestrating an AI software development pipeline.
-
-        The pipeline is strictly sequential:
-
-        1 Explorer
-        2 Proposal
-        3 Architect
-        4 TaskPlanner
-        5 Developer
-        6 QA
-        7 Auditor
-        8 Archivist
-
-        Rules:
-
-        - NEVER return Wait unless the pipeline is finished
-        - ALWAYS select the next missing role
-        - Each role produces an artifact
-
-        Explorer → exploration
-        Proposal → proposal
-        Architect → architecture
-        TaskPlanner → tasks
-        Developer → implementation
-        QA → tests
-        Auditor → verification
-        Archivist → archived
-
-        Return JSON only:
-        { "decision": "Run <Role>", "reason": "..." }
-        """
-        user_prompt = f"""Decide next step.
-
-Project: {context.get('project_name')}
-Status: {context.get('project_status')}
-Stage: {context.get('stage')}
-Artifacts: {json.dumps(context.get('artifacts_summary', {}), indent=2)}
-
-Available Roles: Explorer, Proposal, Architect, TaskPlanner, Developer, QA, Auditor, Archivist.
-Return JSON: {{ "decision": "Run <Role>", "reason": "..." }}
-If finished, "Run Archivist".
-If stage is "initialization", "Run Explorer"
-"""
-        resp = await self._call_llm(ctx, sys_prompt, user_prompt)
-        return self._parse_json(resp)