empathy-framework 5.2.1__py3-none-any.whl → 5.4.0__py3-none-any.whl

empathy_os/platform_utils.py

@@ -1,265 +0,0 @@
-"""Cross-Platform Utilities for Empathy Framework
-
-Provides platform-independent utilities for:
-- File paths and directories
-- File encoding
-- Asyncio event loop handling
-- Environment detection
-
-Copyright 2025 Smart-AI-Memory
-Licensed under Fair Source License 0.9
-"""
-
-import asyncio
-import os
-import platform
-from pathlib import Path
-from typing import Any
-
-from empathy_os.config import _validate_file_path
-
-
-def is_windows() -> bool:
-    """Check if running on Windows."""
-    return platform.system() == "Windows"
-
-
-def is_macos() -> bool:
-    """Check if running on macOS."""
-    return platform.system() == "Darwin"
-
-
-def is_linux() -> bool:
-    """Check if running on Linux."""
-    return platform.system() == "Linux"
-
-
-def get_default_log_dir() -> Path:
-    """Get the default log directory for the current platform.
-
-    Returns:
-        Path: Platform-appropriate log directory
-        - Windows: %APPDATA%/empathy/logs
-        - macOS: ~/Library/Logs/empathy
-        - Linux: /var/log/empathy (if writable) or ~/.local/share/empathy/logs
-
-    """
-    if is_windows():
-        appdata = os.environ.get("APPDATA", os.path.expanduser("~"))
-        return Path(appdata) / "empathy" / "logs"
-    if is_macos():
-        return Path.home() / "Library" / "Logs" / "empathy"
-    # Linux and other Unix
-    var_log = Path("/var/log/empathy")
-    if var_log.exists() or (var_log.parent.exists() and os.access(var_log.parent, os.W_OK)):
-        return var_log
-    # Fallback to user directory
-    return Path.home() / ".local" / "share" / "empathy" / "logs"
-
-
-def get_default_data_dir() -> Path:
-    """Get the default data directory for the current platform.
-
-    Returns:
-        Path: Platform-appropriate data directory
-        - Windows: %APPDATA%/empathy
-        - macOS: ~/Library/Application Support/empathy
-        - Linux: ~/.local/share/empathy
-
-    """
-    if is_windows():
-        appdata = os.environ.get("APPDATA", os.path.expanduser("~"))
-        return Path(appdata) / "empathy"
-    if is_macos():
-        return Path.home() / "Library" / "Application Support" / "empathy"
-    # Linux and other Unix
-    xdg_data = os.environ.get("XDG_DATA_HOME", str(Path.home() / ".local" / "share"))
-    return Path(xdg_data) / "empathy"
-
-
-def get_default_config_dir() -> Path:
-    """Get the default configuration directory for the current platform.
-
-    Returns:
-        Path: Platform-appropriate config directory
-        - Windows: %APPDATA%/empathy
-        - macOS: ~/Library/Preferences/empathy
-        - Linux: ~/.config/empathy
-
-    """
-    if is_windows():
-        appdata = os.environ.get("APPDATA", os.path.expanduser("~"))
-        return Path(appdata) / "empathy"
-    if is_macos():
-        return Path.home() / "Library" / "Preferences" / "empathy"
-    # Linux and other Unix
-    xdg_config = os.environ.get("XDG_CONFIG_HOME", str(Path.home() / ".config"))
-    return Path(xdg_config) / "empathy"
-
-
-def get_default_cache_dir() -> Path:
-    """Get the default cache directory for the current platform.
-
-    Returns:
-        Path: Platform-appropriate cache directory
-        - Windows: %LOCALAPPDATA%/empathy/cache
-        - macOS: ~/Library/Caches/empathy
-        - Linux: ~/.cache/empathy
-
-    """
-    if is_windows():
-        localappdata = os.environ.get(
-            "LOCALAPPDATA",
-            os.environ.get("APPDATA", os.path.expanduser("~")),
-        )
-        return Path(localappdata) / "empathy" / "cache"
-    if is_macos():
-        return Path.home() / "Library" / "Caches" / "empathy"
-    # Linux and other Unix
-    xdg_cache = os.environ.get("XDG_CACHE_HOME", str(Path.home() / ".cache"))
-    return Path(xdg_cache) / "empathy"
-
-
-def setup_asyncio_policy() -> None:
-    """Configure asyncio event loop policy for the current platform.
-
-    On Windows, this uses WindowsSelectorEventLoopPolicy to avoid issues
-    with the default ProactorEventLoop, particularly with subprocesses
-    and certain network operations.
-
-    This should be called early in the application startup, before
-    any asyncio.run() calls.
-    """
-    if is_windows():
-        # Windows requires WindowsSelectorEventLoopPolicy for compatibility
-        # with many libraries and subprocess operations
-        asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())  # type: ignore[attr-defined]
-
-
-def safe_run_async(coro: Any, debug: bool = False) -> Any:
-    """Run an async coroutine with platform-appropriate event loop handling.
-
-    This is a cross-platform wrapper for asyncio.run() that handles
-    Windows-specific event loop requirements.
-
-    Args:
-        coro: Coroutine to run
-        debug: Enable asyncio debug mode
-
-    Returns:
-        Result of the coroutine
-
-    """
-    setup_asyncio_policy()
-    return asyncio.run(coro, debug=debug)
-
-
-def open_text_file(path: str | Path, mode: str = "r", **kwargs: Any):
-    """Open a text file with UTF-8 encoding by default.
-
-    This ensures consistent encoding across platforms, as Windows
-    defaults to cp1252 while Unix defaults to UTF-8.
-
-    Args:
-        path: File path to open
-        mode: File mode (r, w, a, etc.)
-        **kwargs: Additional arguments passed to open()
-
-    Returns:
-        File object
-
-    """
-    kwargs.setdefault("encoding", "utf-8")
-    return open(path, mode, **kwargs)
-
-
-def read_text_file(path: str | Path, encoding: str = "utf-8") -> str:
-    """Read a text file with UTF-8 encoding by default.
-
-    Args:
-        path: File path to read
-        encoding: File encoding (default: utf-8)
-
-    Returns:
-        File contents as string
-
-    """
-    return Path(path).read_text(encoding=encoding)
-
-
-def write_text_file(path: str | Path, content: str, encoding: str = "utf-8") -> int:
-    """Write content to a text file with UTF-8 encoding by default.
-
-    Args:
-        path: File path to write
-        content: Content to write
-        encoding: File encoding (default: utf-8)
-
-    Returns:
-        Number of characters written
-
-    """
-    validated_path = _validate_file_path(str(path))
-    result: int = validated_path.write_text(content, encoding=encoding)
-    return result
-
-
-def normalize_path(path: str | Path) -> Path:
-    """Normalize a path for the current platform.
-
-    Converts forward slashes to backslashes on Windows and
-    resolves any relative path components.
-
-    Args:
-        path: Path to normalize
-
-    Returns:
-        Normalized Path object
-
-    """
-    return Path(path).resolve()
-
-
-def get_temp_dir() -> Path:
-    """Get the system temporary directory.
-
-    Returns:
-        Path to the system temp directory
-
-    """
-    import tempfile
-
-    return Path(tempfile.gettempdir())
-
-
-def ensure_dir(path: str | Path) -> Path:
-    """Ensure a directory exists, creating it if necessary.
-
-    Args:
-        path: Directory path to ensure
-
-    Returns:
-        Path object for the directory
-
-    """
-    dir_path = Path(path)
-    dir_path.mkdir(parents=True, exist_ok=True)
-    return dir_path
-
-
-# Platform information for diagnostics
-PLATFORM_INFO = {
-    "system": platform.system(),
-    "release": platform.release(),
-    "version": platform.version(),
-    "machine": platform.machine(),
-    "python_version": platform.python_version(),
-    "is_windows": is_windows(),
-    "is_macos": is_macos(),
-    "is_linux": is_linux(),
-}
-
-
-def get_platform_info() -> dict:
-    """Get platform information for diagnostics."""
-    return PLATFORM_INFO.copy()

empathy_os/plugins/__init__.py

@@ -1,28 +0,0 @@
-"""Empathy Framework - Plugin System
-
-Enables modular extension of the Empathy Framework with domain-specific plugins.
-
-Copyright 2025 Smart AI Memory, LLC
-Licensed under Fair Source 0.9
-"""
-
-from .base import (
-    BasePlugin,
-    BaseWorkflow,
-    PluginError,
-    PluginLoadError,
-    PluginMetadata,
-    PluginValidationError,
-)
-from .registry import PluginRegistry, get_global_registry
-
-__all__ = [
-    "BasePlugin",
-    "BaseWorkflow",
-    "PluginError",
-    "PluginLoadError",
-    "PluginMetadata",
-    "PluginRegistry",
-    "PluginValidationError",
-    "get_global_registry",
-]

empathy_os/plugins/base.py

@@ -1,361 +0,0 @@
-"""Empathy Framework - Plugin System Base Classes
-
-This module provides the core abstractions for creating domain-specific plugins
-that extend the Empathy Framework.
-
-Copyright 2025 Smart AI Memory, LLC
-Licensed under Fair Source 0.9
-"""
-
-import logging
-from abc import ABC, abstractmethod
-from dataclasses import dataclass
-from datetime import datetime
-from typing import Any
-
-logger = logging.getLogger(__name__)
-
-
-@dataclass
-class PluginMetadata:
-    """Metadata about a plugin"""
-
-    name: str
-    version: str
-    domain: str
-    description: str
-    author: str
-    license: str
-    requires_core_version: str  # Minimum core framework version
-    dependencies: list[str] | None = None  # Additional package dependencies
-
-
-class BaseWorkflow(ABC):
-    """Universal base class for all workflows across all domains.
-
-    This replaces domain-specific base classes (BaseCoachWorkflow, etc.)
-    to provide a unified interface.
-
-    Design Philosophy:
-    - Domain-agnostic: Works for software, healthcare, finance, etc.
-    - Level-aware: Each workflow declares its empathy level
-    - Pattern-contributing: Workflows share learnings via pattern library
-    """
-
-    def __init__(self, name: str, domain: str, empathy_level: int, category: str | None = None):
-        """Initialize a workflow
-
-        Args:
-            name: Human-readable workflow name
-            domain: Domain this workflow belongs to (e.g., 'software', 'healthcare')
-            empathy_level: Which empathy level this workflow operates at (1-5)
-            category: Optional category within domain
-
-        """
-        self.name = name
-        self.domain = domain
-        self.empathy_level = empathy_level
-        self.category = category
-        self.logger = logging.getLogger(f"workflow.{domain}.{name}")
-
-    @abstractmethod
-    async def analyze(self, context: dict[str, Any]) -> dict[str, Any]:
-        """Analyze the given context and return results.
-
-        This is the main entry point for all workflows. The context structure
-        is domain-specific but the return format should follow a standard pattern.
-        Subclasses must implement domain-specific analysis logic that aligns with
-        the workflow's empathy level.
-
-        Args:
-            context: dict[str, Any]
-                Domain-specific context dictionary. Must contain all fields returned
-                by get_required_context(). Examples:
-                - Software: {'code': str, 'file_path': str, 'language': str}
-                - Healthcare: {'patient_id': str, 'vitals': dict, 'medications': list}
-                - Finance: {'transactions': list, 'account': dict, 'period': str}
-
-        Returns:
-            dict[str, Any]
-                Analysis results dictionary containing:
-                - 'issues': list[dict] - Current issues found (Levels 1-3 analysis)
-                - 'predictions': list[dict] - Future issues predicted (Level 4 analysis)
-                - 'recommendations': list[dict] - Actionable next steps
-                - 'patterns': list[str] - Patterns detected for the pattern library
-                - 'confidence': float - Confidence score between 0.0 and 1.0
-                - 'workflow': str - Name of the workflow that performed analysis
-                - 'empathy_level': int - Empathy level of this analysis (1-5)
-                - 'timestamp': str - ISO format timestamp of analysis
-
-        Raises:
-            ValueError: If context is invalid or missing required fields
-            RuntimeError: If analysis fails due to domain-specific errors
-            TimeoutError: If analysis takes too long to complete
-
-        Note:
-            - Validate context using self.validate_context() at the beginning
-            - Each issue/prediction should include 'severity', 'description', 'affected_component'
-            - Use self.contribute_patterns() to extract learnings for the pattern library
-            - Confidence scores should reflect uncertainty in the analysis
-            - This method is async to support long-running analyses
-
-        """
-
-    @abstractmethod
-    def get_required_context(self) -> list[str]:
-        """Declare what context fields this workflow needs.
-
-        This method defines the contract between the caller and the workflow.
-        The caller must provide all declared fields before calling analyze().
-        This enables validation via validate_context() and helps with introspection.
-
-        Returns:
-            list[str]
-                List of required context field names (keys). Each string should be
-                a simple identifier that matches the keys in context dictionaries
-                passed to analyze().
-
-        Examples:
-            Software workflow returns: ['code', 'file_path', 'language']
-            Healthcare workflow returns: ['patient_id', 'vitals', 'medications']
-            Finance workflow returns: ['transactions', 'account_id', 'period']
-
-        Note:
-            - Must return at least one field (even if minimal)
-            - Field names should match exactly what analyze() expects in context
-            - Order is not significant but consistency helps with documentation
-            - Consider validation requirements when declaring fields
-            - Used by validate_context() to check required fields before analyze()
-
-        """
-
-    def validate_context(self, context: dict[str, Any]) -> bool:
-        """Validate that context contains required fields.
-
-        Args:
-            context: Context to validate
-
-        Returns:
-            True if valid, raises ValueError if invalid
-
-        """
-        required = self.get_required_context()
-        missing = [key for key in required if key not in context]
-
-        if missing:
-            raise ValueError(f"Workflow '{self.name}' missing required context: {missing}")
-
-        return True
-
-    def get_empathy_level(self) -> int:
-        """Get the empathy level this workflow operates at"""
-        return self.empathy_level
-
-    def contribute_patterns(self, analysis_result: dict[str, Any]) -> dict[str, Any]:
-        """Extract patterns from analysis for the shared pattern library.
-
-        This enables cross-domain learning (Level 5 Systems Empathy).
-
-        Args:
-            analysis_result: Result from analyze()
-
-        Returns:
-            Dictionary of patterns in standard format
-
-        """
-        # Default implementation - override for custom pattern extraction
-        return {
-            "workflow": self.name,
-            "domain": self.domain,
-            "timestamp": datetime.now().isoformat(),
-            "patterns": analysis_result.get("patterns", []),
-        }
-
-
-class BasePlugin(ABC):
-    """Base class for domain plugins.
-
-    A plugin is a collection of workflows and patterns for a specific domain.
-
-    Example:
-        - SoftwarePlugin: 16+ coach workflows for code analysis
-        - HealthcarePlugin: Clinical and compliance workflows
-        - FinancePlugin: Fraud detection, compliance workflows
-
-    """
-
-    def __init__(self):
-        self.logger = logging.getLogger(f"plugin.{self.get_metadata().domain}")
-        self._workflows: dict[str, type[BaseWorkflow]] = {}
-        self._initialized = False
-
-    @abstractmethod
-    def get_metadata(self) -> PluginMetadata:
-        """Return metadata about this plugin.
-
-        This method provides essential information about the plugin that the
-        framework uses for loading, validation, and discovery. It must return
-        consistent metadata across multiple calls.
-
-        Returns:
-            PluginMetadata
-                A PluginMetadata instance containing:
-                - name: str - Human-readable plugin name (e.g., 'Software Plugin')
-                - version: str - Semantic version string (e.g., '1.0.0')
-                - domain: str - Domain this plugin serves (e.g., 'software', 'healthcare')
-                - description: str - Brief description of plugin functionality
-                - author: str - Plugin author or organization name
-                - license: str - License identifier (e.g., 'Apache-2.0', 'MIT')
-                - requires_core_version: str - Minimum core framework version (e.g., '1.0.0')
-                - dependencies: list[str] - Optional list of required packages
-
-        Note:
-            - Called during plugin initialization to validate compatibility
-            - Used for plugin discovery and listing
-            - Should be immutable (return same values each call)
-            - Version should follow semantic versioning
-            - Domain names should be lowercase and consistent across plugins
-            - Core version requirement ensures framework compatibility
-
-        """
-
-    @abstractmethod
-    def register_workflows(self) -> dict[str, type[BaseWorkflow]]:
-        """Register all workflows provided by this plugin.
-
-        This method defines all analysis workflows available in this plugin.
-        Workflows are lazy-instantiated by get_workflow() when first requested.
-        This method is called during plugin initialization.
-
-        Returns:
-            dict[str, type[BaseWorkflow]]
-                Dictionary mapping workflow identifiers to Workflow classes (not instances).
-                Keys should be lowercase, snake_case identifiers. Values should be
-                uninstantiated class references.
-
-        Returns:
-            dict[str, type[BaseWorkflow]]
-                Mapping structure:
-                {
-                    'workflow_id': WorkflowClass,
-                    'another_workflow': AnotherWorkflowClass,
-                    ...
-                }
-
-        Example:
-            Software plugin might return:
-            {
-                'security': SecurityWorkflow,
-                'performance': PerformanceWorkflow,
-                'maintainability': MaintainabilityWorkflow,
-                'accessibility': AccessibilityWorkflow,
-            }
-
-        Note:
-            - Return only the class, not instances (instantiation is lazy)
-            - Use consistent, descriptive workflow IDs
-            - All returned classes must be subclasses of BaseWorkflow
-            - Can return empty dict {} if plugin provides no workflows initially
-            - Called once during initialization via initialize()
-            - Framework caches results in self._workflows
-
-        """
-
-    def register_patterns(self) -> dict[str, Any]:
-        """Register domain-specific patterns for the pattern library.
-
-        Returns:
-            Dictionary of patterns in standard format
-
-        """
-        # Optional - override if plugin provides pre-built patterns
-        return {}
-
-    def initialize(self) -> None:
-        """Initialize the plugin (lazy initialization).
-
-        Called once before first use. Override to perform setup:
-        - Load configuration
-        - Initialize domain-specific services
-        - Validate dependencies
-        """
-        if self._initialized:
-            return
-
-        self.logger.info(f"Initializing plugin: {self.get_metadata().name}")
-
-        # Register workflows
-        self._workflows = self.register_workflows()
-
-        self.logger.info(
-            f"Plugin '{self.get_metadata().name}' initialized with {len(self._workflows)} workflows",
-        )
-
-        self._initialized = True
-
-    def get_workflow(self, workflow_id: str) -> type[BaseWorkflow] | None:
-        """Get a workflow by ID.
-
-        Args:
-            workflow_id: Workflow identifier
-
-        Returns:
-            Workflow class or None if not found
-
-        """
-        if not self._initialized:
-            self.initialize()
-
-        return self._workflows.get(workflow_id)
-
-    def list_workflows(self) -> list[str]:
-        """List all workflow IDs provided by this plugin.
-
-        Returns:
-            List of workflow identifiers
-
-        """
-        if not self._initialized:
-            self.initialize()
-
-        return list(self._workflows.keys())
-
-    def get_workflow_info(self, workflow_id: str) -> dict[str, Any] | None:
-        """Get information about a workflow without instantiating it.
-
-        Args:
-            workflow_id: Workflow identifier
-
-        Returns:
-            Dictionary with workflow metadata
-
-        """
-        workflow_class = self.get_workflow(workflow_id)
-        if not workflow_class:
-            return None
-
-        # Create temporary instance to get metadata
-        # (workflows should be lightweight to construct)
-        # Subclasses provide their own defaults for name, domain, empathy_level
-        temp_instance = workflow_class()  # type: ignore[call-arg]
-
-        return {
-            "id": workflow_id,
-            "name": temp_instance.name,
-            "domain": temp_instance.domain,
-            "empathy_level": temp_instance.empathy_level,
-            "category": temp_instance.category,
-            "required_context": temp_instance.get_required_context(),
-        }
-
-
-class PluginError(Exception):
-    """Base exception for plugin-related errors"""
-
-
-class PluginLoadError(PluginError):
-    """Raised when plugin fails to load"""
-
-
-class PluginValidationError(PluginError):
-    """Raised when plugin fails validation"""