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

empathy_llm_toolkit/security/secure_memdocs_example.py

@@ -0,0 +1,278 @@
+"""Secure MemDocs Integration - Example Usage
+
+Demonstrates Phase 2 enterprise privacy integration with:
+- PII scrubbing
+- Secrets detection
+- Three-tier classification
+- Encryption for SENSITIVE patterns
+- Audit logging
+
+Author: Empathy Framework Team
+Version: 1.8.0-beta
+"""
+
+import sys
+from pathlib import Path
+
+# Add parent directory to path for imports
+sys.path.insert(0, str(Path(__file__).parent.parent.parent))
+
+from empathy_llm_toolkit.security import SecureMemDocsIntegration, SecurityError
+
+
+def example_basic_usage():
+    """Example 1: Basic pattern storage with auto-classification"""
+    print("\n=== Example 1: Basic Pattern Storage ===\n")
+
+    # Initialize secure integration
+    integration = SecureMemDocsIntegration(
+        storage_dir="./example_memdocs",
+        audit_log_dir="./example_logs",
+    )
+
+    # Store a simple pattern
+    content = """
+    Standard Python sorting algorithm implementation:
+
+    def quick_sort(arr):
+        if len(arr) <= 1:
+            return arr
+        pivot = arr[len(arr) // 2]
+        left = [x for x in arr if x < pivot]
+        middle = [x for x in arr if x == pivot]
+        right = [x for x in arr if x > pivot]
+        return quick_sort(left) + middle + quick_sort(right)
+    """
+
+    result = integration.store_pattern(
+        content=content,
+        pattern_type="algorithm",
+        user_id="developer@company.com",
+    )
+
+    print("Pattern stored successfully!")
+    print(f"  Pattern ID: {result['pattern_id']}")
+    print(f"  Classification: {result['classification']}")
+    print(f"  PII removed: {result['sanitization_report']['pii_count']}")
+    print(f"  Encrypted: {result['metadata']['encrypted']}")
+    print(f"  Retention: {result['metadata']['retention_days']} days")
+
+    return result["pattern_id"]
+
+
+def example_pii_scrubbing():
+    """Example 2: PII scrubbing in action"""
+    print("\n=== Example 2: PII Scrubbing ===\n")
+
+    integration = SecureMemDocsIntegration(
+        storage_dir="./example_memdocs",
+        audit_log_dir="./example_logs",
+    )
+
+    # Content with PII
+    content = """
+    Contact Information:
+    - Email: john.doe@example.com
+    - Phone: 555-123-4567
+    - SSN: 123-45-6789
+
+    For support, call our team at support@company.com
+    """
+
+    result = integration.store_pattern(
+        content=content,
+        pattern_type="contact_info",
+        user_id="hr@company.com",
+    )
+
+    print("Pattern stored with PII scrubbing:")
+    print(f"  Pattern ID: {result['pattern_id']}")
+    print(f"  PII removed: {result['sanitization_report']['pii_count']} items")
+    for pii_item in result["sanitization_report"]["pii_removed"]:
+        print(f"    - {pii_item['type']}")
+
+    # Retrieve to see scrubbed content
+    pattern = integration.retrieve_pattern(
+        pattern_id=result["pattern_id"],
+        user_id="hr@company.com",
+    )
+
+    print("\nRetrieved content (PII scrubbed):")
+    print(pattern["content"][:200] + "...")
+
+    return result["pattern_id"]
+
+
+def example_secrets_blocking():
+    """Example 3: Secrets detection blocks storage"""
+    print("\n=== Example 3: Secrets Detection ===\n")
+
+    integration = SecureMemDocsIntegration(
+        storage_dir="./example_memdocs",
+        audit_log_dir="./example_logs",
+    )
+
+    # Content with secrets (WILL BE BLOCKED)
+    content = """
+    # Configuration
+    ANTHROPIC_API_KEY = "sk-ant-api03-abc123xyz789..."
+    OPENAI_API_KEY = "sk-proj-abc123xyz789..."
+    DATABASE_URL = "postgres://user:password@localhost:5432/db"
+    """
+
+    try:
+        integration.store_pattern(
+            content=content,
+            pattern_type="config",
+            user_id="developer@company.com",
+        )
+        print("ERROR: Secrets should have been blocked!")
+    except SecurityError as e:
+        print("Storage blocked (as expected):")
+        print(f"  Reason: {e!s}")
+        print("  Action: Secrets detected and storage prevented")
+        print("  Audit: Security violation logged")
+
+
+def example_healthcare_sensitive():
+    """Example 4: Healthcare pattern with SENSITIVE classification"""
+    print("\n=== Example 4: Healthcare Pattern (SENSITIVE) ===\n")
+
+    integration = SecureMemDocsIntegration(
+        storage_dir="./example_memdocs",
+        audit_log_dir="./example_logs",
+    )
+
+    # Healthcare content (auto-classified as SENSITIVE)
+    content = """
+    # Patient Vital Signs Monitoring Protocol
+
+    Normal ranges:
+    - Heart rate: 60-100 bpm
+    - Blood pressure: 90/60 to 120/80 mmHg
+    - Respiratory rate: 12-20 breaths/min
+    - Temperature: 97-99°F (36.1-37.2°C)
+    - Oxygen saturation: 95-100%
+
+    Alert thresholds:
+    - Heart rate < 50 or > 120 bpm
+    - Systolic BP < 90 or > 180 mmHg
+    - Oxygen saturation < 92%
+    """
+
+    result = integration.store_pattern(
+        content=content,
+        pattern_type="clinical_protocol",
+        user_id="nurse@hospital.com",
+    )
+
+    print("Healthcare pattern stored:")
+    print(f"  Pattern ID: {result['pattern_id']}")
+    print(f"  Classification: {result['classification']} (auto-detected)")
+    print(f"  Encrypted: {result['metadata']['encrypted']} (HIPAA compliance)")
+    print(f"  Retention: {result['metadata']['retention_days']} days (HIPAA minimum)")
+    print("  Access: Creator only (explicit permission required)")
+
+    # Retrieve (only creator can access)
+    pattern = integration.retrieve_pattern(
+        pattern_id=result["pattern_id"],
+        user_id="nurse@hospital.com",
+    )
+
+    print("\nPattern retrieved and decrypted successfully")
+    print(f"  Content length: {len(pattern['content'])} chars")
+
+    # Try to retrieve as different user (will be blocked)
+    try:
+        pattern = integration.retrieve_pattern(
+            pattern_id=result["pattern_id"],
+            user_id="other_user@hospital.com",
+        )
+        print("ERROR: Access should have been denied!")
+    except Exception:
+        print("\nAccess denied for different user (as expected):")
+        print("  Reason: SENSITIVE patterns require explicit permission")
+
+    return result["pattern_id"]
+
+
+def example_list_patterns():
+    """Example 5: List accessible patterns"""
+    print("\n=== Example 5: List Patterns ===\n")
+
+    integration = SecureMemDocsIntegration(
+        storage_dir="./example_memdocs",
+        audit_log_dir="./example_logs",
+    )
+
+    # List patterns for user
+    patterns = integration.list_patterns(user_id="developer@company.com")
+
+    print(f"Accessible patterns: {len(patterns)}")
+    for pattern in patterns:
+        print(f"\n  Pattern: {pattern['pattern_id']}")
+        print(f"    Type: {pattern['pattern_type']}")
+        print(f"    Classification: {pattern['classification']}")
+        print(f"    Created: {pattern['created_at']}")
+        print(f"    Encrypted: {pattern['encrypted']}")
+
+
+def example_statistics():
+    """Example 6: Get storage statistics"""
+    print("\n=== Example 6: Storage Statistics ===\n")
+
+    integration = SecureMemDocsIntegration(
+        storage_dir="./example_memdocs",
+        audit_log_dir="./example_logs",
+    )
+
+    stats = integration.get_statistics()
+
+    print("MemDocs Statistics:")
+    print(f"  Total patterns: {stats['total_patterns']}")
+    print("  By classification:")
+    for classification, count in stats["by_classification"].items():
+        print(f"    - {classification}: {count}")
+    print(f"  Encrypted patterns: {stats['encrypted_count']}")
+    print(f"  With PII scrubbed: {stats['with_pii_scrubbed']}")
+
+
+def main():
+    """Run all examples"""
+    print("=" * 70)
+    print("Secure MemDocs Integration - Example Usage")
+    print("Phase 2: Enterprise Privacy Integration")
+    print("=" * 70)
+
+    try:
+        # Example 1: Basic usage
+        example_basic_usage()
+
+        # Example 2: PII scrubbing
+        example_pii_scrubbing()
+
+        # Example 3: Secrets blocking
+        example_secrets_blocking()
+
+        # Example 4: Healthcare (SENSITIVE)
+        example_healthcare_sensitive()
+
+        # Example 5: List patterns
+        example_list_patterns()
+
+        # Example 6: Statistics
+        example_statistics()
+
+        print("\n" + "=" * 70)
+        print("All examples completed successfully!")
+        print("=" * 70)
+
+    except Exception as e:
+        print(f"\n\nError running examples: {e}")
+        import traceback
+
+        traceback.print_exc()
+
+
+if __name__ == "__main__":
+    main()

empathy_llm_toolkit/session_status.py

@@ -1,5 +1,4 @@
-"""
-Session Status Assistant
+"""Session Status Assistant
 
 Proactive briefing system that greets developers when they return to an
 Empathy-enhanced project, providing a prioritized status report with
@@ -93,8 +92,7 @@ class SessionStatus:
 
 
 class SessionStatusCollector:
-    """
-    Aggregates project status from all data sources.
+    """Aggregates project status from all data sources.
 
     Scans patterns directories, roadmap docs, and git history
     to build a prioritized status report for developers.
@@ -119,8 +117,7 @@ class SessionStatusCollector:
         self._state: dict[str, Any] | None = None
 
     def should_show(self) -> bool:
-        """
-        Check if status should be shown based on inactivity.
+        """Check if status should be shown based on inactivity.
 
         Returns True if:
         - First interaction after inactivity_minutes of no activity
@@ -164,11 +161,11 @@ class SessionStatusCollector:
         logger.debug("Recorded interaction at %s", state["last_interaction"])
 
     def collect(self) -> SessionStatus:
-        """
-        Collect and prioritize status items from all data sources.
+        """Collect and prioritize status items from all data sources.
 
         Returns:
             SessionStatus with prioritized items and wins
+
         """
         status = SessionStatus()
 
@@ -224,7 +221,7 @@ class SessionStatusCollector:
                     action_prompt=f"Review security finding: {finding}. "
                     f"Provide analysis and recommend: ACCEPTED, DEFERRED, or FALSE_POSITIVE.",
                     details={"pending_count": pending_count, "items": pending_items[:3]},
-                )
+                ),
             )
 
     def _collect_bug_items(self, status: SessionStatus) -> None:
@@ -267,7 +264,7 @@ class SessionStatusCollector:
                     f"{first_bug.get('error_message', 'No description')}. "
                     f"File: {first_bug.get('file_path', 'unknown')}",
                     details={"count": len(high_severity), "bugs": high_severity[:3]},
-                )
+                ),
             )
 
         # Add investigating bugs (P2)
@@ -285,7 +282,7 @@ class SessionStatusCollector:
                     f"Use: empathy patterns resolve {first_bug.get('bug_id', '')} "
                     f"--root-cause '<cause>' --fix '<fix>'",
                     details={"count": len(investigating), "bugs": investigating[:5]},
-                )
+                ),
             )
 
     def _collect_tech_debt_items(self, status: SessionStatus) -> None:
@@ -336,7 +333,7 @@ class SessionStatusCollector:
                         "change": change,
                         "hotspots": current.get("hotspots", [])[:3],
                     },
-                )
+                ),
             )
         elif change < 0:
             # Tech debt decreasing - this is a win
@@ -364,7 +361,7 @@ class SessionStatusCollector:
                         {
                             "task": task.strip(),
                             "file": plan_file.name,
-                        }
+                        },
                     )
             except OSError as e:
                 logger.warning("Failed to read plan file %s: %s", plan_file, e)
@@ -381,7 +378,7 @@ class SessionStatusCollector:
                     action_prompt=f"Continue roadmap item from {first_task['file']}: "
                     f"{first_task['task']}",
                     details={"count": len(unchecked_tasks), "tasks": unchecked_tasks[:5]},
-                )
+                ),
             )
 
     def _collect_git_items(self, status: SessionStatus) -> None:
@@ -389,6 +386,7 @@ class SessionStatusCollector:
         try:
             result = subprocess.run(
                 ["git", "log", "-10", "--format=%h|%s", "--since=7.days"],
+                check=False,
                 capture_output=True,
                 text=True,
                 timeout=5,
@@ -413,7 +411,7 @@ class SessionStatusCollector:
                         {
                             "hash": commit_hash,
                             "message": message,
-                        }
+                        },
                     )
 
             if wip_commits:
@@ -429,7 +427,7 @@ class SessionStatusCollector:
                         f"{first_commit['message']}. "
                         "This commit may need follow-up work.",
                         details={"count": len(wip_commits), "commits": wip_commits[:5]},
-                    )
+                    ),
                 )
 
         except Exception as e:
@@ -540,8 +538,7 @@ class SessionStatusCollector:
         status: SessionStatus,
         max_items: int | None = None,
     ) -> str:
-        """
-        Format status for terminal output.
+        """Format status for terminal output.
 
         Args:
             status: The SessionStatus to format
@@ -549,6 +546,7 @@ class SessionStatusCollector:
 
         Returns:
             Formatted markdown string
+
         """
         max_items = max_items or self.config["max_display_items"]
         sorted_items = status.get_sorted_items()
@@ -616,8 +614,7 @@ class SessionStatusCollector:
         return json.dumps(data, indent=2, default=str)
 
     def get_action_prompt(self, status: SessionStatus, selection: int) -> str | None:
-        """
-        Get the action prompt for a selected item.
+        """Get the action prompt for a selected item.
 
         Args:
             status: The SessionStatus
@@ -625,6 +622,7 @@ class SessionStatusCollector:
 
         Returns:
             Action prompt string, or None if invalid selection
+
         """
         sorted_items = status.get_sorted_items()
 

empathy_llm_toolkit/state.py

@@ -1,5 +1,4 @@
-"""
-Collaboration State Management
+"""Collaboration State Management
 
 Tracks AI-human collaboration over time to enable Level 3+ empathy.
 
@@ -24,8 +23,7 @@ class PatternType(Enum):
 
 @dataclass
 class UserPattern:
-    """
-    A detected pattern in user behavior.
+    """A detected pattern in user behavior.
 
     Enables Level 3 (Proactive) empathy.
     """
@@ -39,8 +37,7 @@ class UserPattern:
     context: dict[str, Any] = field(default_factory=dict)
 
     def should_act(self, trust_level: float) -> bool:
-        """
-        Determine if we should act proactively on this pattern.
+        """Determine if we should act proactively on this pattern.
 
         Requires both high confidence and sufficient trust.
         """
@@ -60,8 +57,7 @@ class Interaction:
 
 @dataclass
 class CollaborationState:
-    """
-    Tracks AI-human collaboration state over time.
+    """Tracks AI-human collaboration state over time.
 
     This is the foundation for Level 2+ empathy:
     - Level 2: Uses conversation history for context
@@ -104,7 +100,11 @@ class CollaborationState:
         return self.successful_actions / total
 
     def add_interaction(
-        self, role: str, content: str, empathy_level: int, metadata: dict | None = None
+        self,
+        role: str,
+        content: str,
+        empathy_level: int,
+        metadata: dict | None = None,
     ):
         """Add interaction to history"""
         self.interactions.append(
@@ -114,7 +114,7 @@ class CollaborationState:
                 content=content,
                 empathy_level=empathy_level,
                 metadata=metadata or {},
-            )
+            ),
         )
 
         # Track level history
@@ -122,12 +122,12 @@ class CollaborationState:
             self.level_history.append(empathy_level)
 
     def update_trust(self, outcome: str, magnitude: float = 1.0):
-        """
-        Update trust level based on action outcome.
+        """Update trust level based on action outcome.
 
         Args:
             outcome: "success" or "failure"
             magnitude: How much to adjust (0.0 to 1.0)
+
         """
         if outcome == "success":
             adjustment = 0.05 * magnitude
@@ -159,8 +159,7 @@ class CollaborationState:
         self.detected_patterns.append(pattern)
 
     def find_matching_pattern(self, trigger_text: str) -> UserPattern | None:
-        """
-        Find pattern that matches current input.
+        """Find pattern that matches current input.
 
         Returns pattern with highest confidence if found.
         """
@@ -177,10 +176,11 @@ class CollaborationState:
         return None
 
     def get_conversation_history(
-        self, max_turns: int = 10, include_metadata: bool = False
+        self,
+        max_turns: int = 10,
+        include_metadata: bool = False,
     ) -> list[dict[str, Any]]:
-        """
-        Get recent conversation history in LLM format.
+        """Get recent conversation history in LLM format.
 
         Args:
             max_turns: Maximum number of turns to include
@@ -188,17 +188,16 @@ class CollaborationState:
 
         Returns:
             List of {"role": "user/assistant", "content": "..."}
+
         """
         recent = self.interactions[-max_turns:] if max_turns else self.interactions
 
         if include_metadata:
             return [{"role": i.role, "content": i.content, "metadata": i.metadata} for i in recent]
-        else:
-            return [{"role": i.role, "content": i.content} for i in recent]
+        return [{"role": i.role, "content": i.content} for i in recent]
 
     def should_progress_to_level(self, level: int) -> bool:
-        """
-        Determine if system should progress to higher empathy level.
+        """Determine if system should progress to higher empathy level.
 
         Progression criteria:
         - Level 2: Immediate (guided questions always helpful)

empathy_llm_toolkit/wizards/__init__.py

@@ -0,0 +1,38 @@
+"""Empathy LLM Wizards - Canonical Examples
+
+Core wizard base class and canonical domain examples demonstrating
+the Empathy Framework's capabilities across different use cases.
+
+Included Wizards (3 canonical examples):
+1. HealthcareWizard - HIPAA-compliant medical assistant
+2. CustomerSupportWizard - Customer service and help desk
+3. TechnologyWizard - IT and software development operations
+
+Additional Wizards Available:
+For specialized domain wizards, install separate packages:
+- Healthcare (23 wizards): pip install empathy-healthcare-wizards
+- Tech & AI (16 wizards): pip install empathy-software-wizards
+- Business (12+ wizards): pip install empathy-business-wizards
+
+Or try the live dashboards:
+- Healthcare: https://healthcare.smartaimemory.com/static/dashboard.html
+- Tech & AI: https://wizards.smartaimemory.com/
+
+Copyright 2025 Smart AI Memory, LLC
+Licensed under Fair Source 0.9
+"""
+
+from .base_wizard import BaseWizard, WizardConfig
+from .customer_support_wizard import CustomerSupportWizard
+from .healthcare_wizard import HealthcareWizard
+from .technology_wizard import TechnologyWizard
+
+__all__ = [
+    # Base classes
+    "BaseWizard",
+    # Canonical domain examples
+    "CustomerSupportWizard",
+    "HealthcareWizard",
+    "TechnologyWizard",
+    "WizardConfig",
+]