stravinsky 0.2.7__py3-none-any.whl → 0.2.40__py3-none-any.whl

mcp_bridge/hooks/empty_message_sanitizer.py

@@ -0,0 +1,240 @@
+"""
+Empty Message Sanitizer Hook.
+
+Cleans up empty/malformed messages:
+- Detects empty content in messages
+- Replaces with placeholder or removes
+- Prevents API errors from empty content
+- Registered as pre_model_invoke hook
+"""
+
+import logging
+import re
+from typing import Any, Dict, List, Optional
+
+logger = logging.getLogger(__name__)
+
+# Patterns that indicate effectively empty content
+EMPTY_PATTERNS = [
+    r'^\s*$',  # Whitespace only
+    r'^[\n\r]+$',  # Newlines only
+    r'^[\t ]+$',  # Tabs/spaces only
+    r'^\s*null\s*$',  # Null string
+    r'^\s*undefined\s*$',  # Undefined string
+    r'^\s*None\s*$',  # Python None as string
+]
+
+# Patterns for malformed JSON-like content
+MALFORMED_PATTERNS = [
+    r'^\s*\{\s*\}\s*$',  # Empty JSON object
+    r'^\s*\[\s*\]\s*$',  # Empty JSON array
+    r'^\s*""\s*$',  # Empty quoted string
+    r"^\s*''\s*$",  # Empty single-quoted string
+]
+
+# Characters that might corrupt the prompt
+DANGEROUS_PATTERNS = [
+    r'\x00',  # Null byte
+    r'[\x01-\x08]',  # Control characters
+    r'[\x0b\x0c]',  # Vertical tab, form feed
+    r'[\x0e-\x1f]',  # More control characters
+    r'\x7f',  # DEL character
+]
+
+PLACEHOLDER_MESSAGE = "[Content sanitized - empty or malformed input detected]"
+
+SANITIZATION_NOTICE = """
+> **[MESSAGE SANITIZATION]**
+> {count} empty or malformed message segment(s) were detected and sanitized.
+> This prevents API errors and ensures proper message processing.
+"""
+
+
+def is_empty_or_malformed(content: str) -> bool:
+    """
+    Check if content is empty or malformed.
+
+    Args:
+        content: The content string to check
+
+    Returns:
+        True if content is empty or malformed
+    """
+    if content is None:
+        return True
+
+    if not isinstance(content, str):
+        # Try to convert to string
+        try:
+            content = str(content)
+        except:
+            return True
+
+    # Check empty patterns
+    for pattern in EMPTY_PATTERNS:
+        if re.match(pattern, content, re.IGNORECASE):
+            return True
+
+    # Check malformed patterns
+    for pattern in MALFORMED_PATTERNS:
+        if re.match(pattern, content, re.IGNORECASE):
+            return True
+
+    return False
+
+
+def contains_dangerous_characters(content: str) -> bool:
+    """
+    Check if content contains potentially dangerous control characters.
+
+    Args:
+        content: The content string to check
+
+    Returns:
+        True if dangerous characters are found
+    """
+    if not isinstance(content, str):
+        return False
+
+    for pattern in DANGEROUS_PATTERNS:
+        if re.search(pattern, content):
+            return True
+
+    return False
+
+
+def sanitize_content(content: str) -> str:
+    """
+    Sanitize content by removing dangerous characters.
+
+    Args:
+        content: The content to sanitize
+
+    Returns:
+        Sanitized content
+    """
+    if not isinstance(content, str):
+        try:
+            content = str(content)
+        except:
+            return PLACEHOLDER_MESSAGE
+
+    # Remove dangerous characters
+    sanitized = content
+    for pattern in DANGEROUS_PATTERNS:
+        sanitized = re.sub(pattern, '', sanitized)
+
+    # If result is empty after sanitization, use placeholder
+    if is_empty_or_malformed(sanitized):
+        return PLACEHOLDER_MESSAGE
+
+    return sanitized
+
+
+def sanitize_message_blocks(prompt: str) -> tuple[str, int]:
+    """
+    Scan prompt for message blocks and sanitize empty ones.
+
+    This handles common message formats in prompts:
+    - user: content
+    - assistant: content
+    - system: content
+    - <role>content</role>
+
+    Args:
+        prompt: The full prompt text
+
+    Returns:
+        Tuple of (sanitized prompt, count of sanitized blocks)
+    """
+    sanitized_count = 0
+
+    # Pattern for role-prefixed messages (user:, assistant:, system:)
+    role_pattern = re.compile(
+        r'((?:user|assistant|system|human|ai):\s*)([\n\r]+|$)',
+        re.IGNORECASE | re.MULTILINE
+    )
+
+    def replace_empty_role(match):
+        nonlocal sanitized_count
+        sanitized_count += 1
+        role = match.group(1)
+        return f"{role}{PLACEHOLDER_MESSAGE}\n"
+
+    prompt = role_pattern.sub(replace_empty_role, prompt)
+
+    # Pattern for XML-style message tags
+    xml_pattern = re.compile(
+        r'(<(?:user|assistant|system|human|ai)>)\s*(</\1>)',
+        re.IGNORECASE
+    )
+
+    def replace_empty_xml(match):
+        nonlocal sanitized_count
+        sanitized_count += 1
+        open_tag = match.group(1)
+        close_tag = match.group(2)
+        return f"{open_tag}{PLACEHOLDER_MESSAGE}{close_tag}"
+
+    prompt = xml_pattern.sub(replace_empty_xml, prompt)
+
+    return prompt, sanitized_count
+
+
+async def empty_message_sanitizer_hook(params: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+    """
+    Pre-model invoke hook that sanitizes empty and malformed message content.
+
+    Scans the prompt for:
+    - Empty message blocks
+    - Malformed content patterns
+    - Dangerous control characters
+
+    And sanitizes them to prevent API errors.
+    """
+    prompt = params.get("prompt", "")
+
+    # Skip if already sanitized
+    if "[MESSAGE SANITIZATION]" in prompt:
+        return None
+
+    # Skip if prompt is valid and not empty
+    if not prompt or not isinstance(prompt, str):
+        logger.warning("[EmptyMessageSanitizer] Empty or invalid prompt detected")
+        params["prompt"] = PLACEHOLDER_MESSAGE
+        return params
+
+    modifications_made = False
+    sanitized_count = 0
+
+    # Check for dangerous characters in the entire prompt
+    if contains_dangerous_characters(prompt):
+        prompt = sanitize_content(prompt)
+        modifications_made = True
+        sanitized_count += 1
+        logger.info("[EmptyMessageSanitizer] Removed dangerous control characters")
+
+    # Sanitize empty message blocks
+    prompt, block_count = sanitize_message_blocks(prompt)
+    if block_count > 0:
+        sanitized_count += block_count
+        modifications_made = True
+        logger.info(f"[EmptyMessageSanitizer] Sanitized {block_count} empty message blocks")
+
+    # Check if the entire prompt is effectively empty
+    if is_empty_or_malformed(prompt):
+        prompt = PLACEHOLDER_MESSAGE
+        sanitized_count += 1
+        modifications_made = True
+        logger.warning("[EmptyMessageSanitizer] Entire prompt was empty/malformed")
+
+    if not modifications_made:
+        return None
+
+    # Add sanitization notice if modifications were made
+    notice = SANITIZATION_NOTICE.format(count=sanitized_count)
+    params["prompt"] = notice + prompt
+
+    logger.info(f"[EmptyMessageSanitizer] Applied {sanitized_count} sanitization(s)")
+
+    return params

mcp_bridge/hooks/keyword_detector.py

@@ -0,0 +1,122 @@
+"""
+Keyword Detector Hook.
+
+Detects trigger keywords (ironstar, search, analyze) in user prompts
+and injects corresponding mode activation tags.
+"""
+
+import logging
+import re
+from typing import Any, Dict, Optional
+
+logger = logging.getLogger(__name__)
+
+IRONSTAR_MODE = """<ironstar-mode>
+[CODE RED] Maximum precision required. Ultrathink before acting.
+
+YOU MUST LEVERAGE ALL AVAILABLE AGENTS TO THEIR FULLEST POTENTIAL.
+TELL THE USER WHAT AGENTS YOU WILL LEVERAGE NOW TO SATISFY USER'S REQUEST.
+
+## AGENT UTILIZATION PRINCIPLES (by capability, not by name)
+- **Codebase Exploration**: Spawn exploration agents using BACKGROUND TASKS for file patterns, internal implementations, project structure
+- **Documentation & References**: Use dewey agents via BACKGROUND TASKS for API references, examples, external library docs
+- **Planning & Strategy**: NEVER plan yourself - ALWAYS spawn a dedicated planning agent for work breakdown
+- **High-IQ Reasoning**: Leverage delphi for architecture decisions, code review, strategic planning
+- **Frontend/UI Tasks**: Delegate to frontend-ui-ux-engineer for design and implementation
+
+## EXECUTION RULES
+- **TODO**: Track EVERY step. Mark complete IMMEDIATELY after each.
+- **PARALLEL**: Fire independent agent calls simultaneously via background_task - NEVER wait sequentially.
+- **BACKGROUND FIRST**: Use background_task for exploration/research agents (10+ concurrent if needed).
+- **VERIFY**: Re-read request after completion. Check ALL requirements met before reporting done.
+- **DELEGATE**: Don't do everything yourself - orchestrate specialized agents for their strengths.
+
+## WORKFLOW
+1. Analyze the request and identify required capabilities
+2. Spawn exploration/dewey agents via background_task in PARALLEL (10+ if needed)
+3. Always Use Plan agent with gathered context to create detailed work breakdown
+4. Execute with continuous verification against original requirements
+
+## TDD (if test infrastructure exists)
+
+1. Write spec (requirements)
+2. Write tests (failing)
+3. RED: tests fail
+4. Implement minimal code
+5. GREEN: tests pass
+6. Refactor if needed (must stay green)
+7. Next feature, repeat
+
+## ZERO TOLERANCE FAILURES
+- **NO Scope Reduction**: Never make "demo", "skeleton", "simplified", "basic" versions - deliver FULL implementation
+- **NO MockUp Work**: When user asked you to do "port A", you must "port A", fully, 100%. No Extra feature, No reduced feature, no mock data, fully working 100% port.
+- **NO Partial Completion**: Never stop at 60-80% saying "you can extend this..." - finish 100%
+- **NO Assumed Shortcuts**: Never skip requirements you deem "optional" or "can be added later"
+- **NO Premature Stopping**: Never declare done until ALL TODOs are completed and verified
+- **NO TEST DELETION**: Never delete or skip failing tests to make the build pass. Fix the code, not the tests.
+
+THE USER ASKED FOR X. DELIVER EXACTLY X. NOT A SUBSET. NOT A DEMO. NOT A STARTING POINT.
+
+</ironstar-mode>
+
+---
+"""
+
+SEARCH_MODE = """[search-mode]
+MAXIMIZE SEARCH EFFORT. Launch multiple background agents IN PARALLEL:
+- explore agents (codebase patterns, file structures, ast-grep)
+- dewey agents (remote repos, official docs, GitHub examples)
+Plus direct tools: Grep, ripgrep (rg), ast-grep (sg)
+NEVER stop at first result - be exhaustive.
+"""
+
+ANALYZE_MODE = """[analyze-mode]
+ANALYSIS MODE. Gather context before diving deep:
+
+CONTEXT GATHERING (parallel):
+- 1-2 explore agents (codebase patterns, implementations)
+- 1-2 dewey agents (if external library involved)
+- Direct tools: Grep, AST-grep, LSP for targeted searches
+
+IF COMPLEX (architecture, multi-system, debugging after 2+ failures):
+- Consult delphi for strategic guidance
+
+SYNTHESIZE findings before proceeding.
+"""
+
+KEYWORD_PATTERNS = {
+    r"\bironstar\b": IRONSTAR_MODE,
+    r"\birs\b": IRONSTAR_MODE,
+    r"\bultrawork\b": IRONSTAR_MODE,
+    r"\bulw\b": IRONSTAR_MODE,
+    r"\bsearch\b": SEARCH_MODE,
+    r"\banalyze\b": ANALYZE_MODE,
+    r"\banalysis\b": ANALYZE_MODE,
+}
+
+
+async def keyword_detector_hook(params: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+    """
+    Pre-model invoke hook that detects keywords and injects mode tags.
+    """
+    prompt = params.get("prompt", "")
+    prompt_lower = prompt.lower()
+
+    injections = []
+    matched_modes = set()
+
+    for pattern, mode_tag in KEYWORD_PATTERNS.items():
+        if re.search(pattern, prompt_lower):
+            mode_id = id(mode_tag)
+            if mode_id not in matched_modes:
+                matched_modes.add(mode_id)
+                injections.append(mode_tag)
+                logger.info(f"[KeywordDetector] Matched pattern '{pattern}', injecting mode tag")
+
+    if injections:
+        injection_block = "\n".join(injections)
+        modified_prompt = prompt + "\n\n" + injection_block
+        params["prompt"] = modified_prompt
+        return params
+
+    return None

mcp_bridge/hooks/manager.py

@@ -8,16 +8,24 @@ from typing import Any, Callable, Dict, List, Optional, Awaitable
 
 logger = logging.getLogger(__name__)
 
+
 class HookManager:
     """
     Manages the registration and execution of hooks.
     """
+
     _instance = None
 
     def __init__(self):
-        self.pre_tool_call_hooks: List[Callable[[str, Dict[str, Any]], Awaitable[Optional[Dict[str, Any]]]]] = []
-        self.post_tool_call_hooks: List[Callable[[str, Dict[str, Any], str], Awaitable[Optional[str]]]] = []
-        self.pre_model_invoke_hooks: List[Callable[[Dict[str, Any]], Awaitable[Optional[Dict[str, Any]]]]] = []
+        self.pre_tool_call_hooks: List[
+            Callable[[str, Dict[str, Any]], Awaitable[Optional[Dict[str, Any]]]]
+        ] = []
+        self.post_tool_call_hooks: List[
+            Callable[[str, Dict[str, Any], str], Awaitable[Optional[str]]]
+        ] = []
+        self.pre_model_invoke_hooks: List[
+            Callable[[Dict[str, Any]], Awaitable[Optional[Dict[str, Any]]]]
+        ] = []
 
     @classmethod
     def get_instance(cls):
@@ -25,19 +33,27 @@ class HookManager:
             cls._instance = cls()
         return cls._instance
 
-    def register_pre_tool_call(self, hook: Callable[[str, Dict[str, Any]], Awaitable[Optional[Dict[str, Any]]]]):
+    def register_pre_tool_call(
+        self, hook: Callable[[str, Dict[str, Any]], Awaitable[Optional[Dict[str, Any]]]]
+    ):
         """Run before a tool is called. Can modify arguments or return early result."""
         self.pre_tool_call_hooks.append(hook)
 
-    def register_post_tool_call(self, hook: Callable[[str, Dict[str, Any], str], Awaitable[Optional[str]]]):
+    def register_post_tool_call(
+        self, hook: Callable[[str, Dict[str, Any], str], Awaitable[Optional[str]]]
+    ):
         """Run after a tool call. Can modify or recover from tool output/error."""
         self.post_tool_call_hooks.append(hook)
 
-    def register_pre_model_invoke(self, hook: Callable[[Dict[str, Any]], Awaitable[Optional[Dict[str, Any]]]]):
+    def register_pre_model_invoke(
+        self, hook: Callable[[Dict[str, Any]], Awaitable[Optional[Dict[str, Any]]]]
+    ):
         """Run before model invocation. Can modify prompt or parameters."""
         self.pre_model_invoke_hooks.append(hook)
 
-    async def execute_pre_tool_call(self, tool_name: str, arguments: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+    async def execute_pre_tool_call(
+        self, tool_name: str, arguments: Dict[str, Any]
+    ) -> Dict[str, Any]:
         """Executes all pre-tool call hooks."""
         current_args = arguments
         for hook in self.pre_tool_call_hooks:
@@ -49,7 +65,9 @@ class HookManager:
                 logger.error(f"[HookManager] Error in pre_tool_call hook {hook.__name__}: {e}")
         return current_args
 
-    async def execute_post_tool_call(self, tool_name: str, arguments: Dict[str, Any], output: str) -> str:
+    async def execute_post_tool_call(
+        self, tool_name: str, arguments: Dict[str, Any], output: str
+    ) -> str:
         """Executes all post-tool call hooks."""
         current_output = output
         for hook in self.post_tool_call_hooks:
@@ -73,5 +91,6 @@ class HookManager:
                 logger.error(f"[HookManager] Error in pre_model_invoke hook {hook.__name__}: {e}")
         return current_params
 
+
 def get_hook_manager() -> HookManager:
     return HookManager.get_instance()

mcp_bridge/hooks/preemptive_compaction.py

@@ -0,0 +1,157 @@
+"""
+Preemptive Context Compaction Hook.
+
+Proactively compresses context BEFORE hitting limits by:
+- Tracking estimated token usage
+- Triggering compaction at 70% capacity (not waiting for errors)
+- Using DCP -> Truncate -> Summarize pipeline
+- Registered as pre_model_invoke hook
+"""
+
+import logging
+import re
+from typing import Any, Dict, Optional
+
+logger = logging.getLogger(__name__)
+
+# Token estimation constants
+CHARS_PER_TOKEN = 4  # Rough estimate for English text
+MAX_CONTEXT_TOKENS = 200000  # Claude's context window
+PREEMPTIVE_THRESHOLD = 0.70  # Trigger at 70% capacity
+WARNING_THRESHOLD = 0.85  # Critical warning at 85%
+
+# Calculate character thresholds
+PREEMPTIVE_CHAR_THRESHOLD = int(MAX_CONTEXT_TOKENS * CHARS_PER_TOKEN * PREEMPTIVE_THRESHOLD)
+WARNING_CHAR_THRESHOLD = int(MAX_CONTEXT_TOKENS * CHARS_PER_TOKEN * WARNING_THRESHOLD)
+
+
+def estimate_tokens(text: str) -> int:
+    """Estimate token count from character count."""
+    return len(text) // CHARS_PER_TOKEN
+
+
+def calculate_usage_percentage(text: str) -> float:
+    """Calculate context window usage as a percentage."""
+    estimated_tokens = estimate_tokens(text)
+    return (estimated_tokens / MAX_CONTEXT_TOKENS) * 100
+
+
+def apply_dcp_truncation(text: str, target_reduction: float = 0.3) -> str:
+    """
+    Apply DCP (Deferred Context Pruning) truncation strategy.
+
+    Prioritizes keeping:
+    1. System instructions (first ~10%)
+    2. Recent context (last ~30%)
+    3. Key structural elements in middle
+
+    Args:
+        text: The full context text
+        target_reduction: How much to reduce (0.3 = reduce by 30%)
+
+    Returns:
+        Truncated text with summary markers
+    """
+    lines = text.split('\n')
+    total_lines = len(lines)
+
+    if total_lines < 100:
+        # Small context, don't truncate
+        return text
+
+    # Calculate segment boundaries
+    system_end = int(total_lines * 0.10)  # Keep first 10%
+    recent_start = int(total_lines * 0.70)  # Keep last 30%
+
+    # Extract segments
+    system_segment = lines[:system_end]
+    recent_segment = lines[recent_start:]
+    middle_segment = lines[system_end:recent_start]
+
+    # For middle segment, keep key structural elements
+    kept_middle = []
+    for line in middle_segment:
+        # Keep lines with structural importance
+        if any([
+            line.strip().startswith('##'),  # Headers
+            line.strip().startswith('def '),  # Function definitions
+            line.strip().startswith('class '),  # Class definitions
+            line.strip().startswith('- '),  # Bullet points
+            'error' in line.lower(),  # Errors
+            'warning' in line.lower(),  # Warnings
+            'todo' in line.lower(),  # TODOs
+        ]):
+            kept_middle.append(line)
+
+    # Limit middle to avoid bloat
+    max_middle = int(total_lines * (1 - target_reduction) * 0.3)
+    kept_middle = kept_middle[:max_middle]
+
+    # Compose truncated context
+    truncation_marker = f"\n[...{len(middle_segment) - len(kept_middle)} lines truncated for context optimization...]\n"
+
+    result_lines = system_segment + [truncation_marker] + kept_middle + [truncation_marker] + recent_segment
+    return '\n'.join(result_lines)
+
+
+PREEMPTIVE_COMPACTION_NOTICE = """
+> **[PREEMPTIVE CONTEXT OPTIMIZATION]**
+> Context usage at {usage:.1f}% - proactively optimizing to maintain performance.
+> The context has been structured for efficiency:
+> - System instructions preserved
+> - Recent interactions kept in full
+> - Historical middle sections summarized
+> - Key structural elements retained
+"""
+
+CRITICAL_WARNING = """
+> **[CRITICAL - CONTEXT WINDOW AT {usage:.1f}%]**
+> Immediate action recommended:
+> 1. Complete current task and document results in TASK_STATE.md
+> 2. Start a new session for fresh context
+> 3. Reference TASK_STATE.md in new session for continuity
+"""
+
+
+async def preemptive_compaction_hook(params: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+    """
+    Pre-model invoke hook that proactively compresses context before hitting limits.
+
+    Uses a multi-tier strategy:
+    - Below 70%: No action
+    - 70-85%: Apply DCP truncation with notice
+    - Above 85%: Apply aggressive truncation with critical warning
+    """
+    prompt = params.get("prompt", "")
+    prompt_length = len(prompt)
+
+    # Skip if already optimized recently
+    if "[PREEMPTIVE CONTEXT OPTIMIZATION]" in prompt or "[CRITICAL - CONTEXT WINDOW" in prompt:
+        return None
+
+    usage = calculate_usage_percentage(prompt)
+
+    if prompt_length >= WARNING_CHAR_THRESHOLD:
+        # Critical level - aggressive truncation
+        logger.warning(f"[PreemptiveCompaction] Critical context usage: {usage:.1f}%")
+
+        truncated = apply_dcp_truncation(prompt, target_reduction=0.4)
+        notice = CRITICAL_WARNING.format(usage=usage)
+        params["prompt"] = notice + truncated
+
+        logger.info(f"[PreemptiveCompaction] Applied aggressive truncation: {len(prompt)} -> {len(truncated)} chars")
+        return params
+
+    elif prompt_length >= PREEMPTIVE_CHAR_THRESHOLD:
+        # Preemptive level - moderate truncation
+        logger.info(f"[PreemptiveCompaction] Preemptive compaction at {usage:.1f}%")
+
+        truncated = apply_dcp_truncation(prompt, target_reduction=0.3)
+        notice = PREEMPTIVE_COMPACTION_NOTICE.format(usage=usage)
+        params["prompt"] = notice + truncated
+
+        logger.info(f"[PreemptiveCompaction] Applied moderate truncation: {len(prompt)} -> {len(truncated)} chars")
+        return params
+
+    # Below threshold, no action needed
+    return None