attune-ai 2.0.0__py3-none-any.whl

attune/optimization/context_optimizer.py

@@ -0,0 +1,272 @@
+"""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)

attune/orchestration/__init__.py

@@ -0,0 +1,67 @@
+"""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 attune.orchestration import AgentTemplate, get_template
+    >>> template = get_template("test_coverage_analyzer")
+    >>> print(template.role)
+    Test Coverage Expert
+
+    >>> from attune.orchestration import get_strategy
+    >>> strategy = get_strategy("tool_enhanced")
+    >>> print(strategy.__class__.__name__)
+    ToolEnhancedStrategy
+"""
+
+from attune.orchestration.agent_templates import (
+    AgentCapability,
+    AgentTemplate,
+    ResourceRequirements,
+    get_all_templates,
+    get_template,
+    get_templates_by_capability,
+    get_templates_by_tier,
+)
+from attune.orchestration.execution_strategies import (
+    DelegationChainStrategy,
+    ExecutionStrategy,
+    PromptCachedSequentialStrategy,
+    ToolEnhancedStrategy,
+    get_strategy,
+)
+from attune.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",
+]