empathy-framework 4.6.6__py3-none-any.whl → 4.7.0__py3-none-any.whl

empathy_os/hot_reload/reloader.py

@@ -1,6 +1,6 @@
-"""Dynamic wizard reloader for hot-reload.
+"""Dynamic workflow reloader for hot-reload.
 
-Handles reloading wizard modules without server restart.
+Handles reloading workflow modules without server restart.
 
 Copyright 2025 Smart AI Memory, LLC
 Licensed under Fair Source 0.9
@@ -17,12 +17,12 @@ logger = logging.getLogger(__name__)
 
 
 class ReloadResult:
-    """Result of a wizard reload operation."""
+    """Result of a workflow reload operation."""
 
     def __init__(
         self,
         success: bool,
-        wizard_id: str,
+        workflow_id: str,
         message: str,
         error: str | None = None,
     ):
@@ -30,13 +30,13 @@ class ReloadResult:
 
         Args:
             success: Whether reload succeeded
-            wizard_id: ID of wizard that was reloaded
+            workflow_id: ID of workflow that was reloaded
             message: Status message
             error: Error message if failed
 
         """
         self.success = success
-        self.wizard_id = wizard_id
+        self.workflow_id = workflow_id
         self.message = message
         self.error = error
 
@@ -44,19 +44,19 @@ class ReloadResult:
         """Convert to dictionary."""
         return {
             "success": self.success,
-            "wizard_id": self.wizard_id,
+            "workflow_id": self.workflow_id,
             "message": self.message,
             "error": self.error,
         }
 
 
-class WizardReloader:
-    """Handles dynamic reloading of wizard modules.
+class WorkflowReloader:
+    """Handles dynamic reloading of workflow modules.
 
-    Supports hot-reload of wizards without server restart by:
+    Supports hot-reload of workflows without server restart by:
     1. Unloading old module from sys.modules
     2. Reloading module with importlib
-    3. Re-registering wizard with wizard API
+    3. Re-registering workflow with workflow API
     4. Notifying clients via callback
     """
 
@@ -68,7 +68,7 @@ class WizardReloader:
         """Initialize reloader.
 
         Args:
-            register_callback: Function to register wizard (wizard_id, wizard_class) -> success
+            register_callback: Function to register workflow (workflow_id, workflow_class) -> success
             notification_callback: Optional function to notify clients of reload events
 
         """
@@ -76,18 +76,18 @@ class WizardReloader:
         self.notification_callback = notification_callback
         self._reload_count = 0
 
-    def reload_wizard(self, wizard_id: str, file_path: str) -> ReloadResult:
-        """Reload a wizard module.
+    def reload_workflow(self, workflow_id: str, file_path: str) -> ReloadResult:
+        """Reload a workflow module.
 
         Args:
-            wizard_id: Wizard identifier
-            file_path: Path to wizard file
+            workflow_id: Workflow identifier
+            file_path: Path to workflow file
 
         Returns:
             ReloadResult with outcome
 
         """
-        logger.info(f"Attempting to reload wizard: {wizard_id} from {file_path}")
+        logger.info(f"Attempting to reload workflow: {workflow_id} from {file_path}")
 
         try:
             # Get module name from file path
@@ -97,7 +97,7 @@ class WizardReloader:
                 logger.error(error_msg)
                 return ReloadResult(
                     success=False,
-                    wizard_id=wizard_id,
+                    workflow_id=workflow_id,
                     message="Failed to reload",
                     error=error_msg,
                 )
@@ -111,60 +111,60 @@ class WizardReloader:
             except ImportError as e:
                 error_msg = f"Failed to import module {module_name}: {e}"
                 logger.error(error_msg)
-                self._notify_reload_failed(wizard_id, error_msg)
+                self._notify_reload_failed(workflow_id, error_msg)
                 return ReloadResult(
                     success=False,
-                    wizard_id=wizard_id,
+                    workflow_id=workflow_id,
                     message="Import failed",
                     error=error_msg,
                 )
 
-            # Find wizard class in module
-            wizard_class = self._find_wizard_class(module)
-            if not wizard_class:
-                error_msg = f"No wizard class found in {module_name}"
+            # Find workflow class in module
+            workflow_class = self._find_workflow_class(module)
+            if not workflow_class:
+                error_msg = f"No workflow class found in {module_name}"
                 logger.error(error_msg)
-                self._notify_reload_failed(wizard_id, error_msg)
+                self._notify_reload_failed(workflow_id, error_msg)
                 return ReloadResult(
                     success=False,
-                    wizard_id=wizard_id,
-                    message="No wizard class found",
+                    workflow_id=workflow_id,
+                    message="No workflow class found",
                     error=error_msg,
                 )
 
-            # Re-register wizard
-            success = self.register_callback(wizard_id, wizard_class)
+            # Re-register workflow
+            success = self.register_callback(workflow_id, workflow_class)
 
             if success:
                 self._reload_count += 1
                 logger.info(
-                    f"✓ Successfully reloaded {wizard_id} ({self._reload_count} total reloads)"
+                    f"✓ Successfully reloaded {workflow_id} ({self._reload_count} total reloads)"
                 )
-                self._notify_reload_success(wizard_id)
+                self._notify_reload_success(workflow_id)
 
                 return ReloadResult(
                     success=True,
-                    wizard_id=wizard_id,
+                    workflow_id=workflow_id,
                     message=f"Reloaded successfully (reload #{self._reload_count})",
                 )
             else:
                 error_msg = "Registration failed"
-                logger.error(f"Failed to re-register {wizard_id}")
-                self._notify_reload_failed(wizard_id, error_msg)
+                logger.error(f"Failed to re-register {workflow_id}")
+                self._notify_reload_failed(workflow_id, error_msg)
                 return ReloadResult(
                     success=False,
-                    wizard_id=wizard_id,
+                    workflow_id=workflow_id,
                     message="Registration failed",
                     error=error_msg,
                 )
 
         except Exception as e:
-            error_msg = f"Unexpected error reloading {wizard_id}: {e}"
+            error_msg = f"Unexpected error reloading {workflow_id}: {e}"
             logger.exception(error_msg)
-            self._notify_reload_failed(wizard_id, str(e))
+            self._notify_reload_failed(workflow_id, str(e))
             return ReloadResult(
                 success=False,
-                wizard_id=wizard_id,
+                workflow_id=workflow_id,
                 message="Unexpected error",
                 error=str(e),
             )
@@ -187,17 +187,17 @@ class WizardReloader:
                 return None
 
             # Get parts relative to project root
-            # Try to find common patterns: wizards/, coach_wizards/, empathy_software_plugin/wizards/
+            # Try to find common patterns: workflows/, empathy_software_plugin/workflows/
             parts = path.parts
 
-            # Find wizard directory in path
-            wizard_dir_indices = [i for i, part in enumerate(parts) if "wizard" in part.lower()]
+            # Find workflow directory in path
+            workflow_dir_indices = [i for i, part in enumerate(parts) if "workflow" in part.lower()]
 
-            if not wizard_dir_indices:
+            if not workflow_dir_indices:
                 return None
 
-            # Take from first wizard directory
-            start_idx = wizard_dir_indices[0]
+            # Take from first workflow directory
+            start_idx = workflow_dir_indices[0]
 
             # Build module name
             module_parts = list(parts[start_idx:])
@@ -228,38 +228,38 @@ class WizardReloader:
             del sys.modules[submodule]
             logger.debug(f"Unloaded submodule: {submodule}")
 
-    def _find_wizard_class(self, module: Any) -> type | None:
-        """Find wizard class in module.
+    def _find_workflow_class(self, module: Any) -> type | None:
+        """Find workflow class in module.
 
         Args:
             module: Python module
 
         Returns:
-            Wizard class or None if not found
+            Workflow class or None if not found
 
         """
-        # Look for classes ending with "Wizard"
+        # Look for classes ending with "Workflow"
         for name in dir(module):
-            if name.endswith("Wizard") and not name.startswith("_"):
+            if name.endswith("Workflow") and not name.startswith("_"):
                 attr = getattr(module, name)
                 if isinstance(attr, type):
                     return attr
 
         return None
 
-    def _notify_reload_success(self, wizard_id: str) -> None:
+    def _notify_reload_success(self, workflow_id: str) -> None:
         """Notify clients of successful reload.
 
         Args:
-            wizard_id: ID of reloaded wizard
+            workflow_id: ID of reloaded workflow
 
         """
         if self.notification_callback:
             try:
                 self.notification_callback(
                     {
-                        "event": "wizard_reloaded",
-                        "wizard_id": wizard_id,
+                        "event": "workflow_reloaded",
+                        "workflow_id": workflow_id,
                         "success": True,
                         "reload_count": self._reload_count,
                     }
@@ -267,11 +267,11 @@ class WizardReloader:
             except Exception as e:
                 logger.error(f"Error sending reload notification: {e}")
 
-    def _notify_reload_failed(self, wizard_id: str, error: str) -> None:
+    def _notify_reload_failed(self, workflow_id: str, error: str) -> None:
         """Notify clients of failed reload.
 
         Args:
-            wizard_id: ID of wizard that failed to reload
+            workflow_id: ID of workflow that failed to reload
             error: Error message
 
         """
@@ -279,8 +279,8 @@ class WizardReloader:
             try:
                 self.notification_callback(
                     {
-                        "event": "wizard_reload_failed",
-                        "wizard_id": wizard_id,
+                        "event": "workflow_reload_failed",
+                        "workflow_id": workflow_id,
                         "success": False,
                         "error": error,
                     }

empathy_os/hot_reload/watcher.py

@@ -1,6 +1,6 @@
-"""File system watcher for wizard hot-reload.
+"""File system watcher for workflow hot-reload.
 
-Monitors wizard directories for changes and triggers reloads.
+Monitors workflow directories for changes and triggers reloads.
 
 Copyright 2025 Smart AI Memory, LLC
 Licensed under Fair Source 0.9
@@ -16,14 +16,14 @@ from watchdog.observers import Observer
 logger = logging.getLogger(__name__)
 
 
-class WizardFileHandler(FileSystemEventHandler):
-    """Handles file system events for wizard files."""
+class WorkflowFileHandler(FileSystemEventHandler):
+    """Handles file system events for workflow files."""
 
     def __init__(self, reload_callback: Callable[[str, str], None]):
         """Initialize handler.
 
         Args:
-            reload_callback: Function to call when wizard file changes (wizard_id, file_path)
+            reload_callback: Function to call when workflow file changes (workflow_id, file_path)
 
         """
         super().__init__()
@@ -61,24 +61,24 @@ class WizardFileHandler(FileSystemEventHandler):
         try:
             self._processing.add(file_path)
 
-            wizard_id = self._extract_wizard_id(file_path)
-            if wizard_id:
-                logger.info(f"Detected change in {wizard_id} ({file_path})")
-                self.reload_callback(wizard_id, file_path)
+            workflow_id = self._extract_workflow_id(file_path)
+            if workflow_id:
+                logger.info(f"Detected change in {workflow_id} ({file_path})")
+                self.reload_callback(workflow_id, file_path)
 
         except Exception as e:
             logger.error(f"Error processing file change {file_path}: {e}")
         finally:
             self._processing.discard(file_path)
 
-    def _extract_wizard_id(self, file_path: str) -> str | None:
-        """Extract wizard ID from file path.
+    def _extract_workflow_id(self, file_path: str) -> str | None:
+        """Extract workflow ID from file path.
 
         Args:
-            file_path: Path to wizard file
+            file_path: Path to workflow file
 
         Returns:
-            Wizard ID or None if cannot extract
+            Workflow ID or None if cannot extract
 
         """
         path = Path(file_path)
@@ -87,43 +87,43 @@ class WizardFileHandler(FileSystemEventHandler):
         filename = path.stem
 
         # Remove common suffixes
-        wizard_id = filename.replace("_wizard", "").replace("wizard_", "")
+        workflow_id = filename.replace("_workflow", "").replace("workflow_", "")
 
-        # Convert to wizard ID format (snake_case)
-        wizard_id = wizard_id.lower()
+        # Convert to workflow ID format (snake_case)
+        workflow_id = workflow_id.lower()
 
-        return wizard_id if wizard_id else None
+        return workflow_id if workflow_id else None
 
 
-class WizardFileWatcher:
-    """Watches wizard directories for file changes.
+class WorkflowFileWatcher:
+    """Watches workflow directories for file changes.
 
     Monitors specified directories and triggers reload callbacks
-    when wizard files are modified.
+    when workflow files are modified.
     """
 
-    def __init__(self, wizard_dirs: list[Path], reload_callback: Callable[[str, str], None]):
+    def __init__(self, workflow_dirs: list[Path], reload_callback: Callable[[str, str], None]):
         """Initialize watcher.
 
         Args:
-            wizard_dirs: List of directories to watch
-            reload_callback: Function to call on file changes (wizard_id, file_path)
+            workflow_dirs: List of directories to watch
+            reload_callback: Function to call on file changes (workflow_id, file_path)
 
         """
-        self.wizard_dirs = [Path(d) for d in wizard_dirs]
+        self.workflow_dirs = [Path(d) for d in workflow_dirs]
         self.reload_callback = reload_callback
         self.observer = Observer()
-        self.event_handler = WizardFileHandler(reload_callback)
+        self.event_handler = WorkflowFileHandler(reload_callback)
         self._running = False
 
     def start(self) -> None:
-        """Start watching wizard directories."""
+        """Start watching workflow directories."""
         if self._running:
             logger.warning("Watcher already running")
             return
 
         valid_dirs = []
-        for directory in self.wizard_dirs:
+        for directory in self.workflow_dirs:
             if not directory.exists():
                 logger.warning(f"Directory does not exist: {directory}")
                 continue
@@ -154,7 +154,7 @@ class WizardFileWatcher:
         )
 
     def stop(self) -> None:
-        """Stop watching wizard directories."""
+        """Stop watching workflow directories."""
         if not self._running:
             return
 

empathy_os/hot_reload/websocket.py

@@ -1,6 +1,6 @@
 """WebSocket notification system for hot-reload events.
 
-Notifies connected clients when wizards are reloaded.
+Notifies connected clients when workflows are reloaded.
 
 Copyright 2025 Smart AI Memory, LLC
 Licensed under Fair Source 0.9
@@ -143,7 +143,7 @@ def get_notification_manager() -> ReloadNotificationManager:
 
 
 def create_notification_callback() -> Callable[[dict[str, Any]], None]:
-    """Create a callback function for the wizard reloader.
+    """Create a callback function for the workflow reloader.
 
     Returns:
         Callback function that broadcasts notifications

empathy_os/memory/__init__.py

@@ -79,8 +79,11 @@ from .cross_session import (
     generate_agent_id,
 )
 
-# Memory Graph (Cross-Wizard Intelligence)
-from .edges import REVERSE_EDGE_TYPES, WIZARD_EDGE_PATTERNS, Edge, EdgeType
+# Memory Graph (Cross-Workflow Intelligence)
+from .edges import REVERSE_EDGE_TYPES, WORKFLOW_EDGE_PATTERNS, Edge, EdgeType
+
+# File-based session memory (always available, no Redis required)
+from .file_session import FileSessionConfig, FileSessionMemory, get_file_session_memory
 from .graph import MemoryGraph
 
 # Long-term memory (Persistent patterns)
@@ -137,7 +140,7 @@ from .unified import Environment, MemoryConfig, UnifiedMemory
 
 __all__ = [
     "REVERSE_EDGE_TYPES",
-    "WIZARD_EDGE_PATTERNS",
+    "WORKFLOW_EDGE_PATTERNS",
     "AccessTier",
     "AgentContext",
     "AgentCredentials",
@@ -152,6 +155,10 @@ __all__ = [
     # Claude Memory
     "ClaudeMemoryConfig",
     "ClaudeMemoryLoader",
+    # File Session Memory (always available)
+    "FileSessionConfig",
+    "FileSessionMemory",
+    "get_file_session_memory",
     "ConflictContext",
     "ConflictResult",
     "ConflictStrategy",
@@ -167,7 +174,7 @@ __all__ = [
     "MemoryConfig",
     # Control Panel
     "MemoryControlPanel",
-    # Memory Graph (Cross-Wizard Intelligence)
+    # Memory Graph (Cross-Workflow Intelligence)
     "MemoryGraph",
     "MemoryPermissionError",
     "MemoryStats",

empathy_os/memory/claude_memory.py

@@ -405,7 +405,7 @@ This project uses the Empathy Framework for AI-powered software development assi
 
 ## Testing Standards
 - Maintain 90%+ test coverage
-- Write tests for all wizards
+- Write tests for all workflows
 - Use pytest fixtures for common setup
 - Mock external API calls
 

empathy_os/memory/cross_session.py

@@ -31,11 +31,7 @@ from typing import Any
 
 import structlog
 
-from .short_term import (
-    AccessTier,
-    AgentCredentials,
-    RedisShortTermMemory,
-)
+from .short_term import AccessTier, AgentCredentials, RedisShortTermMemory
 
 logger = structlog.get_logger(__name__)
 
@@ -571,8 +567,8 @@ class CrossSessionCoordinator:
 
         if owner:
             if isinstance(owner, bytes):
-                owner = owner.decode()
-            return owner
+                return owner.decode()
+            return str(owner)
 
         return None
 
@@ -618,12 +614,12 @@ class CrossSessionCoordinator:
 
                 if event.get("event") == "session_joined":
                     session_info = SessionInfo.from_dict(event["session"])
-                    for handler in self._on_session_joined:
-                        handler(session_info)
+                    for joined_handler in self._on_session_joined:
+                        joined_handler(session_info)
                 elif event.get("event") == "session_left":
                     agent_id = event["agent_id"]
-                    for handler in self._on_session_left:
-                        handler(agent_id)
+                    for left_handler in self._on_session_left:
+                        left_handler(agent_id)
             except (json.JSONDecodeError, KeyError, ValueError) as e:
                 logger.warning("invalid_session_event", error=str(e))
 
@@ -800,7 +796,7 @@ class BackgroundService:
         Returns:
             Dict with service status information
         """
-        status = {
+        status: dict[str, Any] = {
             "running": self._running,
             "agent_id": self._coordinator.agent_id if self._coordinator else None,
             "active_sessions": 0,

empathy_os/memory/edges.py

@@ -1,7 +1,7 @@
 """Memory Graph Edge Types
 
 Defines edge types for connecting nodes in the knowledge graph.
-Edges represent relationships between entities discovered by wizards.
+Edges represent relationships between entities discovered by workflows.
 
 Copyright 2025 Smart AI Memory, LLC
 Licensed under Fair Source 0.9
@@ -74,7 +74,7 @@ class Edge:
 
     # Context
     description: str = ""
-    source_wizard: str = ""
+    source_workflow: str = ""
 
     # Additional data
     metadata: dict[str, Any] = field(default_factory=dict)
@@ -91,7 +91,7 @@ class Edge:
             "weight": self.weight,
             "confidence": self.confidence,
             "description": self.description,
-            "source_wizard": self.source_wizard,
+            "source_workflow": self.source_workflow,
             "metadata": self.metadata,
             "created_at": self.created_at.isoformat(),
         }
@@ -106,7 +106,7 @@ class Edge:
             weight=data.get("weight", 1.0),
             confidence=data.get("confidence", 1.0),
             description=data.get("description", ""),
-            source_wizard=data.get("source_wizard", ""),
+            source_workflow=data.get("source_workflow", data.get("source_wizard", "")),
             metadata=data.get("metadata", {}),
             created_at=(
                 datetime.fromisoformat(data["created_at"])
@@ -121,8 +121,8 @@ class Edge:
         return f"{self.source_id}-{self.type.value}-{self.target_id}"
 
 
-# Common edge patterns for wizard findings
-WIZARD_EDGE_PATTERNS = {
+# Common edge patterns for workflow findings
+WORKFLOW_EDGE_PATTERNS = {
     "security-audit": [
         (EdgeType.CAUSES, "vulnerability → vulnerability"),
         (EdgeType.FIXED_BY, "vulnerability → fix"),