empathy-framework 2.4.0__py3-none-any.whl → 3.8.2__py3-none-any.whl

empathy_llm_toolkit/wizards/technology_wizard.py

@@ -0,0 +1,194 @@
+"""Technology/IT Wizard - System Security Compliant AI Assistant
+
+Specialized wizard for IT and technology operations with system security,
+infrastructure data protection, and comprehensive audit logging.
+
+Key Features:
+- System and infrastructure data protection
+- Secrets detection (API keys, credentials, tokens)
+- Security log analysis
+- Comprehensive audit trail
+- DevOps and infrastructure security
+- Automatic classification as INTERNAL
+
+Copyright 2025 Smart AI Memory, LLC
+Licensed under Fair Source 0.9
+"""
+
+import logging
+
+from empathy_llm_toolkit import EmpathyLLM
+
+from .base_wizard import BaseWizard, WizardConfig
+
+logger = logging.getLogger(__name__)
+
+
+# Technology/IT PII patterns
+TECHNOLOGY_PII_PATTERNS = [
+    # Standard PII
+    "email",
+    "phone",
+    "ip_address",
+    # Technology-specific
+    "api_key",
+    "access_token",
+    "ssh_key",
+    "database_credential",
+]
+
+
+class TechnologyWizard(BaseWizard):
+    """System security compliant technology and IT AI assistant
+
+    Implements data protection for IT operations:
+    1. Infrastructure data detection and protection
+    2. Enhanced secrets detection (API keys, credentials)
+    3. Encryption for sensitive system data
+    4. Comprehensive audit logging
+    5. 1-year retention
+    6. Access control enforcement
+
+    Example:
+        >>> from empathy_llm_toolkit import EmpathyLLM
+        >>> from empathy_llm_toolkit.wizards import TechnologyWizard
+        >>>
+        >>> llm = EmpathyLLM(
+        ...     provider="anthropic",
+        ...     api_key=os.getenv("ANTHROPIC_API_KEY"),
+        ...     enable_security=True,
+        ... )
+        >>>
+        >>> wizard = TechnologyWizard(llm)
+        >>>
+        >>> result = await wizard.process(
+        ...     user_input="Help me troubleshoot this infrastructure issue",
+        ...     user_id="sysadmin@company.com"
+        ... )
+
+    """
+
+    def __init__(
+        self,
+        llm: EmpathyLLM,
+        custom_pii_patterns: list[str] | None = None,
+    ):
+        """Initialize technology/IT wizard
+
+        Args:
+            llm: EmpathyLLM instance (security should be enabled)
+            custom_pii_patterns: Additional organization-specific patterns
+
+        """
+        pii_patterns = TECHNOLOGY_PII_PATTERNS.copy()
+
+        if custom_pii_patterns:
+            pii_patterns.extend(custom_pii_patterns)
+
+        config = WizardConfig(
+            name="Technology & IT Assistant",
+            description="System security compliant AI assistant for IT operations",
+            domain="technology",
+            default_empathy_level=3,  # Proactive
+            enable_security=True,
+            pii_patterns=pii_patterns,
+            enable_secrets_detection=True,
+            block_on_secrets=True,  # CRITICAL for IT security
+            audit_all_access=True,
+            retention_days=365,  # 1 year for system logs
+            default_classification="INTERNAL",
+            auto_classify=True,
+        )
+
+        super().__init__(llm, config)
+
+        if not llm.enable_security:
+            logger.warning(
+                "TechnologyWizard initialized with security DISABLED. "
+                "IT security requires enable_security=True in EmpathyLLM.",
+            )
+
+        logger.info(
+            f"TechnologyWizard initialized: {len(pii_patterns)} PII patterns, "
+            f"empathy level={config.default_empathy_level}, security={llm.enable_security}",
+        )
+
+    def _build_system_prompt(self, user_input: str = "") -> str:
+        """Build technology/IT system prompt
+
+        Uses XML-enhanced prompts if enabled for improved precision
+        and reduced errors in critical IT operations.
+        """
+        # Check if XML prompts are enabled
+        if self._is_xml_enabled():
+            # Use XML-enhanced prompt for better structure
+            return self._render_xml_prompt(
+                role="system security compliant AI technology and IT assistant for infrastructure operations",
+                goal="Assist IT professionals with secure, reliable system administration, infrastructure design, and DevOps automation",
+                instructions=[
+                    "Assist IT professionals with system administration, troubleshooting, and operations",
+                    "Support infrastructure design, optimization, and scalability planning",
+                    "Provide security analysis, incident response guidance, and threat mitigation",
+                    "Help with DevOps automation, CI/CD pipelines, and deployment strategies",
+                    "Base recommendations on industry best practices (NIST, CIS, OWASP)",
+                    "Acknowledge compliance requirements (SOC2, ISO 27001, PCI-DSS, GDPR)",
+                ],
+                constraints=[
+                    "CRITICAL: System data automatically protected - never request or display API keys, credentials, passwords, tokens",
+                    "You are an IT support tool, NOT a replacement for sysadmin or security expert judgment",
+                    "CANNOT make production deployment, security policy, or infrastructure decisions autonomously",
+                    "Always defer to IT leadership for critical infrastructure changes",
+                    "Maintain strict confidentiality of infrastructure data",
+                    "System security and data protection paramount - all interactions logged for audit",
+                ],
+                input_type="it_query",
+                input_payload=user_input if user_input else "[IT professional query]",
+                extra={
+                    "domain": "Technology / IT Operations / DevOps / Infrastructure",
+                    "empathy_level": self.config.default_empathy_level,
+                    "secrets_detection_enabled": self.config.enable_secrets_detection,
+                    "retention_days": self.config.retention_days,
+                },
+            )
+        else:
+            # Fallback to legacy plain text prompt
+            return """You are a system security compliant AI technology and IT assistant.
+
+**Domain**: Technology / IT Operations / DevOps / Infrastructure
+
+**Your Role**:
+- Assist IT professionals with system administration and troubleshooting
+- Support infrastructure design and optimization
+- Help with security analysis and incident response
+- Provide guidance on DevOps and automation
+
+**Security**:
+- All system information is automatically protected before you see it
+- Never request or display API keys, credentials, passwords, or tokens
+- Maintain strict confidentiality of infrastructure data
+- All interactions comply with IT security policies
+
+**Technology Guidelines**:
+- Base recommendations on industry best practices and security standards
+- Acknowledge compliance requirements (SOC2, ISO 27001, etc.)
+- Provide practical technical guidance
+- Follow DevOps and SRE principles
+
+**Communication Style**:
+- Technical and precise
+- Clear and actionable
+- Security-focused
+- Problem-solving oriented
+
+**Important Disclaimers**:
+- You are an IT support tool, not a replacement for sysadmin judgment
+- Cannot make production deployment or security policy decisions
+- Not a substitute for qualified IT professionals and security experts
+- Always defer to IT leadership for critical infrastructure decisions
+
+Remember: System security and data protection are paramount. Interactions are logged.
+"""
+
+    def get_pii_patterns(self) -> list[str]:
+        """Get list of technology PII patterns being detected"""
+        return self.config.pii_patterns.copy()

empathy_os/__init__.py

@@ -1,17 +1,65 @@
-"""
-Empathy Framework - AI-Human Collaboration Library
+"""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 empathy_os 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 empathy_os 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__ = "1.0.0-beta"
+__version__ = "3.8.2"
 __author__ = "Patrick Roebuck"
 __email__ = "hello@deepstudy.ai"
 
+from .agent_monitoring import AgentMetrics, AgentMonitor, TeamMetrics
 from .config import EmpathyConfig, load_config
 from .coordination import (
     AgentCoordinator,
@@ -36,20 +84,14 @@ from .exceptions import (
     ValidationError,
 )
 from .feedback_loops import FeedbackLoopDetector
-from .levels import (
-    Level1Reactive,
-    Level2Guided,
-    Level3Proactive,
-    Level4Anticipatory,
-    Level5Systems,
-)
+from .levels import Level1Reactive, Level2Guided, Level3Proactive, Level4Anticipatory, Level5Systems
 from .leverage_points import LeveragePointAnalyzer
 from .logging_config import LoggingConfig, get_logger
 
 # Memory module (unified short-term + long-term + security)
-from .memory import (  # Short-term (Redis); Security - Audit; Claude Memory; Security - PII; Security - Secrets; Long-term (Persistent); Unified Memory Interface (recommended); Configuration
+from .memory import (
     AccessTier,
-    AgentCredentials,
+    AgentCredentials,  # Memory module imports
     AuditEvent,
     AuditLogger,
     Classification,
@@ -84,100 +126,99 @@ from .memory import (  # Short-term (Redis); Security - Audit; Claude Memory; Se
     get_redis_config,
     get_redis_memory,
 )
-from .monitoring import AgentMetrics, AgentMonitor, TeamMetrics
 from .pattern_library import Pattern, PatternLibrary, PatternMatch
 from .persistence import MetricsCollector, PatternPersistence, StateManager
 from .trust_building import TrustBuildingBehaviors
 
 __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",
-    # Unified Memory Interface
-    "UnifiedMemory",
-    "MemoryConfig",
+    "EncryptionManager",
     "Environment",
+    "FeedbackLoopDetector",
+    "FeedbackLoopError",
     "Level1Reactive",
     "Level2Guided",
     "Level3Proactive",
     "Level4Anticipatory",
     "Level5Systems",
-    "FeedbackLoopDetector",
     "LeveragePointAnalyzer",
-    "EmergenceDetector",
+    "LeveragePointError",
+    "LoggingConfig",
+    "MemDocsStorage",
+    "MemoryConfig",
+    "MemoryPermissionError",
+    "MetricsCollector",
+    "PIIDetection",
+    "PIIPattern",
+    # Security - PII
+    "PIIScrubber",
+    "Pattern",
     # Pattern Library
     "PatternLibrary",
-    "Pattern",
     "PatternMatch",
-    # Coordination (Multi-Agent)
-    "ConflictResolver",
-    "ResolutionResult",
-    "ResolutionStrategy",
-    "TeamPriorities",
-    "AgentCoordinator",
-    "AgentTask",
-    "TeamSession",
-    # Monitoring (Multi-Agent)
-    "AgentMonitor",
-    "AgentMetrics",
-    "TeamMetrics",
-    # Redis Short-Term Memory
-    "RedisShortTermMemory",
-    "AccessTier",
-    "AgentCredentials",
-    "StagedPattern",
-    "ConflictContext",
-    "TTLStrategy",
-    # Redis Configuration
-    "get_redis_memory",
-    "get_redis_config",
-    "get_railway_redis",
-    "check_redis_connection",
-    # Trust
-    "TrustBuildingBehaviors",
+    "PatternMetadata",
+    "PatternNotFoundError",
     # Persistence
     "PatternPersistence",
-    "StateManager",
-    "MetricsCollector",
-    # Configuration
-    "EmpathyConfig",
-    "load_config",
-    # Logging
-    "get_logger",
-    "LoggingConfig",
-    # Exceptions
-    "EmpathyFrameworkError",
-    "ValidationError",
-    "PatternNotFoundError",
-    "TrustThresholdError",
-    "ConfidenceThresholdError",
-    "EmpathyLevelError",
-    "LeveragePointError",
-    "FeedbackLoopError",
-    "CollaborationStateError",
+    # Redis Short-Term Memory
+    "RedisShortTermMemory",
+    "ResolutionResult",
+    "ResolutionStrategy",
+    "SecretDetection",
+    "SecretType",
+    # Security - Secrets
+    "SecretsDetector",
     # Long-term Memory
     "SecureMemDocsIntegration",
-    "Classification",
-    "ClassificationRules",
-    "PatternMetadata",
     "SecurePattern",
-    "MemDocsStorage",
-    "EncryptionManager",
     "SecurityError",
-    "MemoryPermissionError",
-    # Claude Memory
-    "ClaudeMemoryConfig",
-    "ClaudeMemoryLoader",
-    # Security - PII
-    "PIIScrubber",
-    "PIIDetection",
-    "PIIPattern",
-    # Security - Secrets
-    "SecretsDetector",
-    "SecretDetection",
-    "SecretType",
+    "SecurityViolation",
     "Severity",
+    "StagedPattern",
+    "StateManager",
+    "TTLStrategy",
+    "TeamMetrics",
+    "TeamPriorities",
+    "TeamSession",
+    # Trust
+    "TrustBuildingBehaviors",
+    "TrustThresholdError",
+    # Unified Memory Interface
+    "UnifiedMemory",
+    "ValidationError",
+    "check_redis_connection",
     "detect_secrets",
-    # Security - Audit
-    "AuditLogger",
-    "AuditEvent",
-    "SecurityViolation",
+    # Logging
+    "get_logger",
+    "get_railway_redis",
+    "get_redis_config",
+    # Redis Configuration
+    "get_redis_memory",
+    "load_config",
 ]

empathy_os/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 empathy_os.adaptive.task_complexity import (
+                                                 ComplexityScore,
+                                                 TaskComplexity,
+                                                 TaskComplexityScorer,
+)
+
+__all__ = ["TaskComplexity", "ComplexityScore", "TaskComplexityScorer"]

empathy_os/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,
+        )