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

empathy_llm_toolkit/code_health.py

@@ -9,6 +9,7 @@ Licensed under Fair Source 0.9
 
 import asyncio
 import json
+import logging
 import shutil
 import subprocess
 from dataclasses import dataclass, field
@@ -17,6 +18,8 @@ from enum import Enum
 from pathlib import Path
 from typing import Any
 
+logger = logging.getLogger(__name__)
+
 
 class HealthStatus(Enum):
     """Health check result status."""
@@ -311,13 +314,23 @@ class HealthCheckRunner:
         handler,
         config: dict,
     ) -> CheckResult:
-        """Run a check handler asynchronously."""
+        """Run a check handler asynchronously.
+
+        This uses broad exception handling intentionally for graceful degradation.
+        Health checks are optional features - the system should continue even if some checks fail.
+
+        Note:
+            Full exception context is preserved via logger.exception() for debugging.
+        """
         start_time = datetime.now()
         try:
             result: CheckResult = await asyncio.to_thread(handler, config)
             result.duration_ms = int((datetime.now() - start_time).total_seconds() * 1000)
             return result
         except Exception as e:
+            # INTENTIONAL: Broad exception handler for graceful degradation of optional checks
+            # Full traceback preserved for debugging
+            logger.exception(f"Health check failed for {category.value}: {e}")
             return CheckResult(
                 category=category,
                 status=HealthStatus.ERROR,
@@ -390,7 +403,30 @@ class HealthCheckRunner:
                 details={"total_files_checked": len({i.file_path for i in issues}) or "all"},
             )
 
+        except json.JSONDecodeError as e:
+            # Tool output not in expected JSON format
+            logger.warning(f"Lint check JSON parse error ({tool}): {e}")
+            return CheckResult(
+                category=CheckCategory.LINT,
+                status=HealthStatus.ERROR,
+                score=0,
+                tool_used=tool,
+                details={"error": f"Failed to parse {tool} output: {e}"},
+            )
+        except subprocess.SubprocessError as e:
+            # Tool execution failed
+            logger.error(f"Lint check subprocess error ({tool}): {e}")
+            return CheckResult(
+                category=CheckCategory.LINT,
+                status=HealthStatus.ERROR,
+                score=0,
+                tool_used=tool,
+                details={"error": f"Failed to run {tool}: {e}"},
+            )
         except Exception as e:
+            # Unexpected errors - preserve full context for debugging
+            # INTENTIONAL: Broad handler for graceful degradation of optional check
+            logger.exception(f"Unexpected error in lint check ({tool}): {e}")
             return CheckResult(
                 category=CheckCategory.LINT,
                 status=HealthStatus.ERROR,
@@ -475,7 +511,20 @@ class HealthCheckRunner:
                 details={"files_need_formatting": len(issues)},
             )
 
+        except subprocess.SubprocessError as e:
+            # Tool execution failed
+            logger.error(f"Format check subprocess error ({tool}): {e}")
+            return CheckResult(
+                category=CheckCategory.FORMAT,
+                status=HealthStatus.ERROR,
+                score=0,
+                tool_used=tool,
+                details={"error": f"Failed to run {tool}: {e}"},
+            )
         except Exception as e:
+            # Unexpected errors - preserve full context for debugging
+            # INTENTIONAL: Broad handler for graceful degradation of optional check
+            logger.exception(f"Unexpected error in format check ({tool}): {e}")
             return CheckResult(
                 category=CheckCategory.FORMAT,
                 status=HealthStatus.ERROR,
@@ -569,7 +618,30 @@ class HealthCheckRunner:
                 details={"type_errors": len(issues)},
             )
 
+        except json.JSONDecodeError as e:
+            # Tool output not in expected JSON format (pyright specific)
+            logger.warning(f"Type check JSON parse error ({tool}): {e}")
+            return CheckResult(
+                category=CheckCategory.TYPES,
+                status=HealthStatus.ERROR,
+                score=0,
+                tool_used=tool,
+                details={"error": f"Failed to parse {tool} output: {e}"},
+            )
+        except subprocess.SubprocessError as e:
+            # Tool execution failed
+            logger.error(f"Type check subprocess error ({tool}): {e}")
+            return CheckResult(
+                category=CheckCategory.TYPES,
+                status=HealthStatus.ERROR,
+                score=0,
+                tool_used=tool,
+                details={"error": f"Failed to run {tool}: {e}"},
+            )
         except Exception as e:
+            # Unexpected errors - preserve full context for debugging
+            # INTENTIONAL: Broad handler for graceful degradation of optional check
+            logger.exception(f"Unexpected error in type check ({tool}): {e}")
             return CheckResult(
                 category=CheckCategory.TYPES,
                 status=HealthStatus.ERROR,
@@ -681,6 +753,8 @@ class HealthCheckRunner:
             )
 
         except subprocess.TimeoutExpired:
+            # Tests took too long - specific timeout error
+            logger.error(f"Test check timeout ({tool}): Tests took longer than 5 minutes")
             return CheckResult(
                 category=CheckCategory.TESTS,
                 status=HealthStatus.ERROR,
@@ -688,7 +762,20 @@ class HealthCheckRunner:
                 tool_used=tool,
                 details={"error": "Test suite timed out after 5 minutes"},
             )
+        except subprocess.SubprocessError as e:
+            # Tool execution failed
+            logger.error(f"Test check subprocess error ({tool}): {e}")
+            return CheckResult(
+                category=CheckCategory.TESTS,
+                status=HealthStatus.ERROR,
+                score=0,
+                tool_used=tool,
+                details={"error": f"Failed to run {tool}: {e}"},
+            )
         except Exception as e:
+            # Unexpected errors - preserve full context for debugging
+            # INTENTIONAL: Broad handler for graceful degradation of optional check
+            logger.exception(f"Unexpected error in test check ({tool}): {e}")
             return CheckResult(
                 category=CheckCategory.TESTS,
                 status=HealthStatus.ERROR,
@@ -761,7 +848,30 @@ class HealthCheckRunner:
                 },
             )
 
+        except json.JSONDecodeError as e:
+            # Tool output not in expected JSON format
+            logger.warning(f"Security check JSON parse error ({tool}): {e}")
+            return CheckResult(
+                category=CheckCategory.SECURITY,
+                status=HealthStatus.ERROR,
+                score=0,
+                tool_used=tool,
+                details={"error": f"Failed to parse {tool} output: {e}"},
+            )
+        except subprocess.SubprocessError as e:
+            # Tool execution failed
+            logger.error(f"Security check subprocess error ({tool}): {e}")
+            return CheckResult(
+                category=CheckCategory.SECURITY,
+                status=HealthStatus.ERROR,
+                score=0,
+                tool_used=tool,
+                details={"error": f"Failed to run {tool}: {e}"},
+            )
         except Exception as e:
+            # Unexpected errors - preserve full context for debugging
+            # INTENTIONAL: Broad handler for graceful degradation of optional check
+            logger.exception(f"Unexpected error in security check ({tool}): {e}")
             return CheckResult(
                 category=CheckCategory.SECURITY,
                 status=HealthStatus.ERROR,
@@ -824,7 +934,30 @@ class HealthCheckRunner:
                 details={"vulnerable_packages": len(issues)},
             )
 
+        except json.JSONDecodeError as e:
+            # Tool output not in expected JSON format
+            logger.warning(f"Dependency check JSON parse error ({tool}): {e}")
+            return CheckResult(
+                category=CheckCategory.DEPS,
+                status=HealthStatus.ERROR,
+                score=0,
+                tool_used=tool,
+                details={"error": f"Failed to parse {tool} output: {e}"},
+            )
+        except subprocess.SubprocessError as e:
+            # Tool execution failed
+            logger.error(f"Dependency check subprocess error ({tool}): {e}")
+            return CheckResult(
+                category=CheckCategory.DEPS,
+                status=HealthStatus.ERROR,
+                score=0,
+                tool_used=tool,
+                details={"error": f"Failed to run {tool}: {e}"},
+            )
         except Exception as e:
+            # Unexpected errors - preserve full context for debugging
+            # INTENTIONAL: Broad handler for graceful degradation of optional check
+            logger.exception(f"Unexpected error in dependency check ({tool}): {e}")
             return CheckResult(
                 category=CheckCategory.DEPS,
                 status=HealthStatus.ERROR,
@@ -920,7 +1053,14 @@ class AutoFixer:
         return results
 
     async def _apply_fix(self, issue: HealthIssue) -> bool:
-        """Apply a single fix."""
+        """Apply a single fix.
+
+        This uses broad exception handling intentionally for graceful degradation.
+        Auto-fixes are optional - the system should continue even if some fixes fail.
+
+        Note:
+            Full exception context is preserved via logger.exception() for debugging.
+        """
         if not issue.fix_command:
             return False
 
@@ -932,7 +1072,14 @@ class AutoFixer:
                 text=True,
             )
             return result.returncode == 0
-        except Exception:
+        except subprocess.SubprocessError as e:
+            # Fix command execution failed
+            logger.error(f"Auto-fix subprocess error for {issue.file_path}: {e}")
+            return False
+        except Exception as e:
+            # Unexpected errors - preserve full context for debugging
+            # INTENTIONAL: Broad handler for graceful degradation of optional auto-fix
+            logger.exception(f"Unexpected error applying fix to {issue.file_path}: {e}")
             return False
 
 

empathy_llm_toolkit/config/__init__.py

@@ -0,0 +1,29 @@
+"""Empathy Framework Configuration Module
+
+Provides unified configuration models for agents, wizards, and workflows.
+
+Copyright 2025 Smart-AI-Memory
+Licensed under Fair Source License 0.9
+"""
+
+from empathy_llm_toolkit.config.unified import (
+                                                AgentOperationError,
+                                                BookProductionConfig,
+                                                MemDocsConfig,
+                                                ModelTier,
+                                                Provider,
+                                                RedisConfig,
+                                                UnifiedAgentConfig,
+                                                WorkflowMode,
+)
+
+__all__ = [
+    "AgentOperationError",
+    "BookProductionConfig",
+    "MemDocsConfig",
+    "ModelTier",
+    "Provider",
+    "RedisConfig",
+    "UnifiedAgentConfig",
+    "WorkflowMode",
+]

empathy_llm_toolkit/config/unified.py

@@ -0,0 +1,295 @@
+"""Unified Agent Configuration
+
+Single source of truth for all agent, wizard, and workflow configuration.
+Uses Pydantic for validation and type safety.
+
+This resolves the AgentConfig duplication between:
+- empathy_llm_toolkit/agent_factory/base.py
+- agents/book_production/base.py
+
+Copyright 2025 Smart-AI-Memory
+Licensed under Fair Source License 0.9
+"""
+
+from enum import Enum
+from typing import Any, Literal
+
+from pydantic import BaseModel, Field, field_validator
+
+
+class ModelTier(str, Enum):
+    """Model tier for cost optimization."""
+
+    CHEAP = "cheap"  # Haiku - fast, low cost
+    CAPABLE = "capable"  # Sonnet - balanced
+    PREMIUM = "premium"  # Opus - highest quality
+
+
+class Provider(str, Enum):
+    """LLM provider options."""
+
+    ANTHROPIC = "anthropic"
+    OPENAI = "openai"
+    LOCAL = "local"
+
+
+class WorkflowMode(str, Enum):
+    """Workflow execution modes."""
+
+    SEQUENTIAL = "sequential"
+    PARALLEL = "parallel"
+    GRAPH = "graph"
+    CONVERSATION = "conversation"
+
+
+class AgentOperationError(Exception):
+    """Error during agent operation with context."""
+
+    def __init__(self, operation: str, cause: Exception):
+        self.operation = operation
+        self.cause = cause
+        super().__init__(f"Agent operation '{operation}' failed: {cause}")
+
+
+class UnifiedAgentConfig(BaseModel):
+    """Unified configuration model for all agents.
+
+    This is the single source of truth for agent configuration,
+    replacing duplicate definitions across the codebase.
+
+    Example:
+        config = UnifiedAgentConfig(
+            name="researcher",
+            role="researcher",
+            model_tier=ModelTier.CAPABLE,
+            empathy_level=4
+        )
+
+    """
+
+    # Identity
+    name: str = Field(..., min_length=1, description="Unique agent name")
+    role: str = Field(default="custom", description="Agent role (researcher, writer, etc.)")
+    description: str = Field(default="", description="Agent description")
+
+    # Model selection
+    model_tier: ModelTier = Field(
+        default=ModelTier.CAPABLE,
+        description="Model tier for cost optimization",
+    )
+    model_override: str | None = Field(
+        default=None,
+        description="Specific model ID to use (overrides tier)",
+    )
+    provider: Provider = Field(default=Provider.ANTHROPIC, description="LLM provider")
+
+    # Empathy Framework features
+    empathy_level: int = Field(
+        default=4,
+        ge=1,
+        le=5,
+        description="Empathy level (1=Basic, 4=Anticipatory, 5=Transformative)",
+    )
+
+    # Feature flags
+    memory_enabled: bool = Field(default=True, description="Enable conversation memory")
+    pattern_learning: bool = Field(default=True, description="Enable pattern learning")
+    cost_tracking: bool = Field(default=True, description="Track API costs")
+    use_patterns: bool = Field(default=True, description="Use learned patterns")
+
+    # LLM parameters
+    temperature: float = Field(default=0.7, ge=0.0, le=2.0)
+    max_tokens: int = Field(default=4096, ge=1, le=200000)
+    timeout: int = Field(default=120, ge=1, description="Timeout in seconds")
+
+    # Retry configuration
+    retry_attempts: int = Field(default=3, ge=0, le=10)
+    retry_delay: float = Field(default=1.0, ge=0.0)
+
+    # System prompt
+    system_prompt: str | None = Field(default=None, description="Custom system prompt")
+
+    # Tools and capabilities
+    tools: list[Any] = Field(default_factory=list, description="Agent tools")
+    capabilities: list[str] = Field(default_factory=list, description="Agent capabilities")
+
+    # Framework-specific options
+    framework_options: dict[str, Any] = Field(
+        default_factory=dict,
+        description="Framework-specific configuration",
+    )
+
+    # Extensions
+    extra: dict[str, Any] = Field(
+        default_factory=dict,
+        description="Additional custom configuration",
+    )
+
+    @field_validator("role")
+    @classmethod
+    def normalize_role(cls, v: str) -> str:
+        """Normalize role to lowercase."""
+        return v.lower().strip()
+
+    def get_model_id(self) -> str:
+        """Get the actual model ID based on tier and provider.
+
+        Returns:
+            Model identifier string
+
+        """
+        if self.model_override:
+            return self.model_override
+
+        # Model mapping by provider and tier
+        models = {
+            Provider.ANTHROPIC: {
+                ModelTier.CHEAP: "claude-3-haiku-20240307",
+                ModelTier.CAPABLE: "claude-sonnet-4-20250514",
+                ModelTier.PREMIUM: "claude-opus-4-20250514",
+            },
+            Provider.OPENAI: {
+                ModelTier.CHEAP: "gpt-4o-mini",
+                ModelTier.CAPABLE: "gpt-4o",
+                ModelTier.PREMIUM: "gpt-4o",
+            },
+            Provider.LOCAL: {
+                ModelTier.CHEAP: "llama3.2:3b",
+                ModelTier.CAPABLE: "llama3.1:8b",
+                ModelTier.PREMIUM: "llama3.1:70b",
+            },
+        }
+
+        return models.get(self.provider, {}).get(
+            self.model_tier,
+            "claude-sonnet-4-20250514",  # Fallback
+        )
+
+    def for_book_production(self) -> "BookProductionConfig":
+        """Convert to BookProductionConfig for backward compatibility.
+
+        Returns:
+            BookProductionConfig instance
+
+        """
+        return BookProductionConfig(
+            agent_config=self,
+            memdocs_config=MemDocsConfig(),
+            redis_config=RedisConfig(),
+        )
+
+    class Config:
+        """Pydantic configuration."""
+
+        use_enum_values = True
+
+
+class MemDocsConfig(BaseModel):
+    """Configuration for MemDocs pattern storage integration."""
+
+    enabled: bool = Field(default=True, description="Enable MemDocs integration")
+    project: str = Field(default="empathy-framework", description="Project identifier")
+
+    collections: dict[str, str] = Field(
+        default_factory=lambda: {
+            "patterns": "learned_patterns",
+            "exemplars": "exemplar_examples",
+            "transformations": "transformation_examples",
+            "feedback": "quality_feedback",
+        },
+        description="Collection name mappings",
+    )
+
+    # Storage settings
+    storage_path: str = Field(default="./patterns", description="Local storage path")
+    encryption_enabled: bool = Field(default=False, description="Enable encryption")
+
+
+class RedisConfig(BaseModel):
+    """Configuration for Redis state management."""
+
+    enabled: bool = Field(default=True, description="Enable Redis")
+    host: str = Field(default="localhost", description="Redis host")
+    port: int = Field(default=6379, ge=1, le=65535)
+    db: int = Field(default=0, ge=0, le=15)
+    password: str | None = Field(default=None, description="Redis password")
+
+    prefix: str = Field(default="empathy", description="Key prefix")
+    ttl: int = Field(default=86400, ge=0, description="Default TTL in seconds")
+
+    # Connection pool settings
+    max_connections: int = Field(default=10, ge=1)
+    socket_timeout: float = Field(default=5.0, ge=0.1)
+
+
+class BookProductionConfig(BaseModel):
+    """Unified configuration for book production agents.
+
+    Combines UnifiedAgentConfig with production-specific settings.
+    This replaces the duplicate AgentConfig in agents/book_production/base.py.
+    """
+
+    agent_config: UnifiedAgentConfig
+    memdocs_config: MemDocsConfig = Field(default_factory=MemDocsConfig)
+    redis_config: RedisConfig = Field(default_factory=RedisConfig)
+
+    # Book production specific
+    chapter_max_words: int = Field(default=5000, ge=100)
+    include_code_examples: bool = Field(default=True)
+    target_reading_level: Literal["beginner", "intermediate", "advanced"] = "intermediate"
+
+    @property
+    def model(self) -> str:
+        """Get model ID for backward compatibility."""
+        return self.agent_config.get_model_id()
+
+    @property
+    def max_tokens(self) -> int:
+        """Get max tokens for backward compatibility."""
+        return self.agent_config.max_tokens
+
+    @property
+    def temperature(self) -> float:
+        """Get temperature for backward compatibility."""
+        return self.agent_config.temperature
+
+    @property
+    def timeout(self) -> int:
+        """Get timeout for backward compatibility."""
+        return self.agent_config.timeout
+
+    @property
+    def retry_attempts(self) -> int:
+        """Get retry attempts for backward compatibility."""
+        return self.agent_config.retry_attempts
+
+    @property
+    def retry_delay(self) -> float:
+        """Get retry delay for backward compatibility."""
+        return self.agent_config.retry_delay
+
+
+class WorkflowConfig(BaseModel):
+    """Configuration for agent workflows."""
+
+    name: str = Field(..., min_length=1)
+    description: str = Field(default="")
+    mode: WorkflowMode = Field(default=WorkflowMode.SEQUENTIAL)
+
+    # Execution settings
+    max_iterations: int = Field(default=10, ge=1, le=100)
+    timeout_seconds: int = Field(default=300, ge=1)
+
+    # State management
+    state_schema: dict[str, Any] | None = Field(default=None)
+    checkpointing: bool = Field(default=True)
+
+    # Error handling
+    retry_on_error: bool = Field(default=True)
+    max_retries: int = Field(default=3, ge=0)
+
+    # Framework options
+    framework_options: dict[str, Any] = Field(default_factory=dict)
+
+    class Config:
+        use_enum_values = True

empathy_llm_toolkit/routing/__init__.py

@@ -0,0 +1,32 @@
+"""Empathy Framework Model Routing
+
+Smart routing of tasks to appropriate model tiers for cost optimization:
+- CHEAP tier: Triage, summarization, classification (Haiku/GPT-4o-mini)
+- CAPABLE tier: Code generation, analysis, sub-agent work (Sonnet/GPT-4o)
+- PREMIUM tier: Coordination, synthesis, critical decisions (Opus/o1)
+
+Example:
+    >>> from empathy_llm_toolkit.routing import ModelRouter
+    >>>
+    >>> router = ModelRouter()
+    >>> model = router.route("summarize", provider="anthropic")
+    >>> print(model)  # claude-3-5-haiku-20241022
+    >>>
+    >>> model = router.route("coordinate", provider="anthropic")
+    >>> print(model)  # claude-opus-4-20250514
+    >>>
+    >>> cost = router.estimate_cost("fix_bug", input_tokens=5000, output_tokens=1000)
+    >>> print(f"Estimated cost: ${cost:.4f}")
+
+Copyright 2025 Smart AI Memory, LLC
+Licensed under Fair Source 0.9
+
+"""
+
+from .model_router import ModelRouter, ModelTier, TaskRouting
+
+__all__ = [
+    "ModelRouter",
+    "ModelTier",
+    "TaskRouting",
+]