hanzo-mcp 0.8.8__py3-none-any.whl → 0.8.13__py3-none-any.whl

hanzo_mcp/tools/agent/iching_tool.py

@@ -423,17 +423,13 @@ class IChing:
                 lines += "1"
         return Hexagram(lines)
 
-    def select_principles(
-        self, hexagram: Hexagram, challenge: str
-    ) -> List[HanzoPrinciple]:
+    def select_principles(self, hexagram: Hexagram, challenge: str) -> List[HanzoPrinciple]:
         """Select relevant Hanzo principles based on hexagram and challenge."""
         # Use hexagram pattern to deterministically but creatively select principles
         selected = []
 
         # Primary principle based on hexagram pattern
-        primary_index = sum(
-            int(bit) * (2**i) for i, bit in enumerate(hexagram.lines)
-        ) % len(self.principles)
+        primary_index = sum(int(bit) * (2**i) for i, bit in enumerate(hexagram.lines)) % len(self.principles)
         selected.append(self.principles[primary_index])
 
         # Supporting principles based on challenge keywords
@@ -458,9 +454,7 @@ class IChing:
         # Add complementary principle based on changing lines
         changing_lines = hexagram.get_changing_lines()
         if changing_lines:
-            complement_index = (primary_index + sum(changing_lines)) % len(
-                self.principles
-            )
+            complement_index = (primary_index + sum(changing_lines)) % len(self.principles)
             selected.append(self.principles[complement_index])
 
         # Ensure uniqueness and limit to 3-5 principles
@@ -473,9 +467,7 @@ class IChing:
 
         return unique_selected[:5]
 
-    def generate_guidance(
-        self, hexagram: Hexagram, principles: List[HanzoPrinciple], challenge: str
-    ) -> str:
+    def generate_guidance(self, hexagram: Hexagram, principles: List[HanzoPrinciple], challenge: str) -> str:
         """Generate creative guidance combining I Ching wisdom and Hanzo principles."""
         guidance = f"☯️ I CHING GUIDANCE FOR ENGINEERING CHALLENGE ☯️\n\n"
         guidance += f"**Your Challenge:** {challenge}\n\n"
@@ -498,21 +490,15 @@ class IChing:
         if "Creative" in hexagram.title:
             guidance += "• This is a time for bold innovation. Don't hold back on ambitious ideas.\n"
         elif "Receptive" in hexagram.title:
-            guidance += (
-                "• Listen deeply to user needs and system constraints before acting.\n"
-            )
+            guidance += "• Listen deeply to user needs and system constraints before acting.\n"
         elif "Difficulty" in hexagram.title:
-            guidance += (
-                "• Challenges are teachers. Each obstacle reveals the path forward.\n"
-            )
+            guidance += "• Challenges are teachers. Each obstacle reveals the path forward.\n"
         elif "Waiting" in hexagram.title:
             guidance += "• Strategic patience required. Prepare thoroughly before implementation.\n"
         elif "Conflict" in hexagram.title:
             guidance += "• Technical disagreements? Seek data-driven resolution.\n"
         elif "Peace" in hexagram.title:
-            guidance += (
-                "• Harmony achieved. Now build sustainably on this foundation.\n"
-            )
+            guidance += "• Harmony achieved. Now build sustainably on this foundation.\n"
 
         # Principle-specific actionable advice
         principle_actions = {
@@ -534,9 +520,7 @@ class IChing:
         changing_lines = hexagram.get_changing_lines()
         if changing_lines:
             guidance += f"\n**Lines in Transition:** {', '.join(str(i + 1) for i in changing_lines)}\n"
-            guidance += (
-                "• Change is imminent in these areas. Prepare for transformation.\n"
-            )
+            guidance += "• Change is imminent in these areas. Prepare for transformation.\n"
 
         # Final synthesis
         guidance += "\n**The Way Forward:**\n"
@@ -547,9 +531,7 @@ class IChing:
 
         return guidance
 
-    def _synthesize_action_plan(
-        self, hexagram: Hexagram, principles: List[HanzoPrinciple], challenge: str
-    ) -> str:
+    def _synthesize_action_plan(self, hexagram: Hexagram, principles: List[HanzoPrinciple], challenge: str) -> str:
         """Create a specific action plan based on the reading."""
         plan = ""
 
@@ -558,21 +540,15 @@ class IChing:
             plan += "1. **Diagnose systematically** - Use empirical debugging, not guesswork\n"
             plan += "2. **Fix root cause** - Address the source, not just symptoms\n"
             plan += "3. **Prevent recurrence** - Add tests and monitoring\n"
-        elif any(
-            word in challenge.lower() for word in ["scale", "performance", "slow"]
-        ):
+        elif any(word in challenge.lower() for word in ["scale", "performance", "slow"]):
             plan += "1. **Measure first** - Profile to find actual bottlenecks\n"
             plan += "2. **Parallelize** - Use concurrency where possible\n"
             plan += "3. **Simplify** - Remove complexity before optimizing\n"
-        elif any(
-            word in challenge.lower() for word in ["design", "architect", "structure"]
-        ):
+        elif any(word in challenge.lower() for word in ["design", "architect", "structure"]):
             plan += "1. **Start simple** - MVP first, elaborate later\n"
             plan += "2. **Stay flexible** - Design for change\n"
             plan += "3. **Think holistically** - Consider entire system\n"
-        elif any(
-            word in challenge.lower() for word in ["team", "collaborate", "people"]
-        ):
+        elif any(word in challenge.lower() for word in ["team", "collaborate", "people"]):
             plan += "1. **Enable autonomy** - Trust your team\n"
             plan += "2. **Maintain balance** - Sustainable pace wins\n"
             plan += "3. **Share knowledge** - Elevate everyone\n"

hanzo_mcp/tools/agent/network_tool.py

@@ -77,9 +77,7 @@ class NetworkTool(BaseTool):
         """
         self.permission_manager = permission_manager
         self.default_mode = default_mode
-        self.cluster_endpoint = cluster_endpoint or os.environ.get(
-            "HANZO_CLUSTER_ENDPOINT", "http://localhost:8000"
-        )
+        self.cluster_endpoint = cluster_endpoint or os.environ.get("HANZO_CLUSTER_ENDPOINT", "http://localhost:8000")
         self._cluster = None
 
     async def _ensure_cluster(self):
@@ -160,9 +158,7 @@ class NetworkTool(BaseTool):
                         results["results"].append(
                             {
                                 "agent": "local-cluster",
-                                "response": local_result.get("choices", [{}])[0].get(
-                                    "text", ""
-                                ),
+                                "response": local_result.get("choices", [{}])[0].get("text", ""),
                                 "local": True,
                             }
                         )
@@ -180,6 +176,7 @@ class NetworkTool(BaseTool):
                 # Agent-based execution with concurrency
                 if not results["success"] or mode in ["distributed", "hybrid"]:
                     from hanzo_mcp.tools.agent.agent_tool import AgentTool
+
                     agent = AgentTool(permission_manager=self.permission_manager, model=model_pref)
                     concurrency = max(1, len(agents_list)) if agents_list else 5 if routing == "parallel" else 1
                     agent_params = {"prompts": task, "concurrency": concurrency}
@@ -206,25 +203,17 @@ class NetworkTool(BaseTool):
         async def network_handler(
             ctx: MCPContext,
             task: Annotated[str, Field(description="Task to execute on the network")],
-            agents: Annotated[
-                Optional[List[str]], Field(description="Specific agents to use")
-            ] = None,
+            agents: Annotated[Optional[List[str]], Field(description="Specific agents to use")] = None,
             mode: Annotated[
                 Optional[str],
                 Field(description="Execution mode: local, distributed, or hybrid"),
             ] = None,
-            model: Annotated[
-                Optional[str], Field(description="Model preference")
-            ] = None,
+            model: Annotated[Optional[str], Field(description="Model preference")] = None,
             routing: Annotated[
                 Optional[str],
-                Field(
-                    description="Routing strategy: sequential, parallel, or consensus"
-                ),
-            ] = None,
-            require_local: Annotated[
-                Optional[bool], Field(description="Require local-only execution")
+                Field(description="Routing strategy: sequential, parallel, or consensus"),
             ] = None,
+            require_local: Annotated[Optional[bool], Field(description="Require local-only execution")] = None,
         ) -> str:
             """Dispatch work to agent networks."""
             params = NetworkToolParams(

hanzo_mcp/tools/agent/prompt.py

@@ -139,11 +139,7 @@ def get_default_model(model_override: str | None = None) -> str:
     model = os.environ.get("AGENT_MODEL", "claude-3-5-sonnet-20241022")
 
     # Special cases for tests
-    if (
-        model.startswith("test-model")
-        or "TEST_MODE" in os.environ
-        and model == "claude-3-5-sonnet-20241022"
-    ):
+    if model.startswith("test-model") or "TEST_MODE" in os.environ and model == "claude-3-5-sonnet-20241022":
         return model
 
     provider = os.environ.get("AGENT_PROVIDER", "anthropic")

hanzo_mcp/tools/agent/review_tool.py

@@ -83,9 +83,7 @@ review(
             file_paths: Optional[List[str]] = None,
             context: Optional[str] = None,
         ) -> str:
-            return await tool_self.call(
-                ctx, focus, work_description, code_snippets, file_paths, context
-            )
+            return await tool_self.call(ctx, focus, work_description, code_snippets, file_paths, context)
 
 
 class BalancedReviewer:
@@ -210,23 +208,18 @@ class BalancedReviewer:
 
         if code_snippets:
             total_lines = sum(snippet.count("\n") + 1 for snippet in code_snippets)
-            avg_line_length = sum(
-                len(line) for snippet in code_snippets for line in snippet.split("\n")
-            ) / max(total_lines, 1)
+            avg_line_length = sum(len(line) for snippet in code_snippets for line in snippet.split("\n")) / max(
+                total_lines, 1
+            )
 
             if avg_line_length < 80:
                 response += "✓ Line lengths are reasonable\n"
             else:
-                response += (
-                    "• Some lines might be too long, consider breaking them up\n"
-                )
+                response += "• Some lines might be too long, consider breaking them up\n"
 
             # Check naming
             has_good_names = any(
-                any(
-                    word in snippet
-                    for word in ["Add", "Get", "Set", "Create", "Update", "Delete"]
-                )
+                any(word in snippet for word in ["Add", "Get", "Set", "Create", "Update", "Delete"])
                 for snippet in code_snippets
             )
             if has_good_names:
@@ -264,10 +257,7 @@ class BalancedReviewer:
         # Check for modularity in code
         if code_snippets:
             function_count = sum(
-                snippet.count("func ")
-                + snippet.count("def ")
-                + snippet.count("function ")
-                for snippet in code_snippets
+                snippet.count("func ") + snippet.count("def ") + snippet.count("function ") for snippet in code_snippets
             )
             if function_count > 0:
                 response += "✓ Code is broken into functions/methods\n"
@@ -334,8 +324,7 @@ class BalancedReviewer:
         has_comments = False
         if code_snippets:
             has_comments = any(
-                "//" in snippet or "/*" in snippet or "#" in snippet or '"""' in snippet
-                for snippet in code_snippets
+                "//" in snippet or "/*" in snippet or "#" in snippet or '"""' in snippet for snippet in code_snippets
             )
 
         if has_comments:
@@ -372,9 +361,7 @@ class BalancedReviewer:
         # Analyze file structure
         if file_paths:
             # Check for separation of concerns
-            has_separation = (
-                len(set(str(p).split("/")[-2] for p in file_paths if "/" in str(p))) > 1
-            )
+            has_separation = len(set(str(p).split("/")[-2] for p in file_paths if "/" in str(p))) > 1
             if has_separation:
                 response += "✓ Changes span multiple modules (good separation)\n"
             else:
@@ -426,9 +413,7 @@ class ReviewProtocol:
         except KeyError:
             focus_enum = ReviewFocus.GENERAL
 
-        review = self.reviewer.review(
-            focus_enum, work_description, code_snippets, file_paths, context
-        )
+        review = self.reviewer.review(focus_enum, work_description, code_snippets, file_paths, context)
 
         header = f"Review {self.review_count}/{self.max_reviews} (Focus: {focus_enum.value}):\n\n"
         footer = "\n\n💡 This is a balanced review - consider both strengths and suggestions."

hanzo_mcp/tools/agent/swarm_alias.py

@@ -61,9 +61,7 @@ For new code, prefer using 'network' directly."""
             **kwargs: Additional arguments passed to NetworkTool
         """
         # Just pass through to NetworkTool
-        super().__init__(
-            permission_manager=permission_manager, default_mode=default_mode, **kwargs
-        )
+        super().__init__(permission_manager=permission_manager, default_mode=default_mode, **kwargs)
 
     async def call(self, **kwargs) -> str:
         """Execute swarm via network tool.

hanzo_mcp/tools/agent/swarm_tool.py

@@ -96,14 +96,12 @@ except ImportError:
         # Try core module import
         from hanzo_agents.core.memory import create_memory_kv, create_memory_vector
     except ImportError:
-        # Define fallback functions if not available
+        # Define stubs if not available
         def create_memory_kv(*args, **kwargs):
-            """Fallback: Key-value memory not available."""
-            return {}
+            pass
 
         def create_memory_vector(*args, **kwargs):
-            """Fallback: Vector memory not available."""
-            return {}
+            pass
 
 
 try:
@@ -117,18 +115,15 @@ except ImportError:
             state_based_router,
         )
     except ImportError:
-        # Define fallback functions if not available
+        # Define stubs if not available
         def sequential_router(*args, **kwargs):
-            """Fallback: Sequential router not available."""
-            return lambda agents, task: None
+            pass
 
         def conditional_router(*args, **kwargs):
-            """Fallback: Conditional router not available."""
-            return lambda agents, task: None
+            pass
 
         def state_based_router(*args, **kwargs):
-            """Fallback: State-based router not available."""
-            return lambda agents, task: None
+            pass
 
 
 try:
@@ -196,9 +191,7 @@ class SwarmToolParams(TypedDict):
 class SwarmState(State):
     """State for swarm execution."""
 
-    def __init__(
-        self, config: SwarmConfig, initial_query: str, context: Optional[str] = None
-    ):
+    def __init__(self, config: SwarmConfig, initial_query: str, context: Optional[str] = None):
         """Initialize swarm state."""
         super().__init__()
         self.config = config
@@ -299,9 +292,7 @@ class SwarmAgent(MCPAgent):
         # Default to anthropic
         return f"model://anthropic/{model}"
 
-    async def run(
-        self, state: SwarmState, history: History, network: Network
-    ) -> InferenceResult:
+    async def run(self, state: SwarmState, history: History, network: Network) -> InferenceResult:
         """Execute the swarm agent."""
         # Build prompt with context
         prompt_parts = []
@@ -423,9 +414,7 @@ class SwarmRouter(DeterministicRouter):
         # No more agents to execute
         return None
 
-    def _get_agent_class(
-        self, agent_id: str, agent_stack: List[type[Agent]]
-    ) -> type[Agent]:
+    def _get_agent_class(self, agent_id: str, agent_stack: List[type[Agent]]) -> type[Agent]:
         """Get agent class for given agent ID."""
         # Find matching agent by name
         for agent_class in agent_stack:
@@ -500,11 +489,7 @@ Models can be specified as:
         from hanzo_mcp.tools.agent.code_auth import get_latest_claude_model
 
         self.model = model or f"anthropic/{get_latest_claude_model()}"
-        self.api_key = (
-            api_key
-            or os.environ.get("ANTHROPIC_API_KEY")
-            or os.environ.get("CLAUDE_API_KEY")
-        )
+        self.api_key = api_key or os.environ.get("ANTHROPIC_API_KEY") or os.environ.get("CLAUDE_API_KEY")
         self.base_url = base_url
         self.max_tokens = max_tokens
         self.agent_max_iterations = agent_max_iterations
@@ -512,21 +497,15 @@ Models can be specified as:
 
         # Set up available tools for agents
         self.available_tools: list[BaseTool] = []
-        self.available_tools.extend(
-            get_read_only_filesystem_tools(self.permission_manager)
-        )
-        self.available_tools.extend(
-            get_read_only_jupyter_tools(self.permission_manager)
-        )
+        self.available_tools.extend(get_read_only_filesystem_tools(self.permission_manager))
+        self.available_tools.extend(get_read_only_jupyter_tools(self.permission_manager))
 
         # Add edit tools
         self.available_tools.append(Edit(self.permission_manager))
         self.available_tools.append(MultiEdit(self.permission_manager))
 
         # Add batch tool
-        self.available_tools.append(
-            BatchTool({t.name: t for t in self.available_tools})
-        )
+        self.available_tools.append(BatchTool({t.name: t for t in self.available_tools}))
 
     @override
     async def call(
@@ -554,9 +533,7 @@ Models can be specified as:
 
         # hanzo-agents SDK is required (already imported above)
 
-        await tool_ctx.info(
-            f"Starting swarm execution with {len(agents_config)} agents using hanzo-agents SDK"
-        )
+        await tool_ctx.info(f"Starting swarm execution with {len(agents_config)} agents using hanzo-agents SDK")
 
         # Create state
         state = SwarmState(config=config, initial_query=initial_query, context=context)
@@ -653,9 +630,7 @@ Models can be specified as:
         output.append("=" * 80)
         output.append(f"Total agents: {len(agents_config)}")
         output.append(f"Completed: {len(results)}")
-        output.append(
-            f"Failed: {len([r for r in results.values() if r.startswith('Error:')])}"
-        )
+        output.append(f"Failed: {len([r for r in results.values() if r.startswith('Error:')])}")
 
         if entry_point:
             output.append(f"Entry point: {entry_point}")

hanzo_mcp/tools/agent/swarm_tool_v1_deprecated.py

@@ -196,11 +196,7 @@ Models can be specified as:
         from hanzo_mcp.tools.agent.code_auth import get_latest_claude_model
 
         self.model = model or f"anthropic/{get_latest_claude_model()}"
-        self.api_key = (
-            api_key
-            or os.environ.get("ANTHROPIC_API_KEY")
-            or os.environ.get("CLAUDE_API_KEY")
-        )
+        self.api_key = api_key or os.environ.get("ANTHROPIC_API_KEY") or os.environ.get("CLAUDE_API_KEY")
         self.base_url = base_url
         self.max_tokens = max_tokens
         self.agent_max_iterations = agent_max_iterations
@@ -243,9 +239,7 @@ Models can be specified as:
         agents_config = config.get("agents", {})
         entry_point = config.get("entry_point")
 
-        await tool_ctx.info(
-            f"Starting swarm execution with {len(agents_config)} agents"
-        )
+        await tool_ctx.info(f"Starting swarm execution with {len(agents_config)} agents")
 
         # Build agent network
         agent_instances = {}
@@ -292,10 +286,7 @@ Models can be specified as:
                     # Check if any other agent connects to this one
                     has_incoming = False
                     for other_config in agents_config.values():
-                        if (
-                            other_config.get("connections")
-                            and agent_id in other_config["connections"]
-                        ):
+                        if other_config.get("connections") and agent_id in other_config["connections"]:
                             has_incoming = True
                             break
                     if not has_incoming:
@@ -309,18 +300,14 @@ Models can be specified as:
                 await execution_queue.put((root, initial_query, {}))
 
         # Execute agents in network order
-        async def execute_agent(
-            agent_id: str, query: str, inputs: Dict[str, str]
-        ) -> str:
+        async def execute_agent(agent_id: str, query: str, inputs: Dict[str, str]) -> str:
             """Execute a single agent in the network."""
             async with semaphore:
                 try:
                     agent_config = agents_config[agent_id]
                     agent = agent_instances[agent_id]
 
-                    await tool_ctx.info(
-                        f"Executing agent: {agent_id} ({agent_config.get('role', 'Agent')})"
-                    )
+                    await tool_ctx.info(f"Executing agent: {agent_id} ({agent_config.get('role', 'Agent')})")
 
                     # Build prompt with context and inputs
                     prompt_parts = []
@@ -337,15 +324,11 @@ Models can be specified as:
                     if inputs:
                         prompt_parts.append("Input from previous agents:")
                         for input_agent, input_result in inputs.items():
-                            prompt_parts.append(
-                                f"\n--- From {input_agent} ---\n{input_result}"
-                            )
+                            prompt_parts.append(f"\n--- From {input_agent} ---\n{input_result}")
 
                     # Add file context if specified
                     if agent_config.get("file_path"):
-                        prompt_parts.append(
-                            f"\nFile to work on: {agent_config['file_path']}"
-                        )
+                        prompt_parts.append(f"\nFile to work on: {agent_config['file_path']}")
 
                     # Add the main query
                     prompt_parts.append(f"\nTask: {agent_config['query']}")
@@ -393,9 +376,7 @@ Models can be specified as:
 
                     if ready:
                         # Execute agent
-                        task = asyncio.create_task(
-                            execute_agent(agent_id, query, inputs)
-                        )
+                        task = asyncio.create_task(execute_agent(agent_id, query, inputs))
                         running_tasks.add(task)
 
                         async def handle_completion(task, agent_id=agent_id):
@@ -409,9 +390,7 @@ Models can be specified as:
                             connections = agent_config.get("connections", [])
                             for next_agent in connections:
                                 if next_agent in agents_config:
-                                    await execution_queue.put(
-                                        (next_agent, "", {agent_id: result})
-                                    )
+                                    await execution_queue.put((next_agent, "", {agent_id: result}))
 
                         asyncio.create_task(handle_completion(task))
 
@@ -470,9 +449,7 @@ Models can be specified as:
         output.append("=" * 80)
         output.append(f"Total agents: {len(agents_config)}")
         output.append(f"Completed: {len(results)}")
-        output.append(
-            f"Failed: {len([r for r in results.values() if r.startswith('Error:')])}"
-        )
+        output.append(f"Failed: {len([r for r in results.values() if r.startswith('Error:')])}")
 
         if entry_point:
             output.append(f"Entry point: {entry_point}")
@@ -490,12 +467,7 @@ Models can be specified as:
                 role = config.get("role", "Agent")
                 model = config.get("model", "default")
 
-                status = (
-                    "✅"
-                    if agent_id in results
-                    and not results[agent_id].startswith("Error:")
-                    else "❌"
-                )
+                status = "✅" if agent_id in results and not results[agent_id].startswith("Error:") else "❌"
                 lines.append(f"{indent}{status} {agent_id} ({role}) [{model}]")
 
                 # Show connections