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

hanzo_mcp/tools/common/forgiving_edit.py

@@ -1,59 +1,57 @@
 """Forgiving edit helper for AI-friendly text matching."""
 
-import difflib
 import re
-from typing import List, Optional, Tuple
+import difflib
+from typing import List, Tuple, Optional
 
 
 class ForgivingEditHelper:
     """Helper class to make text editing more forgiving for AI usage.
-    
+
     This helper normalizes whitespace, handles partial matches, and provides
     suggestions when exact matches fail.
     """
-    
+
     @staticmethod
     def normalize_whitespace(text: str) -> str:
         """Normalize whitespace while preserving structure.
-        
+
         Args:
             text: Text to normalize
-            
+
         Returns:
             Text with normalized whitespace
         """
         # Handle the input line by line
         lines = []
-        for line in text.split('\n'):
+        for line in text.split("\n"):
             # Replace tabs with 4 spaces everywhere in the line
-            line = line.replace('\t', '    ')
-            
+            line = line.replace("\t", "    ")
+
             # Split into indentation and content
             stripped = line.lstrip()
-            indent = line[:len(line) - len(stripped)]
-            
+            indent = line[: len(line) - len(stripped)]
+
             if stripped:
                 # For content, normalize multiple spaces to single space
-                content = re.sub(r' {2,}', ' ', stripped)
+                content = re.sub(r" {2,}", " ", stripped)
                 lines.append(indent + content)
             else:
                 lines.append(indent)
-        
-        return '\n'.join(lines)
-    
+
+        return "\n".join(lines)
+
     @staticmethod
     def find_fuzzy_match(
-        haystack: str, 
-        needle: str,
-        threshold: float = 0.85
+        haystack: str, needle: str, threshold: float = 0.85
     ) -> Optional[Tuple[int, int, str]]:
         """Find a fuzzy match for the needle in the haystack.
-        
+
         Args:
             haystack: Text to search in
             needle: Text to search for
             threshold: Similarity threshold (0-1)
-            
+
         Returns:
             Tuple of (start_pos, end_pos, matched_text) or None
         """
@@ -61,150 +59,156 @@ class ForgivingEditHelper:
         if needle in haystack:
             start = haystack.index(needle)
             return (start, start + len(needle), needle)
-        
+
         # Normalize for comparison
         norm_haystack = ForgivingEditHelper.normalize_whitespace(haystack)
         norm_needle = ForgivingEditHelper.normalize_whitespace(needle)
-        
+
         # Try normalized exact match
         if norm_needle in norm_haystack:
             # Find the match in normalized text
             norm_start = norm_haystack.index(norm_needle)
-            
+
             # Map back to original text
             # This is approximate but usually good enough
-            lines_before = norm_haystack[:norm_start].count('\n')
-            
+            lines_before = norm_haystack[:norm_start].count("\n")
+
             # Find corresponding position in original
-            original_lines = haystack.split('\n')
-            norm_lines = norm_haystack.split('\n')
-            
+            original_lines = haystack.split("\n")
+            norm_lines = norm_haystack.split("\n")
+
             start_pos = sum(len(line) + 1 for line in original_lines[:lines_before])
-            
+
             # Find end position by counting lines in needle
-            needle_lines = norm_needle.count('\n') + 1
-            end_pos = sum(len(line) + 1 for line in original_lines[:lines_before + needle_lines])
-            
-            matched = '\n'.join(original_lines[lines_before:lines_before + needle_lines])
+            needle_lines = norm_needle.count("\n") + 1
+            end_pos = sum(
+                len(line) + 1 for line in original_lines[: lines_before + needle_lines]
+            )
+
+            matched = "\n".join(
+                original_lines[lines_before : lines_before + needle_lines]
+            )
             return (start_pos, end_pos - 1, matched)
-        
+
         # Try fuzzy matching on lines
-        haystack_lines = haystack.split('\n')
-        needle_lines = needle.split('\n')
-        
+        haystack_lines = haystack.split("\n")
+        needle_lines = needle.split("\n")
+
         if len(needle_lines) == 1:
             # Single line - find best match
             needle_norm = ForgivingEditHelper.normalize_whitespace(needle)
             best_ratio = 0
             best_match = None
-            
+
             for i, line in enumerate(haystack_lines):
                 line_norm = ForgivingEditHelper.normalize_whitespace(line)
                 ratio = difflib.SequenceMatcher(None, line_norm, needle_norm).ratio()
-                
+
                 if ratio > best_ratio and ratio >= threshold:
                     best_ratio = ratio
                     start_pos = sum(len(l) + 1 for l in haystack_lines[:i])
                     best_match = (start_pos, start_pos + len(line), line)
-            
+
             return best_match
-        
+
         else:
             # Multi-line - find sequence match
             for i in range(len(haystack_lines) - len(needle_lines) + 1):
-                candidate_lines = haystack_lines[i:i + len(needle_lines)]
-                candidate = '\n'.join(candidate_lines)
+                candidate_lines = haystack_lines[i : i + len(needle_lines)]
+                candidate = "\n".join(candidate_lines)
                 candidate_norm = ForgivingEditHelper.normalize_whitespace(candidate)
                 needle_norm = ForgivingEditHelper.normalize_whitespace(needle)
-                
-                ratio = difflib.SequenceMatcher(None, candidate_norm, needle_norm).ratio()
-                
+
+                ratio = difflib.SequenceMatcher(
+                    None, candidate_norm, needle_norm
+                ).ratio()
+
                 if ratio >= threshold:
                     start_pos = sum(len(l) + 1 for l in haystack_lines[:i])
                     return (start_pos, start_pos + len(candidate), candidate)
-        
+
         return None
-    
+
     @staticmethod
     def suggest_matches(
-        haystack: str,
-        needle: str,
-        max_suggestions: int = 3
+        haystack: str, needle: str, max_suggestions: int = 3
     ) -> List[Tuple[float, str]]:
         """Suggest possible matches when exact match fails.
-        
+
         Args:
             haystack: Text to search in
             needle: Text to search for
             max_suggestions: Maximum number of suggestions
-            
+
         Returns:
             List of (similarity_score, text) tuples
         """
         suggestions = []
-        
+
         # Normalize needle
         needle_norm = ForgivingEditHelper.normalize_whitespace(needle)
-        needle_lines = needle.split('\n')
-        
+        needle_lines = needle.split("\n")
+
         if len(needle_lines) == 1:
             # Single line - compare with all lines
-            for line in haystack.split('\n'):
+            for line in haystack.split("\n"):
                 if line.strip():  # Skip empty lines
                     line_norm = ForgivingEditHelper.normalize_whitespace(line)
-                    ratio = difflib.SequenceMatcher(None, line_norm, needle_norm).ratio()
+                    ratio = difflib.SequenceMatcher(
+                        None, line_norm, needle_norm
+                    ).ratio()
                     if ratio > 0.5:  # Only reasonably similar lines
                         suggestions.append((ratio, line))
-        
+
         else:
             # Multi-line - use sliding window
-            haystack_lines = haystack.split('\n')
+            haystack_lines = haystack.split("\n")
             window_size = len(needle_lines)
-            
+
             for i in range(len(haystack_lines) - window_size + 1):
-                candidate_lines = haystack_lines[i:i + window_size]
-                candidate = '\n'.join(candidate_lines)
+                candidate_lines = haystack_lines[i : i + window_size]
+                candidate = "\n".join(candidate_lines)
                 candidate_norm = ForgivingEditHelper.normalize_whitespace(candidate)
-                
-                ratio = difflib.SequenceMatcher(None, candidate_norm, needle_norm).ratio()
+
+                ratio = difflib.SequenceMatcher(
+                    None, candidate_norm, needle_norm
+                ).ratio()
                 if ratio > 0.5:
                     suggestions.append((ratio, candidate))
-        
+
         # Sort by similarity and return top matches
         suggestions.sort(reverse=True, key=lambda x: x[0])
         return suggestions[:max_suggestions]
-    
+
     @staticmethod
     def create_edit_suggestion(
-        file_content: str,
-        old_string: str,
-        new_string: str
+        file_content: str, old_string: str, new_string: str
     ) -> dict:
         """Create a helpful edit suggestion when match fails.
-        
+
         Args:
             file_content: Current file content
             old_string: String that couldn't be found
             new_string: Replacement string
-            
+
         Returns:
             Dict with error message and suggestions
         """
         # Try fuzzy match
         fuzzy_match = ForgivingEditHelper.find_fuzzy_match(file_content, old_string)
-        
+
         if fuzzy_match:
             _, _, matched_text = fuzzy_match
             return {
                 "error": "Exact match not found, but found similar text",
                 "found": matched_text,
                 "suggestion": "Use this as old_string instead",
-                "confidence": "high"
+                "confidence": "high",
             }
-        
+
         # Get suggestions
         suggestions = ForgivingEditHelper.suggest_matches(file_content, old_string)
-        
+
         if suggestions:
             return {
                 "error": "Could not find exact or fuzzy match",
@@ -212,9 +216,9 @@ class ForgivingEditHelper:
                     {"similarity": f"{score:.0%}", "text": text}
                     for score, text in suggestions
                 ],
-                "hint": "Try using one of these suggestions as old_string"
+                "hint": "Try using one of these suggestions as old_string",
             }
-        
+
         # No good matches - provide general help
         return {
             "error": "Could not find any matches",
@@ -222,32 +226,32 @@ class ForgivingEditHelper:
                 "Check for whitespace differences (tabs vs spaces)",
                 "Ensure you're including complete lines",
                 "Try a smaller, more unique portion of text",
-                "Use the streaming_command tool to view the file with visible whitespace"
-            ]
+                "Use the streaming_command tool to view the file with visible whitespace",
+            ],
         }
-    
+
     @staticmethod
     def prepare_edit_string(text: str) -> str:
         """Prepare a string for editing by handling common issues.
-        
+
         Args:
             text: Text to prepare
-            
+
         Returns:
             Cleaned text ready for editing
         """
         # Remove any line number prefixes (common in AI copy-paste)
         lines = []
-        for line in text.split('\n'):
+        for line in text.split("\n"):
             # Remove common line number patterns while preserving indentation
             # Match patterns like "1: ", "123: ", "1| ", "1- ", etc.
             # But preserve the original indentation after the line number
-            match = re.match(r'^(\d+[:\|\-])\s(.*)', line)
+            match = re.match(r"^(\d+[:\|\-])\s(.*)", line)
             if match:
                 # Keep only the content part (group 2) which includes any indentation
                 lines.append(match.group(2))
             else:
                 # No line number pattern found, keep the line as-is
                 lines.append(line)
-        
-        return '\n'.join(lines)
+
+        return "\n".join(lines)

hanzo_mcp/tools/common/mode.py

@@ -1,23 +1,23 @@
 """Mode system for organizing development tools based on programmer personalities."""
 
 import os
+from typing import Set, Dict, List, Optional
 from dataclasses import dataclass
-from typing import Dict, List, Optional, Set
 
 from hanzo_mcp.tools.common.personality import (
     ToolPersonality,
-    register_default_personalities,
+    personalities,
     ensure_agent_enabled,
-    personalities
 )
 
 
 @dataclass
 class Mode(ToolPersonality):
     """Development mode combining tool preferences and environment settings."""
+
     # Inherits all fields from ToolPersonality
     # Adds mode-specific functionality
-    
+
     @property
     def is_active(self) -> bool:
         """Check if this mode is currently active."""
@@ -26,47 +26,47 @@ class Mode(ToolPersonality):
 
 class ModeRegistry:
     """Registry for development modes."""
-    
+
     _modes: Dict[str, Mode] = {}
     _active_mode: Optional[str] = None
-    
+
     @classmethod
     def register(cls, mode: Mode) -> None:
         """Register a development mode."""
         # Ensure agent is enabled if API keys present
         mode = ensure_agent_enabled(mode)
         cls._modes[mode.name] = mode
-    
+
     @classmethod
     def get(cls, name: str) -> Optional[Mode]:
         """Get a mode by name."""
         return cls._modes.get(name)
-    
+
     @classmethod
     def list(cls) -> List[Mode]:
         """List all registered modes."""
         return list(cls._modes.values())
-    
+
     @classmethod
     def set_active(cls, name: str) -> None:
         """Set the active mode."""
         if name not in cls._modes:
             raise ValueError(f"Mode '{name}' not found")
         cls._active_mode = name
-        
+
         # Apply environment variables from the mode
         mode = cls._modes[name]
         if mode.environment:
             for key, value in mode.environment.items():
                 os.environ[key] = value
-    
+
     @classmethod
     def get_active(cls) -> Optional[Mode]:
         """Get the active mode."""
         if cls._active_mode:
             return cls._modes.get(cls._active_mode)
         return None
-    
+
     @classmethod
     def get_active_tools(cls) -> Set[str]:
         """Get the set of tools from the active mode."""
@@ -95,9 +95,9 @@ def get_mode_from_env() -> Optional[str]:
     """Get mode name from environment variables."""
     # Check for HANZO_MODE, PERSONALITY, or MODE env vars
     return (
-        os.environ.get("HANZO_MODE") or
-        os.environ.get("PERSONALITY") or
-        os.environ.get("MODE")
+        os.environ.get("HANZO_MODE")
+        or os.environ.get("PERSONALITY")
+        or os.environ.get("MODE")
     )
 
 
@@ -112,5 +112,3 @@ def activate_mode_from_env():
             # Mode not found, ignore
             pass
     return False
-
-

hanzo_mcp/tools/common/mode_loader.py

@@ -1,50 +1,54 @@
 """Tool mode loader for dynamic tool configuration."""
 
 import os
-from typing import Dict, List, Optional, Set
+from typing import Dict, Optional
 
-from hanzo_mcp.tools.common.mode import ModeRegistry, register_default_modes, activate_mode_from_env
+from hanzo_mcp.tools.common.mode import (
+    ModeRegistry,
+    activate_mode_from_env,
+    register_default_modes,
+)
 
 
 class ModeLoader:
     """Loads and manages tool modes for dynamic configuration."""
-    
+
     @staticmethod
     def initialize_modes() -> None:
         """Initialize the mode system with defaults."""
         # Initialize modes
         register_default_modes()
-        
+
         # Check for mode from environment
         activate_mode_from_env()
-        
+
         # If no mode set, use default
         if not ModeRegistry.get_active():
             default_mode = os.environ.get("HANZO_DEFAULT_MODE", "hanzo")
             if ModeRegistry.get(default_mode):
                 ModeRegistry.set_active(default_mode)
-    
+
     @staticmethod
     def get_enabled_tools_from_mode(
         base_enabled_tools: Optional[Dict[str, bool]] = None,
-        force_mode: Optional[str] = None
+        force_mode: Optional[str] = None,
     ) -> Dict[str, bool]:
         """Get enabled tools configuration from active mode.
-        
+
         Args:
             base_enabled_tools: Base configuration to merge with
             force_mode: Force a specific mode (overrides active)
-            
+
         Returns:
             Dictionary of tool enable states
         """
         # Initialize if needed
         if not ModeRegistry.list():
             ModeLoader.initialize_modes()
-        
+
         # Get mode to use
         tools_list = None
-        
+
         if force_mode:
             # Set and get mode
             if ModeRegistry.get(force_mode):
@@ -56,35 +60,36 @@ class ModeLoader:
             mode = ModeRegistry.get_active()
             if mode:
                 tools_list = mode.tools
-        
+
         if not tools_list:
             # No active mode, return base config
             return base_enabled_tools or {}
-        
+
         # Start with base configuration
         result = base_enabled_tools.copy() if base_enabled_tools else {}
-        
+
         # Get all possible tools from registry
         from hanzo_mcp.config.tool_config import TOOL_REGISTRY
+
         all_possible_tools = set(TOOL_REGISTRY.keys())
-        
+
         # Disable all tools first (clean slate for mode)
         for tool in all_possible_tools:
             result[tool] = False
-        
+
         # Enable tools from mode
         for tool in tools_list:
             result[tool] = True
-        
+
         # Always enable mode tool (meta)
         result["mode"] = True
-        
+
         return result
-    
+
     @staticmethod
     def get_environment_from_mode() -> Dict[str, str]:
         """Get environment variables from active mode.
-        
+
         Returns:
             Dictionary of environment variables
         """
@@ -92,14 +97,12 @@ class ModeLoader:
         mode = ModeRegistry.get_active()
         if mode and mode.environment:
             return mode.environment.copy()
-        
+
         return {}
-    
+
     @staticmethod
     def apply_environment_from_mode() -> None:
         """Apply environment variables from active mode."""
         env_vars = ModeLoader.get_environment_from_mode()
         for key, value in env_vars.items():
             os.environ[key] = value
-
-