devhive 0.1.6__py3-none-any.whl

devhive-0.1.6.dist-info/METADATA

@@ -0,0 +1,5 @@
+Metadata-Version: 2.4
+Name: devhive
+Version: 0.1.6
+Summary: DevHive MCP Server
+Requires-Python: >=3.10

devhive-0.1.6.dist-info/RECORD

@@ -0,0 +1,19 @@
+mcp_server/__init__.py,sha256=fZsU_7U8cOD1nFGAGfDkQkbkqTGP6MIfyQu3V_avYWM,21
+mcp_server/cli.py,sha256=dWs1_BnnU6K2I8DCLG-jOyGRyBDP0IC2m1RzLskEa9w,12039
+mcp_server/server.py,sha256=2KpBwiM3fXvj_FhF_S8Cz1P4riGVWMxBFgXCx7v7pNo,28365
+mcp_server/agents/__init__.py,sha256=twIY6ejPe7goNxSg6PmG34uuK_WTRfGnH5qwlODLnY0,508
+mcp_server/agents/architect.py,sha256=RaiTBu14Yaksxsw-J-vrWM3OPwdORgM7qxggta-r1as,1147
+mcp_server/agents/archivist.py,sha256=8WSPLBlsdbXnqJ1DHTTTYvmlJV_NTsXT0UTW36mbiZc,828
+mcp_server/agents/auditor.py,sha256=tmVoEoC_Sgy6xbkBqH655gK8hMnyZz_KdLdo853G984,1244
+mcp_server/agents/base_agent.py,sha256=204h_k95ctt5nfuhdyRREJQqJfChc318dAPsJi6NAS0,3992
+mcp_server/agents/ceo.py,sha256=TNQ4wn6QzMlC17hzT3lzTPTXfsFG_MBZJBplWEE7DaE,5628
+mcp_server/agents/developer.py,sha256=4LfQWnjLARv0K3RGU4lTEi_ITjykrOUPtjwPmZpGpKs,1829
+mcp_server/agents/explorer.py,sha256=YX3MnI_futq812m4UR9RZ8ldV_YUKyCX9edMKI_nvBc,1452
+mcp_server/agents/proposal.py,sha256=45ODWvQaOP8mueZAzdZ9IwLX1c1ayOZU4PRBkOkoXHI,1242
+mcp_server/agents/qa.py,sha256=zEF5TQ-Ll7Dr3g8BOwijp1IvRBJRyJyCtsqITrqBqe0,1850
+mcp_server/agents/task_agent.py,sha256=pLsgnu6CpXgM0Zw4t9imwzQvpx42sDi2RPOXDgwleuE,1151
+devhive-0.1.6.dist-info/METADATA,sha256=8PM2B9c_m3YY4XrjbS6vBGmIFYjeVjJtlV5DsTa21f8,103
+devhive-0.1.6.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+devhive-0.1.6.dist-info/entry_points.txt,sha256=6psqoP5HWwon8SMKeI2Pamsl_jLutNFxUmoV-AtXeyM,85
+devhive-0.1.6.dist-info/top_level.txt,sha256=R49ZBwHkJvJ-AJ8o9wy6MuCs0rvZpyCEuvdwhI4PpHs,11
+devhive-0.1.6.dist-info/RECORD,,

devhive-0.1.6.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

devhive-0.1.6.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+devhive = mcp_server.cli:main
+devhive_mcp = mcp_server.server:main

devhive-0.1.6.dist-info/top_level.txt

@@ -0,0 +1 @@
+mcp_server

mcp_server/__init__.py

@@ -0,0 +1 @@
+# MCP Server Package

mcp_server/agents/__init__.py

@@ -0,0 +1,10 @@
+from mcp_server.agents.base_agent import BaseAgent
+from mcp_server.agents.explorer import ExplorerAgent
+from mcp_server.agents.proposal import ProposalAgent
+from mcp_server.agents.architect import ArchitectAgent
+from mcp_server.agents.task_agent import TaskAgent
+from mcp_server.agents.developer import DeveloperAgent
+from mcp_server.agents.qa import QAAgent
+from mcp_server.agents.auditor import AuditorAgent
+from mcp_server.agents.archivist import ArchivistAgent
+from mcp_server.agents.ceo import CEOAgent

mcp_server/agents/architect.py

@@ -0,0 +1,28 @@
+import json
+from typing import Dict, Any
+from mcp.server.fastmcp import Context
+from mcp_server.agents.base_agent import BaseAgent
+
+class ArchitectAgent(BaseAgent):
+    role = "Architect"
+    
+    async def execute(self, ctx: Context, **kwargs) -> str:
+        context = self.get_context()
+        sys_prompt = "You are the Tech Lead. Output JSON only."
+        user_prompt = f"""Design architecture.
+Context: {json.dumps(context, default=str)}
+Return JSON with keys: architecture_pattern, components, data_models, apis."""
+        
+        resp = await self._call_llm(ctx, sys_prompt, user_prompt)
+        data = self._parse_json(resp)
+        return self.save_artifact("architecture", data)
+    
+    def generate_summary(self, data: Dict[str, Any]) -> str:
+        """Generate executive summary for Architect agent."""
+        components_count = len(data.get("components", []))
+        apis_count = len(data.get("apis", []))
+        pattern = data.get("architecture_pattern", "N/A")
+        return (
+            f"Designed architecture using {pattern} pattern "
+            f"with {components_count} components and {apis_count} APIs."
+        )

mcp_server/agents/archivist.py

@@ -0,0 +1,19 @@
+import json
+from typing import Dict, Any
+from mcp.server.fastmcp import Context
+from mcp_server.agents.base_agent import BaseAgent
+
+class ArchivistAgent(BaseAgent):
+    role = "Archivist"
+    async def execute(self, ctx: Context, **kwargs) -> str:
+        state = self.state_manager.get_state()
+        state["status"] = "completed"
+        if "artifacts" not in state: state["artifacts"] = {}
+        state["artifacts"]["archive"] = "archived"
+        self.state_manager.update_state(state)
+        return "Project Archived Successfully"
+    
+    def generate_summary(self, data: Dict[str, Any]) -> str:
+        """Generate executive summary for Archivist agent."""
+        # Archivist doesn't use structured data, just returns success message
+        return "Project archived successfully. All artifacts and state preserved."

mcp_server/agents/auditor.py

@@ -0,0 +1,28 @@
+import json
+from typing import Dict, Any
+from mcp.server.fastmcp import Context
+from mcp_server.agents.base_agent import BaseAgent
+
+class AuditorAgent(BaseAgent):
+    role = "Auditor"
+    async def execute(self, ctx: Context, **kwargs) -> str:
+        context = self.get_context()
+        sys_prompt = "You are the Auditor. Output JSON only."
+        user_prompt = f"""Verify the project.
+Context: {json.dumps(context, default=str)}
+Return JSON with keys: architecture_consistency (bool), missing_pieces (list), security_risks (list)."""
+        
+        resp = await self._call_llm(ctx, sys_prompt, user_prompt)
+        data = self._parse_json(resp)
+        return self.save_artifact("verification", data)
+    
+    def generate_summary(self, data: Dict[str, Any]) -> str:
+        """Generate executive summary for Auditor agent."""
+        consistent = data.get("architecture_consistency", False)
+        missing_count = len(data.get("missing_pieces", []))
+        security_count = len(data.get("security_risks", []))
+        status = "✓ Passed" if consistent and missing_count == 0 else "⚠ Issues Found"
+        return (
+            f"{status}. Missing pieces: {missing_count}, "
+            f"Security risks: {security_count}"
+        )

mcp_server/agents/base_agent.py

@@ -0,0 +1,104 @@
+import json
+import logging
+from typing import Dict, Any, Optional
+from mcp.types import SamplingMessage, TextContent
+from mcp.server.fastmcp import Context
+from mcp_server.core.project_state_manager import ProjectStateManager
+from mcp_server.core.artifact_manager import ArtifactManager
+from mcp_server.core.context_router import ContextRouter
+from mcp_server.core.llm import LLM
+
+logger = logging.getLogger(__name__)
+
+class BaseAgent:
+    role: str = "Base"
+
+    def __init__(self, project_name: str):
+        self.project_name = project_name
+        self.state_manager = ProjectStateManager(project_name)
+        self.artifact_manager = ArtifactManager(project_name)
+        self.context_router = ContextRouter(self.state_manager, self.artifact_manager)
+
+    def get_context(self) -> Dict[str, Any]:
+        return self.context_router.get_context(self.role)
+
+    def save_artifact(self, step_name: str, content: Dict[str, Any]) -> str:
+        aid = self.artifact_manager.save_artifact(step_name, content)
+        self.state_manager.update_artifact(step_name, aid)
+        return aid
+    
+    def generate_summary(self, data: Dict[str, Any]) -> str:
+        """
+        Generate a 1-3 sentence executive summary of the agent's work.
+        
+        This default implementation provides a basic summary. Subclasses should
+        override this method to provide more specific summaries based on their
+        role and the data they produce.
+        
+        Args:
+            data: The artifact data produced by the agent
+        
+        Returns:
+            A concise 1-3 sentence summary suitable for orchestrator context
+        """
+        return f"{self.role} completed successfully."
+
+    async def _call_llm(self, ctx: Context, system_prompt: str, user_prompt: str, max_tokens: int = 2000)-> str:
+        decision = await LLM.generate_json(
+            ctx,
+            system_prompt,
+            user_prompt
+        )
+        return json.dumps(decision)
+
+
+    async def _call_llm_old(self, ctx: Context, system_prompt: str, user_prompt: str, max_tokens: int = 2000) -> str:
+        """Helper to call LLM via Sampling."""
+        try:
+            messages = [
+                {"role": "user", "content": { "type": "text", "text": f"{system_prompt}\n\n{user_prompt}" }}
+            ]
+            
+            # Using create_message which is standard
+            if hasattr(ctx.session, 'create_message'):
+                try:
+                    result = await ctx.session.create_message(
+                        messages=messages,
+                        max_tokens=max_tokens,
+                        system_prompt=system_prompt
+                    )
+                except:
+                    # Retry with just user prompt if system prompt arg fails
+                    result = await ctx.session.create_message(
+                        messages=messages,
+                        max_tokens=max_tokens
+                    )
+
+                if hasattr(result, 'content') and hasattr(result.content, 'text'):
+                    return result.content.text
+                return str(result)
+            
+            # Fallback
+            if hasattr(ctx.session, 'sample'):
+                 return str(await ctx.session.sample(messages=messages, max_tokens=max_tokens))
+            
+            return '{"error": "No sampling capability found on session"}'
+
+        except Exception as e:
+            logger.error(f"LLM Call failed: {e}")
+            return json.dumps({"error": str(e)})
+
+    def _parse_json(self, text: str) -> Dict[str, Any]:
+        """ Robust JSON parser """
+        text = text.strip()
+        if "```json" in text:
+            text = text.split("```json")[1].split("```")[0]
+        elif "```" in text:
+            text = text.split("```")[1].split("```")[0]
+        try:
+            return json.loads(text)
+        except:
+            return {"raw_text": text}
+
+    async def execute(self, ctx: Context, **kwargs) -> Any:
+        raise NotImplementedError

mcp_server/agents/ceo.py

@@ -0,0 +1,171 @@
+import json
+from typing import Dict, Any
+from mcp.server.fastmcp import Context
+from mcp_server.agents.base_agent import BaseAgent
+from mcp_server.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
+        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:
+            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)

mcp_server/agents/developer.py

@@ -0,0 +1,44 @@
+import json
+from typing import Dict, Any
+from mcp.server.fastmcp import Context
+from mcp_server.agents.base_agent import BaseAgent
+
+class DeveloperAgent(BaseAgent):
+    role = "Developer"
+    
+    def write_files(self, data: Dict[str, Any]) -> list[str]:
+        """Write implementation files to disk. Returns list of file paths."""
+        files = data.get("files", [])
+        from mcp_server.utils.filesystem import write_file
+        file_paths = []
+        for f in files:
+            if isinstance(f, dict) and "path" in f and "content" in f:
+                write_file(f["path"], f["content"])
+                file_paths.append(f["path"])
+        return file_paths
+    
+    async def execute(self, ctx: Context, **kwargs) -> str:
+        context = self.get_context()
+        sys_prompt = "You are the Developer. Output JSON only."
+        user_prompt = f"""Implement the feature.
+Context: {json.dumps(context, default=str)}
+Return JSON with keys: implementation_strategy, file_structure, pseudocode, files (list of {{path, content}})."""
+        
+        resp = await self._call_llm(ctx, sys_prompt, user_prompt, max_tokens=4000)
+        data = self._parse_json(resp)
+        
+        # Write files (using extracted method)
+        file_paths = self.write_files(data)
+        self.state_manager.add_files(file_paths)
+        return self.save_artifact("implementation", data)
+    
+    def generate_summary(self, data: Dict[str, Any]) -> str:
+        """Generate executive summary for Developer agent."""
+        files_count = len(data.get("files", []))
+        strategy = data.get("implementation_strategy", "N/A")
+        # Truncate if too long
+        if len(strategy) > 80:
+            strategy = strategy[:80] + "..."
+        return (
+            f"Implemented {files_count} files using strategy: {strategy}"
+        )

mcp_server/agents/explorer.py

@@ -0,0 +1,36 @@
+import json
+from typing import Dict, Any
+from mcp.server.fastmcp import Context
+from mcp_server.agents.base_agent import BaseAgent
+
+class ExplorerAgent(BaseAgent):
+    role = "Explorer"
+    
+    async def execute(self, ctx: Context, **kwargs) -> str:
+        requirements = kwargs.get("requirements", "")
+        context = self.get_context()
+        sys_prompt = """
+        You are the Analyst (Explorer). Remember always read AGENTS.md or GUIDELINES.md if exists. 
+        
+        Output JSON only.
+        """
+        user_prompt = f"""Analyze: {requirements}
+Context: {json.dumps(context, default=str)}
+Return JSON with keys: user_needs, constraints, dependencies, risks."""
+        
+        resp = await self._call_llm(ctx, sys_prompt, user_prompt)
+        data = self._parse_json(resp)
+        return self.save_artifact("exploration", data)
+    
+    def generate_summary(self, data: Dict[str, Any]) -> str:
+        """Generate executive summary for Explorer agent."""
+        constraints_count = len(data.get("constraints", []))
+        deps_count = len(data.get("dependencies", []))
+        user_needs = data.get("user_needs", "N/A")
+        # Truncate user_needs if too long
+        if len(user_needs) > 80:
+            user_needs = user_needs[:80] + "..."
+        return (
+            f"Analyzed requirements and identified {constraints_count} constraints "
+            f"and {deps_count} dependencies. Key user need: {user_needs}"
+        )

mcp_server/agents/proposal.py

@@ -0,0 +1,30 @@
+import json
+from typing import Dict, Any
+from mcp.server.fastmcp import Context
+from mcp_server.agents.base_agent import BaseAgent
+
+class ProposalAgent(BaseAgent):
+    role = "Proposal"
+    
+    async def execute(self, ctx: Context, **kwargs) -> str:
+        context = self.get_context()
+        sys_prompt = "You are the Product Manager. Output JSON only."
+        user_prompt = f"""Create proposal based on exploration.
+Context: {json.dumps(context, default=str)}
+Return JSON with keys: feature_description, user_value, acceptance_criteria, scope."""
+        
+        resp = await self._call_llm(ctx, sys_prompt, user_prompt)
+        data = self._parse_json(resp)
+        return self.save_artifact("proposal", data)
+    
+    def generate_summary(self, data: Dict[str, Any]) -> str:
+        """Generate executive summary for Proposal agent."""
+        criteria_count = len(data.get("acceptance_criteria", []))
+        feature_desc = data.get("feature_description", "N/A")
+        # Truncate if too long
+        if len(feature_desc) > 80:
+            feature_desc = feature_desc[:80] + "..."
+        return (
+            f"Created feature proposal with {criteria_count} acceptance criteria. "
+            f"Feature: {feature_desc}"
+        )

mcp_server/agents/qa.py

@@ -0,0 +1,46 @@
+import json
+from typing import Dict, Any
+from mcp.server.fastmcp import Context
+from mcp_server.agents.base_agent import BaseAgent
+
+class QAAgent(BaseAgent):
+    role = "QA"
+    
+    def write_test_files(self, data: Dict[str, Any]) -> list[str]:
+        """Write test files to disk. Returns list of file paths."""
+        files = data.get("files", [])
+        from mcp_server.utils.filesystem import write_file
+        file_paths = []
+        for f in files:
+            if isinstance(f, dict) and "path" in f and "content" in f:
+                write_file(f["path"], f["content"])
+                file_paths.append(f["path"])
+        return file_paths
+    
+    async def execute(self, ctx: Context, **kwargs) -> str:
+        context = self.get_context()
+        sys_prompt = "You are QA. Output JSON only."
+        user_prompt = f"""Generate tests.
+Context: {json.dumps(context, default=str)}
+Return JSON with keys: test_strategy, unit_tests, validation_plan, files (list of {{path, content}})."""
+        
+        resp = await self._call_llm(ctx, sys_prompt, user_prompt)
+        data = self._parse_json(resp)
+        
+        # Write test files (using extracted method)
+        file_paths = self.write_test_files(data)
+        self.state_manager.add_files(file_paths)
+        return self.save_artifact("tests", data)
+    
+    def generate_summary(self, data: Dict[str, Any]) -> str:
+        """Generate executive summary for QA agent."""
+        tests_count = len(data.get("unit_tests", []))
+        files_count = len(data.get("files", []))
+        strategy = data.get("test_strategy", "N/A")
+        # Truncate if too long
+        if len(strategy) > 60:
+            strategy = strategy[:60] + "..."
+        return (
+            f"Generated {tests_count} unit tests across {files_count} test files. "
+            f"Strategy: {strategy}"
+        )

mcp_server/agents/task_agent.py

@@ -0,0 +1,27 @@
+import json
+from typing import Dict, Any
+from mcp.server.fastmcp import Context
+from mcp_server.agents.base_agent import BaseAgent
+
+class TaskAgent(BaseAgent):
+    role = "TaskPlanner"
+    async def execute(self, ctx: Context, **kwargs) -> str:
+        context = self.get_context()
+        sys_prompt = "You are the Scrum Master. Output JSON only."
+        user_prompt = f"""Break down tasks.
+Context: {json.dumps(context, default=str)}
+Return JSON with keys: epics, tasks (list of dicts), estimated_complexity."""
+        
+        resp = await self._call_llm(ctx, sys_prompt, user_prompt)
+        data = self._parse_json(resp)
+        return self.save_artifact("tasks", data)
+    
+    def generate_summary(self, data: Dict[str, Any]) -> str:
+        """Generate executive summary for TaskPlanner agent."""
+        tasks_count = len(data.get("tasks", []))
+        complexity = data.get("estimated_complexity", "N/A")
+        epics_count = len(data.get("epics", [])) if isinstance(data.get("epics"), list) else 0
+        return (
+            f"Created {tasks_count} tasks across {epics_count} epics. "
+            f"Complexity: {complexity}"
+        )