empathy-framework 3.7.0__py3-none-any.whl → 3.7.1__py3-none-any.whl

empathy_llm_toolkit/wizards/patient_assessment_wizard.py

@@ -0,0 +1,193 @@
+"""PatientAssessmentWizard - Generated by Pattern-Compose
+
+Domain: healthcare
+Patterns: empathy_level, user_guidance, linear_flow, structured_fields, step_validation, approval, educational_banner, ai_enhancement, config_validation, session_based
+Generated: Auto-generated by Empathy Framework
+"""
+
+from datetime import datetime
+from typing import Any
+from uuid import uuid4
+
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+
+router = APIRouter(
+    prefix="/wizards/patient_assessment",
+    tags=["wizards"],
+)
+
+
+# Request/Response Models
+class WizardRequest(BaseModel):
+    """Request model for wizard."""
+
+    input: str
+    context: dict[str, Any] | None = None
+
+
+class WizardResponse(BaseModel):
+    """Response model for wizard."""
+
+    success: bool
+    output: str
+    wizard_id: str | None = None
+    error: str | None = None
+
+
+# Session storage (Redis in production, memory for development)
+_wizard_sessions: dict[str, dict[str, Any]] = {}
+
+
+@router.post("/start")
+async def start_wizard():
+    """Start patient_assessment wizard session.
+
+    Returns wizard_id and first step configuration.
+    """
+    wizard_id = str(uuid4())
+
+    session_data = {
+        "wizard_id": wizard_id,
+        "wizard_type": "patient_assessment",
+        "current_step": 1,
+        "total_steps": 5,  # TODO: Adjust based on your wizard
+        "collected_data": {},
+        "created_at": datetime.now().isoformat(),
+    }
+
+    _wizard_sessions[wizard_id] = session_data
+
+    return {
+        "wizard_id": wizard_id,
+        "current_step": 1,
+        "total_steps": 5,
+        "message": "Wizard started successfully",
+    }
+
+
+@router.post("/{wizard_id}/step")
+async def submit_step(wizard_id: str, step_data: dict[str, Any]):
+    """Submit data for current step.
+
+    Validates step sequence and stores data.
+    """
+    if wizard_id not in _wizard_sessions:
+        raise HTTPException(404, "Wizard session not found")
+
+    session = _wizard_sessions[wizard_id]
+    current_step = session["current_step"]
+    total_steps = session["total_steps"]
+
+    # Validate step number
+    submitted_step = step_data.get("step", current_step)
+    if submitted_step != current_step:
+        raise HTTPException(422, f"Expected step {current_step}, got step {submitted_step}")
+
+    # Store data
+    session["collected_data"].update(step_data.get("data", {}))
+    session["updated_at"] = datetime.now().isoformat()
+
+    # Advance to next step
+    if current_step < total_steps:
+        session["current_step"] = current_step + 1
+
+    return {
+        "wizard_id": wizard_id,
+        "current_step": session["current_step"],
+        "total_steps": total_steps,
+        "message": f"Step {current_step} completed",
+    }
+
+
+@router.post("/{wizard_id}/preview")
+async def preview_report(wizard_id: str):
+    """Generate preview without finalizing.
+
+    Allows user to review before explicit approval.
+    """
+    if wizard_id not in _wizard_sessions:
+        raise HTTPException(404, "Wizard session not found")
+
+    session = _wizard_sessions[wizard_id]
+
+    if session["current_step"] != session["total_steps"]:
+        raise HTTPException(400, "Complete all steps before preview")
+
+    # Generate preview
+    preview = _generate_report(session["collected_data"])
+    session["preview_report"] = preview
+    session["preview_generated_at"] = datetime.now().isoformat()
+
+    return {
+        "preview": preview,
+        "message": "Preview generated. Review and approve to finalize.",
+    }
+
+
+@router.post("/{wizard_id}/save")
+async def save_report(wizard_id: str, approval: dict[str, Any]):
+    """Finalize report with user approval.
+
+    Requires preview generated and explicit user approval.
+    """
+    if wizard_id not in _wizard_sessions:
+        raise HTTPException(404, "Wizard session not found")
+
+    session = _wizard_sessions[wizard_id]
+
+    # Verify preview generated
+    if "preview_report" not in session:
+        raise HTTPException(400, "Must generate preview before saving. Call /preview first.")
+
+    # Verify user approval
+    if not approval.get("user_approved", False):
+        raise HTTPException(400, "User approval required. Set 'user_approved': true")
+
+    # Mark as complete
+    session["completed"] = True
+    session["completed_at"] = datetime.now().isoformat()
+    session["final_report"] = session["preview_report"]
+
+    return {
+        "wizard_id": wizard_id,
+        "completed": True,
+        "report": session["final_report"],
+        "message": "Report finalized successfully",
+    }
+
+
+@router.get("/{wizard_id}/report")
+async def get_report(wizard_id: str):
+    """Retrieve completed report.
+
+    Only available after wizard is completed.
+    """
+    if wizard_id not in _wizard_sessions:
+        raise HTTPException(404, "Wizard session not found")
+
+    session = _wizard_sessions[wizard_id]
+
+    if not session.get("completed", False):
+        raise HTTPException(422, "Wizard not yet completed")
+
+    return {
+        "wizard_id": wizard_id,
+        "report": _generate_report(session["collected_data"]),
+    }
+
+
+def _generate_report(collected_data: dict[str, Any]) -> dict[str, Any]:
+    """Generate report from collected data.
+
+    TODO: Customize report generation for your wizard.
+    """
+    return {
+        "data": collected_data,
+        "generated_at": datetime.now().isoformat(),
+        "wizard_type": "patient_assessment",
+    }
+
+
+# Export router
+__all__ = ["router"]

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

@@ -59,28 +59,29 @@ __version__ = "1.0.0-beta"
 __author__ = "Patrick Roebuck"
 __email__ = "hello@deepstudy.ai"
 
+from .agent_monitoring import AgentMetrics, AgentMonitor, TeamMetrics
 from .config import EmpathyConfig, load_config
 from .coordination import (
-    AgentCoordinator,
-    AgentTask,
-    ConflictResolver,
-    ResolutionResult,
-    ResolutionStrategy,
-    TeamPriorities,
-    TeamSession,
+                           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,
+                           CollaborationStateError,
+                           ConfidenceThresholdError,
+                           EmpathyFrameworkError,
+                           EmpathyLevelError,
+                           FeedbackLoopError,
+                           LeveragePointError,
+                           PatternNotFoundError,
+                           TrustThresholdError,
+                           ValidationError,
 )
 from .feedback_loops import FeedbackLoopDetector
 from .levels import Level1Reactive, Level2Guided, Level3Proactive, Level4Anticipatory, Level5Systems
@@ -89,43 +90,42 @@ from .logging_config import LoggingConfig, get_logger
 
 # Memory module (unified short-term + long-term + security)
 from .memory import (
-    AccessTier,
-    AgentCredentials,  # Memory module imports
-    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,
+                           AccessTier,
+                           AgentCredentials,  # Memory module imports
+                           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 .monitoring import AgentMetrics, AgentMonitor, TeamMetrics
 from .pattern_library import Pattern, PatternLibrary, PatternMatch
 from .persistence import MetricsCollector, PatternPersistence, StateManager
 from .trust_building import TrustBuildingBehaviors

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