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

empathy_os/config/xml_config.py

@@ -0,0 +1,239 @@
+"""Configuration system for XML-enhanced prompting features.
+
+Provides feature flags and settings for all 6 XML enhancement options:
+1. Workflow migration settings
+2. XML schema validation
+3. Prompt metrics tracking
+4. Context window optimization
+5. Dynamic prompt adaptation
+6. Multi-language support
+
+Copyright 2026 Smart-AI-Memory
+Licensed under Fair Source License 0.9
+"""
+
+import json
+import os
+from dataclasses import asdict, dataclass, field
+from pathlib import Path
+
+
+@dataclass
+class XMLConfig:
+    """XML prompting configuration.
+
+    Controls XML-enhanced prompt behavior and validation.
+    """
+
+    use_xml_structure: bool = True  # Default to XML prompts
+    validate_schemas: bool = False  # Feature flag for validation
+    schema_dir: str = ".empathy/schemas"
+    strict_validation: bool = False  # Fail on validation errors
+
+
+@dataclass
+class OptimizationConfig:
+    """Context window optimization configuration.
+
+    Controls prompt compression and token reduction strategies.
+    """
+
+    compression_level: str = "moderate"  # none, light, moderate, aggressive
+    use_short_tags: bool = True
+    strip_whitespace: bool = True
+    cache_system_prompts: bool = True
+    max_context_tokens: int = 8000
+
+
+@dataclass
+class AdaptiveConfig:
+    """Adaptive prompting configuration.
+
+    Controls dynamic model tier and compression selection based on task complexity.
+    """
+
+    enable_adaptation: bool = True
+    model_tier_mapping: dict[str, str] = field(
+        default_factory=lambda: {
+            "simple": "gpt-3.5-turbo",
+            "moderate": "gpt-4",
+            "complex": "gpt-4",
+            "very_complex": "gpt-4-turbo-preview",
+        }
+    )
+    complexity_thresholds: dict[str, int] = field(
+        default_factory=lambda: {
+            "simple_tokens": 100,
+            "moderate_tokens": 500,
+            "complex_tokens": 2000,
+        }
+    )
+
+
+@dataclass
+class I18nConfig:
+    """Internationalization configuration.
+
+    Controls multi-language support for XML prompts.
+    """
+
+    default_language: str = "en"
+    translate_tags: bool = False  # Keep tags in English by default
+    translate_content: bool = True
+    fallback_to_english: bool = True
+    translation_dir: str = ".empathy/translations"
+
+
+@dataclass
+class MetricsConfig:
+    """Metrics tracking configuration.
+
+    Controls prompt performance metrics collection and storage.
+    """
+
+    enable_tracking: bool = True
+    metrics_file: str = ".empathy/prompt_metrics.json"
+    track_token_usage: bool = True
+    track_latency: bool = True
+    track_retries: bool = True
+    track_parsing_success: bool = True
+
+
+@dataclass
+class EmpathyXMLConfig:
+    """Main Empathy XML enhancement configuration.
+
+    Combines all feature configurations with centralized management.
+
+    Usage:
+        config = EmpathyXMLConfig.load_from_file()
+        if config.xml.use_xml_structure:
+            use_xml_prompts()
+
+        # Or create custom config
+        config = EmpathyXMLConfig(
+            xml=XMLConfig(validate_schemas=True),
+            metrics=MetricsConfig(enable_tracking=True)
+        )
+        config.save_to_file()
+    """
+
+    xml: XMLConfig = field(default_factory=XMLConfig)
+    optimization: OptimizationConfig = field(default_factory=OptimizationConfig)
+    adaptive: AdaptiveConfig = field(default_factory=AdaptiveConfig)
+    i18n: I18nConfig = field(default_factory=I18nConfig)
+    metrics: MetricsConfig = field(default_factory=MetricsConfig)
+
+    @classmethod
+    def load_from_file(cls, config_file: str = ".empathy/config.json") -> "EmpathyXMLConfig":
+        """Load configuration from JSON file.
+
+        Args:
+            config_file: Path to config file (default: .empathy/config.json)
+
+        Returns:
+            EmpathyXMLConfig instance loaded from file, or default config if file doesn't exist
+        """
+        path = Path(config_file)
+
+        if not path.exists():
+            # Return default config if file doesn't exist
+            return cls()
+
+        try:
+            with open(path) as f:
+                data = json.load(f)
+
+            # Reconstruct nested dataclasses
+            return cls(
+                xml=XMLConfig(**data.get("xml", {})),
+                optimization=OptimizationConfig(**data.get("optimization", {})),
+                adaptive=AdaptiveConfig(**data.get("adaptive", {})),
+                i18n=I18nConfig(**data.get("i18n", {})),
+                metrics=MetricsConfig(**data.get("metrics", {})),
+            )
+        except Exception as e:
+            # Return default config on error
+            print(f"Warning: Failed to load config from {config_file}: {e}")
+            return cls()
+
+    def save_to_file(self, config_file: str = ".empathy/config.json") -> None:
+        """Save configuration to JSON file.
+
+        Args:
+            config_file: Path to save config (default: .empathy/config.json)
+        """
+        path = Path(config_file)
+        path.parent.mkdir(parents=True, exist_ok=True)
+
+        data = {
+            "xml": asdict(self.xml),
+            "optimization": asdict(self.optimization),
+            "adaptive": asdict(self.adaptive),
+            "i18n": asdict(self.i18n),
+            "metrics": asdict(self.metrics),
+        }
+
+        with open(path, "w") as f:
+            json.dump(data, f, indent=2)
+
+    @classmethod
+    def from_env(cls) -> "EmpathyXMLConfig":
+        """Load configuration from environment variables.
+
+        Environment variables:
+            EMPATHY_XML_ENABLED: Enable XML prompts (default: true)
+            EMPATHY_VALIDATION_ENABLED: Enable schema validation (default: false)
+            EMPATHY_METRICS_ENABLED: Enable metrics tracking (default: true)
+            EMPATHY_OPTIMIZATION_LEVEL: Compression level (default: moderate)
+            EMPATHY_ADAPTIVE_ENABLED: Enable adaptive prompts (default: true)
+
+        Returns:
+            EmpathyXMLConfig with settings from environment variables
+        """
+        return cls(
+            xml=XMLConfig(
+                use_xml_structure=os.getenv("EMPATHY_XML_ENABLED", "true").lower() == "true",
+                validate_schemas=os.getenv("EMPATHY_VALIDATION_ENABLED", "false").lower() == "true",
+            ),
+            optimization=OptimizationConfig(
+                compression_level=os.getenv("EMPATHY_OPTIMIZATION_LEVEL", "moderate"),
+            ),
+            adaptive=AdaptiveConfig(
+                enable_adaptation=os.getenv("EMPATHY_ADAPTIVE_ENABLED", "true").lower() == "true",
+            ),
+            metrics=MetricsConfig(
+                enable_tracking=os.getenv("EMPATHY_METRICS_ENABLED", "true").lower() == "true",
+            ),
+        )
+
+
+# Global default configuration instance
+_global_config: EmpathyXMLConfig | None = None
+
+
+def get_config() -> EmpathyXMLConfig:
+    """Get global configuration instance.
+
+    Returns cached config or loads from file if not yet loaded.
+
+    Returns:
+        Global EmpathyXMLConfig instance
+    """
+    global _global_config
+
+    if _global_config is None:
+        # Try to load from file, fall back to defaults
+        _global_config = EmpathyXMLConfig.load_from_file()
+
+    return _global_config
+
+
+def set_config(config: EmpathyXMLConfig) -> None:
+    """Set global configuration instance.
+
+    Args:
+        config: EmpathyXMLConfig to use globally
+    """
+    global _global_config
+    _global_config = config

empathy_os/config.py

@@ -1,5 +1,4 @@
-"""
-Configuration Management for Empathy Framework
+"""Configuration Management for Empathy Framework
 
 Supports:
 - YAML configuration files
@@ -24,11 +23,12 @@ try:
 except ImportError:
     YAML_AVAILABLE = False
 
+from empathy_os.workflows.config import ModelConfig
+
 
 @dataclass
 class EmpathyConfig:
-    """
-    Configuration for EmpathyOS instance
+    """Configuration for EmpathyOS instance
 
     Can be loaded from:
     - YAML file (.empathy.yml, empathy.config.yml)
@@ -77,10 +77,21 @@ class EmpathyConfig:
     # Custom metadata
     metadata: dict[str, Any] = field(default_factory=dict)
 
+    # Model settings
+    models: list[ModelConfig] = field(default_factory=list)
+    default_model: str | None = None
+    log_path: str | None = None
+    max_threads: int = 4
+    model_router: dict[str, Any] | None = None
+
+    def __post_init__(self):
+        """Post-initialization validation."""
+        if self.default_model and not any(m.name == self.default_model for m in self.models):
+            raise ValueError(f"Default model '{self.default_model}' not in models.")
+
     @classmethod
     def from_yaml(cls, filepath: str) -> "EmpathyConfig":
-        """
-        Load configuration from YAML file
+        """Load configuration from YAML file
 
         Args:
             filepath: Path to YAML configuration file
@@ -95,21 +106,46 @@ class EmpathyConfig:
         Example:
             >>> config = EmpathyConfig.from_yaml("empathy.config.yml")
             >>> empathy = EmpathyOS(config=config)
+
+        Note:
+            Unknown fields in the YAML file are silently ignored.
+            This allows config files to contain settings for other
+            components (e.g., model_preferences, workflows) without
+            breaking EmpathyConfig loading.
+
         """
         if not YAML_AVAILABLE:
             raise ImportError(
-                "PyYAML is required for YAML configuration. Install with: pip install pyyaml"
+                "PyYAML is required for YAML configuration. Install with: pip install pyyaml",
             )
 
         with open(filepath) as f:
             data = yaml.safe_load(f)
 
-        return cls(**data)
+        # Filter to only known fields (gracefully ignore unknown fields like
+        # 'provider', 'model_preferences', 'workflows', etc.)
+        from dataclasses import fields as dataclass_fields
+
+        valid_fields = {f.name for f in dataclass_fields(cls)}
+        filtered_data = {k: v for k, v in data.items() if k in valid_fields}
+
+        return cls.from_dict(filtered_data)
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> "EmpathyConfig":
+        """Create an EmpathyConfig from a dictionary, ignoring unknown fields."""
+        known_fields = {f.name for f in cls.__dataclass_fields__.values()}
+        filtered_data = {k: v for k, v in data.items() if k in known_fields}
+
+        # Handle nested ModelConfig objects
+        if filtered_data.get("models"):
+            filtered_data["models"] = [ModelConfig(**m) for m in filtered_data["models"]]
+
+        return cls(**filtered_data)
 
     @classmethod
     def from_json(cls, filepath: str) -> "EmpathyConfig":
-        """
-        Load configuration from JSON file
+        """Load configuration from JSON file
 
         Args:
             filepath: Path to JSON configuration file
@@ -120,16 +156,25 @@ class EmpathyConfig:
         Example:
             >>> config = EmpathyConfig.from_json("empathy.config.json")
             >>> empathy = EmpathyOS(config=config)
+
+        Note:
+            Unknown fields in the JSON file are silently ignored.
+
         """
         with open(filepath) as f:
             data = json.load(f)
 
-        return cls(**data)
+        # Filter to only known fields (gracefully ignore unknown fields)
+        from dataclasses import fields as dataclass_fields
+
+        valid_fields = {f.name for f in dataclass_fields(cls)}
+        filtered_data = {k: v for k, v in data.items() if k in valid_fields}
+
+        return cls(**filtered_data)
 
     @classmethod
     def from_env(cls, prefix: str = "EMPATHY_") -> "EmpathyConfig":
-        """
-        Load configuration from environment variables
+        """Load configuration from environment variables
 
         Environment variables should be prefixed with EMPATHY_
         and match config field names in uppercase.
@@ -149,8 +194,14 @@ class EmpathyConfig:
             >>> os.environ["EMPATHY_USER_ID"] = "alice"
             >>> config = EmpathyConfig.from_env()
             >>> print(config.user_id)  # "alice"
+
         """
-        data = {}
+        from dataclasses import fields as dataclass_fields
+
+        # Get valid field names from the dataclass
+        valid_fields = {f.name for f in dataclass_fields(cls)}
+
+        data: dict[str, Any] = {}
 
         # Get all environment variables with prefix
         for key, value in os.environ.items():
@@ -158,6 +209,10 @@ class EmpathyConfig:
                 # Convert EMPATHY_USER_ID -> user_id
                 field_name = key[len(prefix) :].lower()
 
+                # Skip unknown fields (e.g., EMPATHY_MASTER_KEY for encryption)
+                if field_name not in valid_fields:
+                    continue
+
                 # Type conversion based on field name
                 if field_name in ("target_level",):
                     data[field_name] = int(value)
@@ -187,8 +242,7 @@ class EmpathyConfig:
 
     @classmethod
     def from_file(cls, filepath: str | None = None) -> "EmpathyConfig":
-        """
-        Automatically detect and load configuration from file
+        """Automatically detect and load configuration from file
 
         Looks for configuration files in this order:
         1. Provided filepath
@@ -208,6 +262,7 @@ class EmpathyConfig:
         Example:
             >>> config = EmpathyConfig.from_file()  # Auto-detect
             >>> config = EmpathyConfig.from_file("my-config.yml")
+
         """
         search_paths = [
             filepath,
@@ -223,15 +278,14 @@ class EmpathyConfig:
             if path and Path(path).exists():
                 if path.endswith((".yml", ".yaml")):
                     return cls.from_yaml(path)
-                elif path.endswith(".json"):
+                if path.endswith(".json"):
                     return cls.from_json(path)
 
         # No config file found - return default
         return cls()
 
     def to_yaml(self, filepath: str):
-        """
-        Save configuration to YAML file
+        """Save configuration to YAML file
 
         Args:
             filepath: Path to save YAML file
@@ -239,10 +293,11 @@ class EmpathyConfig:
         Example:
             >>> config = EmpathyConfig(user_id="alice", target_level=4)
             >>> config.to_yaml("my-config.yml")
+
         """
         if not YAML_AVAILABLE:
             raise ImportError(
-                "PyYAML is required for YAML export. Install with: pip install pyyaml"
+                "PyYAML is required for YAML export. Install with: pip install pyyaml",
             )
 
         data = asdict(self)
@@ -251,8 +306,7 @@ class EmpathyConfig:
             yaml.dump(data, f, default_flow_style=False, sort_keys=False)
 
     def to_json(self, filepath: str, indent: int = 2):
-        """
-        Save configuration to JSON file
+        """Save configuration to JSON file
 
         Args:
             filepath: Path to save JSON file
@@ -261,6 +315,7 @@ class EmpathyConfig:
         Example:
             >>> config = EmpathyConfig(user_id="alice", target_level=4)
             >>> config.to_json("my-config.json")
+
         """
         data = asdict(self)
 
@@ -272,8 +327,7 @@ class EmpathyConfig:
         return asdict(self)
 
     def update(self, **kwargs):
-        """
-        Update configuration fields
+        """Update configuration fields
 
         Args:
             **kwargs: Fields to update
@@ -281,14 +335,14 @@ class EmpathyConfig:
         Example:
             >>> config = EmpathyConfig()
             >>> config.update(user_id="bob", target_level=5)
+
         """
         for key, value in kwargs.items():
             if hasattr(self, key):
                 setattr(self, key, value)
 
     def merge(self, other: "EmpathyConfig") -> "EmpathyConfig":
-        """
-        Merge with another configuration (other takes precedence)
+        """Merge with another configuration (other takes precedence)
 
         Args:
             other: Configuration to merge
@@ -300,6 +354,7 @@ class EmpathyConfig:
             >>> base = EmpathyConfig(user_id="alice")
             >>> override = EmpathyConfig(target_level=5)
             >>> merged = base.merge(override)
+
         """
         # Start with base values
         base_dict = self.to_dict()
@@ -316,31 +371,31 @@ class EmpathyConfig:
         return EmpathyConfig(**base_dict)
 
     def validate(self) -> bool:
-        """
-        Validate configuration values
+        """Validate configuration values
 
         Returns:
             True if valid, raises ValueError if invalid
 
         Raises:
             ValueError: If configuration is invalid
+
         """
         if self.target_level not in range(1, 6):
             raise ValueError(f"target_level must be 1-5, got {self.target_level}")
 
         if not 0.0 <= self.confidence_threshold <= 1.0:
             raise ValueError(
-                f"confidence_threshold must be 0.0-1.0, got {self.confidence_threshold}"
+                f"confidence_threshold must be 0.0-1.0, got {self.confidence_threshold}",
             )
 
         if not 0.0 <= self.pattern_confidence_threshold <= 1.0:
-            raise ValueError(
-                f"pattern_confidence_threshold must be 0.0-1.0, got {self.pattern_confidence_threshold}"
-            )
+            threshold_val = self.pattern_confidence_threshold
+            raise ValueError(f"pattern_confidence_threshold must be 0.0-1.0, got {threshold_val}")
 
         if self.persistence_backend not in ("sqlite", "json", "none"):
+            backend_val = self.persistence_backend
             raise ValueError(
-                f"persistence_backend must be 'sqlite', 'json', or 'none', got {self.persistence_backend}"
+                f"persistence_backend must be 'sqlite', 'json', or 'none', got {backend_val}",
             )
 
         return True
@@ -354,10 +409,11 @@ class EmpathyConfig:
 
 
 def load_config(
-    filepath: str | None = None, use_env: bool = True, defaults: dict[str, Any] | None = None
+    filepath: str | None = None,
+    use_env: bool = True,
+    defaults: dict[str, Any] | None = None,
 ) -> EmpathyConfig:
-    """
-    Load configuration with flexible precedence
+    """Load configuration with flexible precedence
 
     Precedence (highest to lowest):
     1. Environment variables (if use_env=True)
@@ -379,6 +435,7 @@ def load_config(
 
         >>> # Load with custom defaults
         >>> config = load_config(defaults={"target_level": 4})
+
     """
     # Start with built-in defaults
     config = EmpathyConfig()
@@ -418,7 +475,8 @@ def load_config(
         try:
             env_config = EmpathyConfig.from_env()
             config = config.merge(env_config)
-        except Exception:
+        except (ValueError, TypeError):
+            # Graceful fallback: invalid env var type conversion
             pass  # Use current config if environment parsing fails
 
     # Validate final configuration