empathy-framework 5.3.0__py3-none-any.whl → 5.4.0__py3-none-any.whl

empathy_os/optimization/context_optimizer.py

@@ -1,272 +0,0 @@
-"""Context window optimization for reducing token usage.
-
-Implements compression strategies to reduce prompt tokens by 20-30%
-while maintaining semantic content and XML structure.
-
-Copyright 2026 Smart-AI-Memory
-Licensed under Fair Source License 0.9
-"""
-
-import re
-from enum import Enum
-
-
-class CompressionLevel(Enum):
-    """Context window compression levels."""
-
-    NONE = "none"  # No compression
-    LIGHT = "light"  # Minimal compression (5-10% reduction)
-    MODERATE = "moderate"  # Balanced compression (15-25% reduction)
-    AGGRESSIVE = "aggressive"  # Maximum compression (25-35% reduction)
-
-
-class ContextOptimizer:
-    """Optimizes XML prompts to reduce token usage.
-
-    Strategies:
-    1. Tag compression: <thinking> → <t>, <answer> → <a>
-    2. Whitespace optimization: Remove excess whitespace
-    3. Comment removal: Strip XML comments
-    4. Redundancy elimination: Remove duplicate text
-
-    Usage:
-        optimizer = ContextOptimizer(CompressionLevel.MODERATE)
-        optimized = optimizer.optimize(xml_prompt)
-    """
-
-    def __init__(self, level: CompressionLevel = CompressionLevel.MODERATE):
-        """Initialize optimizer with compression level.
-
-        Args:
-            level: Compression level to apply
-        """
-        self.level = level
-
-        # Tag compression mappings
-        self._tag_mappings = {
-            # Core structure tags
-            "thinking": "t",
-            "answer": "a",
-            "agent_role": "role",
-            "agent_goal": "goal",
-            "agent_backstory": "back",
-            # Common output tags
-            "description": "desc",
-            "recommendation": "rec",
-            "assessment": "assess",
-            "analysis": "analyze",
-            "explanation": "explain",
-            "example": "ex",
-            "code_review": "review",
-            "security_issue": "sec",
-            "performance_issue": "perf",
-            "architecture": "arch",
-            "implementation": "impl",
-        }
-
-        # Reverse mapping for decompression
-        self._reverse_mappings = {v: k for k, v in self._tag_mappings.items()}
-
-    def optimize(self, xml_prompt: str) -> str:
-        """Optimize XML prompt to reduce token usage.
-
-        Args:
-            xml_prompt: Original XML-structured prompt
-
-        Returns:
-            Optimized prompt with reduced token count
-        """
-        if self.level == CompressionLevel.NONE:
-            return xml_prompt
-
-        optimized = xml_prompt
-
-        # Apply optimizations based on level
-        if self.level in (
-            CompressionLevel.LIGHT,
-            CompressionLevel.MODERATE,
-            CompressionLevel.AGGRESSIVE,
-        ):
-            optimized = self._strip_whitespace(optimized)
-            optimized = self._remove_comments(optimized)
-
-        if self.level in (CompressionLevel.MODERATE, CompressionLevel.AGGRESSIVE):
-            optimized = self._compress_tags(optimized)
-            optimized = self._remove_redundancy(optimized)
-
-        if self.level == CompressionLevel.AGGRESSIVE:
-            optimized = self._aggressive_compression(optimized)
-
-        return optimized
-
-    def decompress(self, compressed_response: str) -> str:
-        """Decompress response to restore original tag names.
-
-        Args:
-            compressed_response: Response with compressed tags
-
-        Returns:
-            Response with full tag names restored
-        """
-        decompressed = compressed_response
-
-        # Restore full tag names
-        for short, full in self._reverse_mappings.items():
-            # Opening tags
-            decompressed = decompressed.replace(f"<{short}>", f"<{full}>")
-            decompressed = decompressed.replace(f"<{short} ", f"<{full} ")
-            # Closing tags
-            decompressed = decompressed.replace(f"</{short}>", f"</{full}>")
-
-        return decompressed
-
-    def _strip_whitespace(self, text: str) -> str:
-        """Remove excess whitespace while preserving structure.
-
-        Args:
-            text: Input text
-
-        Returns:
-            Text with optimized whitespace
-        """
-        # Replace multiple spaces with single space
-        text = re.sub(r" {2,}", " ", text)
-
-        # Remove spaces around XML tags
-        text = re.sub(r">\s+<", "><", text)
-
-        # Remove leading/trailing whitespace from lines
-        lines = [line.strip() for line in text.split("\n")]
-
-        # Remove empty lines
-        lines = [line for line in lines if line]
-
-        return "\n".join(lines)
-
-    def _remove_comments(self, text: str) -> str:
-        """Remove XML comments.
-
-        Args:
-            text: Input text
-
-        Returns:
-            Text without comments
-        """
-        # Remove XML comments
-        text = re.sub(r"<!--.*?-->", "", text, flags=re.DOTALL)
-
-        return text
-
-    def _compress_tags(self, text: str) -> str:
-        """Compress XML tag names to shorter versions.
-
-        Args:
-            text: Input text
-
-        Returns:
-            Text with compressed tags
-        """
-        for full, short in self._tag_mappings.items():
-            # Opening tags
-            text = text.replace(f"<{full}>", f"<{short}>")
-            text = text.replace(f"<{full} ", f"<{short} ")
-            # Closing tags
-            text = text.replace(f"</{full}>", f"</{short}>")
-
-        return text
-
-    def _remove_redundancy(self, text: str) -> str:
-        """Remove redundant phrases and repetition.
-
-        Args:
-            text: Input text
-
-        Returns:
-            Text with redundancy removed
-        """
-        # Common redundant phrases in prompts
-        redundant_phrases = [
-            "Please note that ",
-            "It is important to ",
-            "Make sure to ",
-            "Be sure to ",
-            "Remember to ",
-            "Don't forget to ",
-        ]
-
-        for phrase in redundant_phrases:
-            text = text.replace(phrase, "")
-
-        return text
-
-    def _aggressive_compression(self, text: str) -> str:
-        """Apply aggressive compression techniques.
-
-        Args:
-            text: Input text
-
-        Returns:
-            Aggressively compressed text
-        """
-        # Remove articles (a, an, the) where they don't affect meaning
-        # Only in instruction text, not in code or structured output
-        lines = []
-        for line in text.split("\n"):
-            # Skip lines that look like code or XML content
-            if "<" in line and ">" in line:
-                lines.append(line)
-            else:
-                # Remove articles from instruction text
-                line = re.sub(r"\b(a|an|the)\b\s+", "", line, flags=re.IGNORECASE)
-                lines.append(line)
-
-        text = "\n".join(lines)
-
-        # Abbreviate common instruction words
-        abbreviations = {
-            "Generate": "Gen",
-            "Analyze": "Analyze",  # Keep as is (short)
-            "Provide": "Give",
-            "Identify": "ID",
-            "Determine": "Find",
-            "Evaluate": "Eval",
-            "Recommend": "Rec",
-            "Implement": "Impl",
-            "following": "below",
-            "should be": "is",
-            "you should": "you",
-            "must be": "is",
-        }
-
-        for full, abbrev in abbreviations.items():
-            text = text.replace(full, abbrev)
-
-        return text
-
-
-def optimize_xml_prompt(
-    prompt: str,
-    level: CompressionLevel = CompressionLevel.MODERATE,
-) -> str:
-    """Convenience function to optimize XML prompt.
-
-    Args:
-        prompt: XML-structured prompt to optimize
-        level: Compression level to apply
-
-    Returns:
-        Optimized prompt
-
-    Example:
-        >>> prompt = '''<thinking>
-        ...    Analyze the code carefully
-        ... </thinking>
-        ... <answer>
-        ...    The code is good
-        ... </answer>'''
-        >>> optimized = optimize_xml_prompt(prompt)
-        >>> print(optimized)
-        <t>Analyze code carefully</t><a>Code is good</a>
-    """
-    optimizer = ContextOptimizer(level)
-    return optimizer.optimize(prompt)

empathy_os/orchestration/__init__.py

@@ -1,67 +0,0 @@
-"""Meta-orchestration system for dynamic agent composition.
-
-This package provides the infrastructure for dynamically composing
-agent teams based on task requirements. It enables intelligent task
-analysis, agent spawning, and execution strategy selection.
-
-Example:
-    >>> from empathy_os.orchestration import AgentTemplate, get_template
-    >>> template = get_template("test_coverage_analyzer")
-    >>> print(template.role)
-    Test Coverage Expert
-
-    >>> from empathy_os.orchestration import get_strategy
-    >>> strategy = get_strategy("tool_enhanced")
-    >>> print(strategy.__class__.__name__)
-    ToolEnhancedStrategy
-"""
-
-from empathy_os.orchestration.agent_templates import (
-    AgentCapability,
-    AgentTemplate,
-    ResourceRequirements,
-    get_all_templates,
-    get_template,
-    get_templates_by_capability,
-    get_templates_by_tier,
-)
-from empathy_os.orchestration.execution_strategies import (
-    DelegationChainStrategy,
-    ExecutionStrategy,
-    PromptCachedSequentialStrategy,
-    ToolEnhancedStrategy,
-    get_strategy,
-)
-from empathy_os.orchestration.meta_orchestrator import (
-    CompositionPattern,
-    ExecutionPlan,
-    MetaOrchestrator,
-    TaskComplexity,
-    TaskDomain,
-    TaskRequirements,
-)
-
-__all__ = [
-    # Agent Templates
-    "AgentTemplate",
-    "AgentCapability",
-    "ResourceRequirements",
-    "get_template",
-    "get_all_templates",
-    "get_templates_by_capability",
-    "get_templates_by_tier",
-    # Execution Strategies
-    "ExecutionStrategy",
-    "get_strategy",
-    # Anthropic-Inspired Patterns (Patterns 8-10)
-    "ToolEnhancedStrategy",
-    "PromptCachedSequentialStrategy",
-    "DelegationChainStrategy",
-    # Meta-Orchestrator & Types
-    "MetaOrchestrator",
-    "ExecutionPlan",
-    "CompositionPattern",
-    "TaskComplexity",
-    "TaskDomain",
-    "TaskRequirements",
-]