hanzo-mcp 0.7.6__py3-none-any.whl → 0.8.0__py3-none-any.whl

hanzo_mcp/tools/agent/code_auth_tool.py

@@ -3,10 +3,10 @@
 This tool manages API keys and accounts for Claude Code and other AI coding tools.
 """
 
-from typing import Annotated, Optional, TypedDict, Unpack, final, override
+from typing import Unpack, Optional, TypedDict, final, override
+
 from mcp.server import FastMCP
 from mcp.server.fastmcp import Context as MCPContext
-from pydantic import Field
 
 from hanzo_mcp.tools.common.base import BaseTool
 from hanzo_mcp.tools.common.context import create_tool_context
@@ -15,6 +15,7 @@ from hanzo_mcp.tools.agent.code_auth import CodeAuthManager
 
 class CodeAuthParams(TypedDict, total=False):
     """Parameters for code auth tool."""
+
     action: str
     account: Optional[str]
     provider: Optional[str]
@@ -28,13 +29,13 @@ class CodeAuthParams(TypedDict, total=False):
 @final
 class CodeAuthTool(BaseTool):
     """Tool for managing Claude Code authentication and API keys."""
-    
+
     @property
     @override
     def name(self) -> str:
         """Get the tool name."""
         return "code_auth"
-    
+
     @property
     @override
     def description(self) -> str:
@@ -60,11 +61,11 @@ code_auth switch --account personal
 code_auth agent --agent_id swarm_1 --parent_account work
 
 Providers: claude, openai, azure, deepseek, google, groq"""
-    
+
     def __init__(self):
         """Initialize the code auth tool."""
         self.auth_manager = CodeAuthManager()
-    
+
     @override
     async def call(
         self,
@@ -72,19 +73,19 @@ Providers: claude, openai, azure, deepseek, google, groq"""
         **params: Unpack[CodeAuthParams],
     ) -> str:
         """Execute the code auth tool.
-        
+
         Args:
             ctx: MCP context
             **params: Tool parameters
-            
+
         Returns:
             Result message
         """
         tool_ctx = create_tool_context(ctx)
         await tool_ctx.set_tool_info(self.name)
-        
+
         action = params.get("action", "status")
-        
+
         if action == "status":
             current = self.auth_manager.get_active_account()
             if current:
@@ -92,12 +93,12 @@ Providers: claude, openai, azure, deepseek, google, groq"""
                 if info:
                     return f"Logged in as: {current} ({info['provider']})"
             return "Not logged in"
-        
+
         elif action == "list":
             accounts = self.auth_manager.list_accounts()
             if not accounts:
                 return "No accounts configured"
-            
+
             current = self.auth_manager.get_active_account()
             lines = ["Configured accounts:"]
             for account in accounts:
@@ -105,52 +106,52 @@ Providers: claude, openai, azure, deepseek, google, groq"""
                 marker = " (active)" if account == current else ""
                 lines.append(f"  - {account}: {info['provider']}{marker}")
             return "\n".join(lines)
-        
+
         elif action == "create":
             account = params.get("account")
             if not account:
                 return "Error: account name required"
-            
+
             provider = params.get("provider", "claude")
             api_key = params.get("api_key")
             model = params.get("model")
             description = params.get("description")
-            
+
             success, msg = self.auth_manager.create_account(
                 account, provider, api_key, model, description
             )
             return msg
-        
+
         elif action == "login":
             account = params.get("account", "default")
             success, msg = self.auth_manager.login(account)
             return msg
-        
+
         elif action == "logout":
             success, msg = self.auth_manager.logout()
             return msg
-        
+
         elif action == "switch":
             account = params.get("account")
             if not account:
                 return "Error: account name required"
-            
+
             success, msg = self.auth_manager.switch_account(account)
             return msg
-        
+
         elif action == "agent":
             agent_id = params.get("agent_id")
             if not agent_id:
                 return "Error: agent_id required"
-            
+
             provider = params.get("provider", "claude")
             parent_account = params.get("parent_account")
-            
+
             # Try to create agent account
             success, result = self.auth_manager.create_agent_account(
                 agent_id, provider, parent_account
             )
-            
+
             if success:
                 # Get credentials
                 creds = self.auth_manager.get_agent_credentials(agent_id)
@@ -160,15 +161,15 @@ Providers: claude, openai, azure, deepseek, google, groq"""
                     return f"Agent account created but no credentials: {result}"
             else:
                 return f"Failed to create agent account: {result}"
-        
+
         else:
             return f"Unknown action: {action}. Use: status, list, create, login, logout, switch, agent"
-    
+
     @override
     def register(self, mcp_server: FastMCP) -> None:
         """Register this tool with the MCP server."""
         tool_self = self
-        
+
         @mcp_server.tool(name=self.name, description=self.description)
         async def code_auth(
             ctx: MCPContext,
@@ -191,4 +192,4 @@ Providers: claude, openai, azure, deepseek, google, groq"""
                 description=description,
                 agent_id=agent_id,
                 parent_account=parent_account,
-            )
+            )

hanzo_mcp/tools/agent/codex_cli_tool.py

@@ -4,26 +4,27 @@ This tool provides integration with OpenAI's CLI (openai command),
 allowing programmatic execution of GPT-4 and other models for code tasks.
 """
 
-from typing import List, Optional, override, final
+from typing import List, Optional, final, override
+
 from mcp.server import FastMCP
 from mcp.server.fastmcp import Context as MCPContext
 
-from hanzo_mcp.tools.agent.cli_agent_base import CLIAgentBase
 from hanzo_mcp.tools.common.permissions import PermissionManager
+from hanzo_mcp.tools.agent.cli_agent_base import CLIAgentBase
 
 
 @final
 class CodexCLITool(CLIAgentBase):
     """Tool for executing OpenAI CLI (formerly Codex)."""
-    
+
     def __init__(
         self,
         permission_manager: PermissionManager,
         model: Optional[str] = None,
-        **kwargs
+        **kwargs,
     ):
         """Initialize Codex CLI tool.
-        
+
         Args:
             permission_manager: Permission manager for access control
             model: Optional model override (defaults to gpt-4o)
@@ -35,15 +36,15 @@ class CodexCLITool(CLIAgentBase):
             provider_name="OpenAI",
             default_model=model or "gpt-4o",
             env_vars=["OPENAI_API_KEY"],
-            **kwargs
+            **kwargs,
         )
-    
+
     @property
     @override
     def name(self) -> str:
         """Get the tool name."""
         return "codex_cli"
-    
+
     @property
     @override
     def description(self) -> str:
@@ -68,42 +69,42 @@ Requirements:
 - OpenAI CLI must be installed: pip install openai
 - OPENAI_API_KEY environment variable
 """
-    
+
     @override
     def get_cli_args(self, prompt: str, **kwargs) -> List[str]:
         """Get CLI arguments for OpenAI.
-        
+
         Args:
             prompt: The prompt to send
             **kwargs: Additional arguments (model, temperature, etc.)
-            
+
         Returns:
             List of command arguments
         """
         args = ["api", "chat.completions.create"]
-        
+
         # Add model
         model = kwargs.get("model", self.default_model)
         args.extend(["-m", model])
-        
+
         # Add temperature if specified
         if "temperature" in kwargs:
             args.extend(["--temperature", str(kwargs["temperature"])])
-        
+
         # Add max tokens if specified
         if "max_tokens" in kwargs:
             args.extend(["--max-tokens", str(kwargs["max_tokens"])])
-        
+
         # Add the prompt as a message
         args.extend(["-g", prompt])
-        
+
         return args
-    
+
     @override
     def register(self, mcp_server: FastMCP) -> None:
         """Register this tool with the MCP server."""
         tool_self = self
-        
+
         @mcp_server.tool(name=self.name, description=self.description)
         async def codex_cli(
             ctx: MCPContext,
@@ -120,4 +121,4 @@ Requirements:
                 temperature=temperature,
                 max_tokens=max_tokens,
                 working_dir=working_dir,
-            )
+            )

hanzo_mcp/tools/agent/critic_tool.py

@@ -1,16 +1,17 @@
 """Critic tool for agents to request critical review from main loop."""
 
-import json
-from typing import Any, Dict, List, Optional, override
 from enum import Enum
+from typing import List, Optional, override
 
-from hanzo_mcp.tools.common.base import BaseTool
-from mcp.server.fastmcp import Context as MCPContext
 from mcp.server import FastMCP
+from mcp.server.fastmcp import Context as MCPContext
+
+from hanzo_mcp.tools.common.base import BaseTool
 
 
 class ReviewType(Enum):
     """Types of review requests."""
+
     CODE_QUALITY = "code_quality"
     CORRECTNESS = "correctness"
     PERFORMANCE = "performance"
@@ -22,9 +23,9 @@ class ReviewType(Enum):
 
 class CriticTool(BaseTool):
     """Tool for agents to request critical review from the main loop."""
-    
+
     name = "critic"
-    
+
     @property
     @override
     def description(self) -> str:
@@ -55,7 +56,7 @@ critic(
     file_paths=["/path/to/atomic.go", "/path/to/network.go"],
     specific_concerns="Are the imports in the correct format and location?"
 )"""
-    
+
     async def call(
         self,
         ctx: MCPContext,
@@ -63,16 +64,16 @@ critic(
         work_description: str,
         code_snippets: Optional[List[str]] = None,
         file_paths: Optional[List[str]] = None,
-        specific_concerns: Optional[str] = None
+        specific_concerns: Optional[str] = None,
     ) -> str:
         """This is a placeholder - actual implementation happens in AgentTool."""
         # This tool is handled specially in the agent execution
         return f"Critic review requested for: {work_description}"
-    
+
     def register(self, server: FastMCP) -> None:
         """Register the tool with the MCP server."""
         tool_self = self
-        
+
         @server.tool(name=self.name, description=self.description)
         async def critic(
             ctx: MCPContext,
@@ -80,7 +81,7 @@ critic(
             work_description: str,
             code_snippets: Optional[List[str]] = None,
             file_paths: Optional[List[str]] = None,
-            specific_concerns: Optional[str] = None
+            specific_concerns: Optional[str] = None,
         ) -> str:
             return await tool_self.call(
                 ctx,
@@ -88,13 +89,13 @@ critic(
                 work_description,
                 code_snippets,
                 file_paths,
-                specific_concerns
+                specific_concerns,
             )
 
 
 class AutoCritic:
     """Automated critic that provides harsh but constructive feedback."""
-    
+
     def __init__(self):
         self.review_patterns = {
             ReviewType.CODE_QUALITY: self._review_code_quality,
@@ -105,82 +106,96 @@ class AutoCritic:
             ReviewType.BEST_PRACTICES: self._review_best_practices,
             ReviewType.GENERAL: self._review_general,
         }
-    
+
     def review(
         self,
         review_type: ReviewType,
         work_description: str,
         code_snippets: Optional[List[str]] = None,
         file_paths: Optional[List[str]] = None,
-        specific_concerns: Optional[str] = None
+        specific_concerns: Optional[str] = None,
     ) -> str:
         """Perform automated critical review."""
         review_func = self.review_patterns.get(review_type, self._review_general)
-        return review_func(work_description, code_snippets, file_paths, specific_concerns)
-    
+        return review_func(
+            work_description, code_snippets, file_paths, specific_concerns
+        )
+
     def _review_code_quality(
         self,
         work_description: str,
         code_snippets: Optional[List[str]],
         file_paths: Optional[List[str]],
-        specific_concerns: Optional[str]
+        specific_concerns: Optional[str],
     ) -> str:
         """Review code quality aspects."""
         issues = []
         suggestions = []
-        
+
         # Check for common code quality issues
         if code_snippets:
             for snippet in code_snippets:
                 # Check for proper error handling
                 if "error" in snippet.lower() and "if err" not in snippet:
-                    issues.append("❌ Missing error handling - always check errors in Go")
-                
+                    issues.append(
+                        "❌ Missing error handling - always check errors in Go"
+                    )
+
                 # Check for magic numbers
                 if any(char.isdigit() for char in snippet) and "const" not in snippet:
-                    suggestions.append("💡 Consider extracting magic numbers to named constants")
-                
+                    suggestions.append(
+                        "💡 Consider extracting magic numbers to named constants"
+                    )
+
                 # Check for proper imports
                 if "import" in snippet:
                     if '"fmt"' in snippet and snippet.count("fmt.") == 0:
                         issues.append("❌ Unused import 'fmt' - remove unused imports")
                     if not snippet.strip().endswith(")") and "import (" in snippet:
                         issues.append("❌ Import block not properly closed")
-        
+
         # General quality checks
         if "fix" in work_description.lower():
             suggestions.append("💡 Ensure you've tested the fix thoroughly")
             suggestions.append("💡 Consider edge cases and error scenarios")
-        
+
         if file_paths and len(file_paths) > 5:
-            suggestions.append("💡 Large number of files modified - consider breaking into smaller PRs")
-        
+            suggestions.append(
+                "💡 Large number of files modified - consider breaking into smaller PRs"
+            )
+
         # Build response
         response = "🔍 CODE QUALITY REVIEW:\n\n"
-        
+
         if issues:
             response += "Issues Found:\n" + "\n".join(issues) + "\n\n"
         else:
             response += "✅ No major code quality issues detected.\n\n"
-        
+
         if suggestions:
-            response += "Suggestions for Improvement:\n" + "\n".join(suggestions) + "\n\n"
-        
+            response += (
+                "Suggestions for Improvement:\n" + "\n".join(suggestions) + "\n\n"
+            )
+
         if specific_concerns:
             response += f"Regarding your concern: '{specific_concerns}'\n"
             if "import" in specific_concerns.lower():
                 response += "→ Imports look properly formatted. Ensure they're in the standard order: stdlib, external, internal.\n"
-        
-        response += "\nOverall: " + ("⚠️ Address the issues before proceeding." if issues else "✅ Good work, but always room for improvement!")
-        
+
+        response += "\nOverall: " + (
+            "⚠️ Address the issues before proceeding."
+            if issues
+            else "✅ Good work, but always room for improvement!"
+        )
+
         return response
-    
+
     def _review_correctness(
         self,
         work_description: str,
         code_snippets: Optional[List[str]],
         file_paths: Optional[List[str]],
-        specific_concerns: Optional[str]
+        specific_concerns: Optional[str],
     ) -> str:
         """Review correctness aspects."""
         return """🔍 CORRECTNESS REVIEW:
@@ -197,13 +212,13 @@ Specific Checks:
 - If refactoring: Confirm behavior is preserved
 
 ⚠️ Remember: Working code > elegant code. Make sure it works first!"""
-    
+
     def _review_performance(
         self,
         work_description: str,
         code_snippets: Optional[List[str]],
         file_paths: Optional[List[str]],
-        specific_concerns: Optional[str]
+        specific_concerns: Optional[str],
     ) -> str:
         """Review performance aspects."""
         return """🔍 PERFORMANCE REVIEW:
@@ -220,13 +235,13 @@ For file operations:
 - Avoid reading entire files into memory if possible
 
 💡 Remember: Premature optimization is evil, but obvious inefficiencies should be fixed."""
-    
+
     def _review_security(
         self,
         work_description: str,
         code_snippets: Optional[List[str]],
         file_paths: Optional[List[str]],
-        specific_concerns: Optional[str]
+        specific_concerns: Optional[str],
     ) -> str:
         """Review security aspects."""
         return """🔍 SECURITY REVIEW:
@@ -240,41 +255,43 @@ Security Checklist:
 🔐 Sensitive data is not logged
 
 ⚠️ If in doubt, err on the side of caution!"""
-    
+
     def _review_completeness(
         self,
         work_description: str,
         code_snippets: Optional[List[str]],
         file_paths: Optional[List[str]],
-        specific_concerns: Optional[str]
+        specific_concerns: Optional[str],
     ) -> str:
         """Review completeness aspects."""
         tasks_mentioned = work_description.lower()
-        
+
         response = "🔍 COMPLETENESS REVIEW:\n\n"
-        
+
         if "fix" in tasks_mentioned and "test" not in tasks_mentioned:
-            response += "❌ No mention of tests - have you verified the fix with tests?\n"
-        
+            response += (
+                "❌ No mention of tests - have you verified the fix with tests?\n"
+            )
+
         if "import" in tasks_mentioned:
             response += "✓ Import fixes mentioned\n"
             response += "❓ Have you checked for other files with similar issues?\n"
             response += "❓ Are all undefined symbols now resolved?\n"
-        
+
         if file_paths:
             response += f"\n✓ Modified {len(file_paths)} files\n"
             response += "❓ Are there any related files that also need updates?\n"
-        
+
         response += "\n💡 Completeness means not just fixing the immediate issue, but considering the broader impact."
-        
+
         return response
-    
+
     def _review_best_practices(
         self,
         work_description: str,
         code_snippets: Optional[List[str]],
         file_paths: Optional[List[str]],
-        specific_concerns: Optional[str]
+        specific_concerns: Optional[str],
     ) -> str:
         """Review best practices."""
         return """🔍 BEST PRACTICES REVIEW:
@@ -293,21 +310,21 @@ General Best Practices:
 ✓ Changes are minimal and focused
 
 💡 Good code is code that others (including future you) can understand and modify."""
-    
+
     def _review_general(
         self,
         work_description: str,
         code_snippets: Optional[List[str]],
         file_paths: Optional[List[str]],
-        specific_concerns: Optional[str]
+        specific_concerns: Optional[str],
     ) -> str:
         """General review covering multiple aspects."""
         response = "🔍 GENERAL CRITICAL REVIEW:\n\n"
         response += f"Work Description: {work_description}\n\n"
-        
+
         # Quick assessment
         response += "Quick Assessment:\n"
-        
+
         if "fix" in work_description.lower():
             response += "- Type: Bug fix / Error resolution\n"
             response += "- Critical: Ensure the fix is complete and tested\n"
@@ -317,60 +334,56 @@ General Best Practices:
         elif "refactor" in work_description.lower():
             response += "- Type: Code refactoring\n"
             response += "- Critical: Ensure behavior is preserved\n"
-        
+
         if file_paths:
             response += f"- Scope: {len(file_paths)} files affected\n"
             if len(file_paths) > 10:
                 response += "- ⚠️ Large scope - consider breaking down\n"
-        
+
         response += "\nCritical Questions:\n"
         response += "1. Is this the minimal change needed?\n"
         response += "2. Have you considered all edge cases?\n"
         response += "3. Will this work in production?\n"
         response += "4. Is there a simpler solution?\n"
-        
+
         if specific_concerns:
             response += f"\nYour Concern: {specific_concerns}\n"
             response += "→ Valid concern. Double-check this area carefully.\n"
-        
+
         response += "\n🎯 Bottom Line: Good work needs critical thinking. Question everything, verify everything."
-        
+
         return response
 
 
 class CriticProtocol:
     """Protocol for critic interactions."""
-    
+
     def __init__(self):
         self.auto_critic = AutoCritic()
         self.review_count = 0
         self.max_reviews = 2  # Allow up to 2 reviews per task
-    
+
     def request_review(
         self,
         review_type: str,
         work_description: str,
         code_snippets: Optional[List[str]] = None,
         file_paths: Optional[List[str]] = None,
-        specific_concerns: Optional[str] = None
+        specific_concerns: Optional[str] = None,
     ) -> str:
         """Request a critical review."""
         if self.review_count >= self.max_reviews:
             return "❌ Review limit exceeded. Time to move forward with what you have."
-        
+
         self.review_count += 1
-        
+
         try:
             review_enum = ReviewType[review_type.upper()]
         except KeyError:
             review_enum = ReviewType.GENERAL
-        
+
         review = self.auto_critic.review(
-            review_enum,
-            work_description,
-            code_snippets,
-            file_paths,
-            specific_concerns
+            review_enum, work_description, code_snippets, file_paths, specific_concerns
         )
-        
-        return f"Review {self.review_count}/{self.max_reviews}:\n\n{review}"
+
+        return f"Review {self.review_count}/{self.max_reviews}:\n\n{review}"