attune-ai 2.0.0__py3-none-any.whl

attune/__init__.py

@@ -0,0 +1,358 @@
+"""Empathy Framework - AI-Human Collaboration Library
+
+A five-level maturity model for building AI systems that progress from
+reactive responses to anticipatory problem prevention.
+
+QUICK START:
+    from attune import EmpathyOS
+
+    # Create an EmpathyOS instance
+    empathy = EmpathyOS(user_id="developer@company.com")
+
+    # Use Level 4 (Anticipatory) for predictions
+    response = empathy.level_4_anticipatory(
+        user_input="How do I optimize database queries?",
+        context={"domain": "software"},
+        history=[]
+    )
+
+    print(f"Response: {response['response']}")
+    print(f"Predictions: {response.get('predictions', [])}")
+
+    # Store patterns in memory
+    empathy.stash("session_context", {"topic": "database optimization"})
+    empathy.persist_pattern(
+        content="Query optimization technique",
+        pattern_type="technique"
+    )
+
+MEMORY OPERATIONS:
+    from attune import UnifiedMemory, Classification
+
+    # Initialize unified memory (auto-detects environment)
+    memory = UnifiedMemory(user_id="agent@company.com")
+
+    # Short-term (Redis-backed, TTL-based)
+    memory.stash("working_data", {"status": "processing"})
+    data = memory.retrieve("working_data")
+
+    # Long-term (persistent, classified)
+    result = memory.persist_pattern(
+        content="Optimization algorithm for X",
+        pattern_type="algorithm",
+        classification=Classification.INTERNAL,
+    )
+    pattern = memory.recall_pattern(result["pattern_id"])
+
+KEY EXPORTS:
+    - EmpathyOS: Main orchestration class
+    - UnifiedMemory: Two-tier memory (short + long term)
+    - MemoryConfig, Environment: Memory configuration
+    - Classification, AccessTier: Security/access enums
+    - Level1-5 classes: Empathy level implementations
+
+Copyright 2025 Smart AI Memory, LLC
+Licensed under Fair Source 0.9
+"""
+
+__version__ = "5.3.0"
+__author__ = "Patrick Roebuck"
+__email__ = "patrick.roebuck@smartaimemory.com"
+
+# =============================================================================
+# LAZY IMPORTS - Deferred loading for faster startup
+# =============================================================================
+# Instead of importing everything at module load, we use __getattr__ to load
+# modules only when they're actually accessed. This reduces import time from
+# ~1s to ~0.05s for simple use cases.
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    # Type hints for IDE support (not evaluated at runtime)
+    from .agent_monitoring import AgentMetrics, AgentMonitor, TeamMetrics
+    from .config import EmpathyConfig, load_config
+    from .coordination import (
+        AgentCoordinator,
+        AgentTask,
+        ConflictResolver,
+        ResolutionResult,
+        ResolutionStrategy,
+        TeamPriorities,
+        TeamSession,
+    )
+    from .core import EmpathyOS
+    from .emergence import EmergenceDetector
+    from .exceptions import (
+        CollaborationStateError,
+        ConfidenceThresholdError,
+        EmpathyFrameworkError,
+        EmpathyLevelError,
+        FeedbackLoopError,
+        LeveragePointError,
+        PatternNotFoundError,
+        TrustThresholdError,
+        ValidationError,
+    )
+    from .feedback_loops import FeedbackLoopDetector
+    from .levels import (
+        Level1Reactive,
+        Level2Guided,
+        Level3Proactive,
+        Level4Anticipatory,
+        Level5Systems,
+    )
+    from .leverage_points import LeveragePointAnalyzer
+    from .logging_config import LoggingConfig, get_logger
+    from .memory import (
+        AccessTier,
+        AgentCredentials,
+        AuditEvent,
+        AuditLogger,
+        Classification,
+        ClassificationRules,
+        ClaudeMemoryConfig,
+        ClaudeMemoryLoader,
+        ConflictContext,
+        EncryptionManager,
+        Environment,
+        MemDocsStorage,
+        MemoryConfig,
+        MemoryPermissionError,
+        PatternMetadata,
+        PIIDetection,
+        PIIPattern,
+        PIIScrubber,
+        RedisShortTermMemory,
+        SecretDetection,
+        SecretsDetector,
+        SecretType,
+        SecureMemDocsIntegration,
+        SecurePattern,
+        SecurityError,
+        SecurityViolation,
+        Severity,
+        StagedPattern,
+        TTLStrategy,
+        UnifiedMemory,
+        check_redis_connection,
+        detect_secrets,
+        get_railway_redis,
+        get_redis_config,
+        get_redis_memory,
+    )
+    from .pattern_library import Pattern, PatternLibrary, PatternMatch
+    from .persistence import MetricsCollector, PatternPersistence, StateManager
+    from .trust_building import TrustBuildingBehaviors
+
+# Mapping of attribute names to their module paths
+_LAZY_IMPORTS: dict[str, tuple[str, str]] = {
+    # agent_monitoring
+    "AgentMetrics": (".agent_monitoring", "AgentMetrics"),
+    "AgentMonitor": (".agent_monitoring", "AgentMonitor"),
+    "TeamMetrics": (".agent_monitoring", "TeamMetrics"),
+    # config
+    "EmpathyConfig": (".config", "EmpathyConfig"),
+    "load_config": (".config", "load_config"),
+    # coordination
+    "AgentCoordinator": (".coordination", "AgentCoordinator"),
+    "AgentTask": (".coordination", "AgentTask"),
+    "ConflictResolver": (".coordination", "ConflictResolver"),
+    "ResolutionResult": (".coordination", "ResolutionResult"),
+    "ResolutionStrategy": (".coordination", "ResolutionStrategy"),
+    "TeamPriorities": (".coordination", "TeamPriorities"),
+    "TeamSession": (".coordination", "TeamSession"),
+    # core
+    "EmpathyOS": (".core", "EmpathyOS"),
+    # emergence
+    "EmergenceDetector": (".emergence", "EmergenceDetector"),
+    # exceptions
+    "CollaborationStateError": (".exceptions", "CollaborationStateError"),
+    "ConfidenceThresholdError": (".exceptions", "ConfidenceThresholdError"),
+    "EmpathyFrameworkError": (".exceptions", "EmpathyFrameworkError"),
+    "EmpathyLevelError": (".exceptions", "EmpathyLevelError"),
+    "FeedbackLoopError": (".exceptions", "FeedbackLoopError"),
+    "LeveragePointError": (".exceptions", "LeveragePointError"),
+    "PatternNotFoundError": (".exceptions", "PatternNotFoundError"),
+    "TrustThresholdError": (".exceptions", "TrustThresholdError"),
+    "ValidationError": (".exceptions", "ValidationError"),
+    # feedback_loops
+    "FeedbackLoopDetector": (".feedback_loops", "FeedbackLoopDetector"),
+    # levels
+    "Level1Reactive": (".levels", "Level1Reactive"),
+    "Level2Guided": (".levels", "Level2Guided"),
+    "Level3Proactive": (".levels", "Level3Proactive"),
+    "Level4Anticipatory": (".levels", "Level4Anticipatory"),
+    "Level5Systems": (".levels", "Level5Systems"),
+    # leverage_points
+    "LeveragePointAnalyzer": (".leverage_points", "LeveragePointAnalyzer"),
+    # logging_config
+    "LoggingConfig": (".logging_config", "LoggingConfig"),
+    "get_logger": (".logging_config", "get_logger"),
+    # memory module
+    "AccessTier": (".memory", "AccessTier"),
+    "AgentCredentials": (".memory", "AgentCredentials"),
+    "AuditEvent": (".memory", "AuditEvent"),
+    "AuditLogger": (".memory", "AuditLogger"),
+    "Classification": (".memory", "Classification"),
+    "ClassificationRules": (".memory", "ClassificationRules"),
+    "ClaudeMemoryConfig": (".memory", "ClaudeMemoryConfig"),
+    "ClaudeMemoryLoader": (".memory", "ClaudeMemoryLoader"),
+    "ConflictContext": (".memory", "ConflictContext"),
+    "EncryptionManager": (".memory", "EncryptionManager"),
+    "Environment": (".memory", "Environment"),
+    "MemDocsStorage": (".memory", "MemDocsStorage"),
+    "MemoryConfig": (".memory", "MemoryConfig"),
+    "MemoryPermissionError": (".memory", "MemoryPermissionError"),
+    "PatternMetadata": (".memory", "PatternMetadata"),
+    "PIIDetection": (".memory", "PIIDetection"),
+    "PIIPattern": (".memory", "PIIPattern"),
+    "PIIScrubber": (".memory", "PIIScrubber"),
+    "RedisShortTermMemory": (".memory", "RedisShortTermMemory"),
+    "SecretDetection": (".memory", "SecretDetection"),
+    "SecretsDetector": (".memory", "SecretsDetector"),
+    "SecretType": (".memory", "SecretType"),
+    "SecureMemDocsIntegration": (".memory", "SecureMemDocsIntegration"),
+    "SecurePattern": (".memory", "SecurePattern"),
+    "SecurityError": (".memory", "SecurityError"),
+    "SecurityViolation": (".memory", "SecurityViolation"),
+    "Severity": (".memory", "Severity"),
+    "StagedPattern": (".memory", "StagedPattern"),
+    "TTLStrategy": (".memory", "TTLStrategy"),
+    "UnifiedMemory": (".memory", "UnifiedMemory"),
+    "check_redis_connection": (".memory", "check_redis_connection"),
+    "detect_secrets": (".memory", "detect_secrets"),
+    "get_railway_redis": (".memory", "get_railway_redis"),
+    "get_redis_config": (".memory", "get_redis_config"),
+    "get_redis_memory": (".memory", "get_redis_memory"),
+    # pattern_library
+    "Pattern": (".pattern_library", "Pattern"),
+    "PatternLibrary": (".pattern_library", "PatternLibrary"),
+    "PatternMatch": (".pattern_library", "PatternMatch"),
+    # persistence
+    "MetricsCollector": (".persistence", "MetricsCollector"),
+    "PatternPersistence": (".persistence", "PatternPersistence"),
+    "StateManager": (".persistence", "StateManager"),
+    # trust_building
+    "TrustBuildingBehaviors": (".trust_building", "TrustBuildingBehaviors"),
+}
+
+# Cache for loaded modules
+_loaded_modules: dict[str, object] = {}
+
+
+def __getattr__(name: str) -> object:
+    """Lazy import handler - loads modules only when accessed."""
+    if name in _LAZY_IMPORTS:
+        module_path, attr_name = _LAZY_IMPORTS[name]
+
+        # Check cache first
+        cache_key = f"{module_path}.{attr_name}"
+        if cache_key in _loaded_modules:
+            return _loaded_modules[cache_key]
+
+        # Import the module and get the attribute
+        import importlib
+
+        module = importlib.import_module(module_path, package="attune")
+        attr = getattr(module, attr_name)
+
+        # Cache and return
+        _loaded_modules[cache_key] = attr
+        return attr
+
+    raise AttributeError(f"module 'attune' has no attribute '{name}'")
+
+
+__all__ = [
+    "AccessTier",
+    "AgentCoordinator",
+    "AgentCredentials",
+    "AgentMetrics",
+    # Monitoring (Multi-Agent)
+    "AgentMonitor",
+    "AgentTask",
+    "AuditEvent",
+    # Security - Audit
+    "AuditLogger",
+    "Classification",
+    "ClassificationRules",
+    # Claude Memory
+    "ClaudeMemoryConfig",
+    "ClaudeMemoryLoader",
+    "CollaborationStateError",
+    "ConfidenceThresholdError",
+    "ConflictContext",
+    # Coordination (Multi-Agent)
+    "ConflictResolver",
+    "EmergenceDetector",
+    # Configuration
+    "EmpathyConfig",
+    # Exceptions
+    "EmpathyFrameworkError",
+    "EmpathyLevelError",
+    "EmpathyOS",
+    "EncryptionManager",
+    "Environment",
+    "FeedbackLoopDetector",
+    "FeedbackLoopError",
+    "Level1Reactive",
+    "Level2Guided",
+    "Level3Proactive",
+    "Level4Anticipatory",
+    "Level5Systems",
+    "LeveragePointAnalyzer",
+    "LeveragePointError",
+    "LoggingConfig",
+    "MemDocsStorage",
+    "MemoryConfig",
+    "MemoryPermissionError",
+    "MetricsCollector",
+    "PIIDetection",
+    "PIIPattern",
+    # Security - PII
+    "PIIScrubber",
+    "Pattern",
+    # Pattern Library
+    "PatternLibrary",
+    "PatternMatch",
+    "PatternMetadata",
+    "PatternNotFoundError",
+    # Persistence
+    "PatternPersistence",
+    # Redis Short-Term Memory
+    "RedisShortTermMemory",
+    "ResolutionResult",
+    "ResolutionStrategy",
+    "SecretDetection",
+    "SecretType",
+    # Security - Secrets
+    "SecretsDetector",
+    # Long-term Memory
+    "SecureMemDocsIntegration",
+    "SecurePattern",
+    "SecurityError",
+    "SecurityViolation",
+    "Severity",
+    "StagedPattern",
+    "StateManager",
+    "TTLStrategy",
+    "TeamMetrics",
+    "TeamPriorities",
+    "TeamSession",
+    # Trust
+    "TrustBuildingBehaviors",
+    "TrustThresholdError",
+    # Unified Memory Interface
+    "UnifiedMemory",
+    "ValidationError",
+    "check_redis_connection",
+    "detect_secrets",
+    # Logging
+    "get_logger",
+    "get_railway_redis",
+    "get_redis_config",
+    # Redis Configuration
+    "get_redis_memory",
+    "load_config",
+]

attune/adaptive/__init__.py

@@ -0,0 +1,13 @@
+"""Adaptive prompting system for dynamic model and compression selection.
+
+Copyright 2026 Smart-AI-Memory
+Licensed under Fair Source License 0.9
+"""
+
+from attune.adaptive.task_complexity import (
+    ComplexityScore,
+    TaskComplexity,
+    TaskComplexityScorer,
+)
+
+__all__ = ["TaskComplexity", "ComplexityScore", "TaskComplexityScorer"]

attune/adaptive/task_complexity.py

@@ -0,0 +1,127 @@
+"""Task complexity scoring for adaptive prompt selection.
+
+Uses simple heuristics (token count, LOC) to classify tasks as
+simple, moderate, complex, or very complex, enabling dynamic
+model tier and compression level selection.
+
+Copyright 2026 Smart-AI-Memory
+Licensed under Fair Source License 0.9
+"""
+
+from dataclasses import dataclass
+from enum import Enum
+
+try:
+    import tiktoken
+except ImportError:
+    tiktoken = None  # type: ignore[assignment]
+
+
+class TaskComplexity(Enum):
+    """Task complexity levels for adaptive prompting."""
+
+    SIMPLE = "simple"  # <100 tokens, <50 LOC
+    MODERATE = "moderate"  # 100-500 tokens, 50-200 LOC
+    COMPLEX = "complex"  # 500-2000 tokens, 200-1000 LOC
+    VERY_COMPLEX = "very_complex"  # >2000 tokens, >1000 LOC
+
+
+@dataclass
+class ComplexityScore:
+    """Task complexity scoring result.
+
+    Attributes:
+        token_count: Estimated input tokens
+        line_count: Lines of code in context
+        file_count: Number of files involved
+        complexity_level: Classified complexity
+        confidence: Confidence in classification (0-1)
+    """
+
+    token_count: int
+    line_count: int
+    file_count: int
+    complexity_level: TaskComplexity
+    confidence: float
+
+
+class TaskComplexityScorer:
+    """Scores task complexity using simple heuristics.
+
+    Uses token counting (via tiktoken if available) and line counting
+    to estimate task complexity for adaptive prompt selection.
+
+    Usage:
+        scorer = TaskComplexityScorer()
+        score = scorer.score_task(
+            description="Refactor authentication module",
+            context=source_code,
+            files=["auth.py", "session.py"]
+        )
+
+        if score.complexity_level == TaskComplexity.VERY_COMPLEX:
+            use_premium_model()
+    """
+
+    def __init__(self):
+        """Initialize complexity scorer."""
+        if tiktoken:
+            self.tokenizer = tiktoken.get_encoding("cl100k_base")
+        else:
+            self.tokenizer = None
+
+    def score_task(
+        self,
+        description: str,
+        context: str | None = None,
+        files: list[str] | None = None,
+    ) -> ComplexityScore:
+        """Score task complexity.
+
+        Args:
+            description: Task description
+            context: Optional context (code, docs, etc.)
+            files: Optional list of file paths
+
+        Returns:
+            ComplexityScore with classification and metrics
+        """
+        # Count tokens
+        if self.tokenizer:
+            token_count = len(self.tokenizer.encode(description))
+            if context:
+                token_count += len(self.tokenizer.encode(context))
+        else:
+            # Fallback: rough estimate (4 chars per token)
+            token_count = len(description) // 4
+            if context:
+                token_count += len(context) // 4
+
+        # Count lines of code
+        line_count = 0
+        if context:
+            line_count = len(context.split("\n"))
+
+        # Count files
+        file_count = len(files) if files else 0
+
+        # Determine complexity level using thresholds
+        if token_count < 100 and line_count < 50:
+            complexity = TaskComplexity.SIMPLE
+        elif token_count < 500 and line_count < 200:
+            complexity = TaskComplexity.MODERATE
+        elif token_count < 2000 and line_count < 1000:
+            complexity = TaskComplexity.COMPLEX
+        else:
+            complexity = TaskComplexity.VERY_COMPLEX
+
+        # Confidence is moderate for simple heuristics
+        confidence = 0.8 if self.tokenizer else 0.6
+
+        return ComplexityScore(
+            token_count=token_count,
+            line_count=line_count,
+            file_count=file_count,
+            complexity_level=complexity,
+            confidence=confidence,
+        )