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

empathy_os/workflow_patterns/__init__.py

@@ -1,33 +0,0 @@
-"""Workflow Pattern Library.
-
-Extracted patterns from 17 existing workflows for rapid workflow generation.
-
-Copyright 2025 Smart-AI-Memory
-Licensed under Fair Source License 0.9
-"""
-
-from .behavior import CodeScannerPattern, ConditionalTierPattern, ConfigDrivenPattern
-from .core import PatternCategory, WorkflowComplexity, WorkflowPattern
-from .output import ResultDataclassPattern
-from .registry import WorkflowPatternRegistry, get_workflow_pattern_registry
-from .structural import CrewBasedPattern, MultiStagePattern, SingleStagePattern
-
-__all__ = [
-    # Core
-    "WorkflowPattern",
-    "PatternCategory",
-    "WorkflowComplexity",
-    # Structural
-    "SingleStagePattern",
-    "MultiStagePattern",
-    "CrewBasedPattern",
-    # Behavioral
-    "ConditionalTierPattern",
-    "ConfigDrivenPattern",
-    "CodeScannerPattern",
-    # Output
-    "ResultDataclassPattern",
-    # Registry
-    "WorkflowPatternRegistry",
-    "get_workflow_pattern_registry",
-]

empathy_os/workflow_patterns/behavior.py

@@ -1,249 +0,0 @@
-"""Behavioral workflow patterns.
-
-Patterns for conditional execution and dynamic behavior.
-
-Copyright 2025 Smart-AI-Memory
-Licensed under Fair Source License 0.9
-"""
-
-from typing import Any
-
-from .core import CodeSection, PatternCategory, WorkflowComplexity, WorkflowPattern
-
-
-class ConditionalTierPattern(WorkflowPattern):
-    """Dynamic tier routing based on complexity or conditions.
-
-    Use for: Cost optimization by downgrading/skipping expensive stages.
-    Examples: bug-predict (skip premium if low risk), code-review (conditional architect review).
-    """
-
-    id: str = "conditional-tier"
-    name: str = "Conditional Tier Routing"
-    category: PatternCategory = PatternCategory.BEHAVIOR
-    description: str = "Dynamically adjust model tiers based on conditions"
-    complexity: WorkflowComplexity = WorkflowComplexity.MODERATE
-    use_cases: list[str] = [
-        "Cost optimization",
-        "Conditional premium tier usage",
-        "Complexity-based routing",
-    ]
-    examples: list[str] = ["bug-predict", "code-review", "pr-review"]
-    requires: list[str] = ["multi-stage"]
-    risk_weight: float = 3.0
-
-    def generate_code_sections(self, context: dict[str, Any]) -> list[CodeSection]:
-        """Generate code for conditional tier routing."""
-        threshold_param = context.get("threshold_param", "complexity_threshold")
-        threshold_default = context.get("threshold_default", "0.7")
-        metric_name = context.get("metric_name", "complexity_score")
-
-        return [
-            CodeSection(
-                location="init_method",
-                code=f"""        self.{threshold_param} = {threshold_param} if {threshold_param} is not None else {threshold_default}
-        self._{metric_name}: float = 0.0""",
-                priority=1,
-            ),
-            CodeSection(
-                location="methods",
-                code=f'''    def should_skip_stage(self, stage_name: str, input_data: Any) -> tuple[bool, str | None]:
-        """Conditionally downgrade or skip stages based on {metric_name}.
-
-        Args:
-            stage_name: Name of the stage to check
-            input_data: Current workflow data
-
-        Returns:
-            Tuple of (should_skip, reason)
-
-        """
-        # Example: Downgrade premium stage if metric below threshold
-        if stage_name == "recommend" or stage_name == "architect_review":
-            if self._{metric_name} < self.{threshold_param}:
-                # Downgrade to CAPABLE instead of skipping
-                self.tier_map[stage_name] = ModelTier.CAPABLE
-                logger.info(f"Downgraded {{stage_name}} to CAPABLE ({metric_name}: {{self._{metric_name}:.2f}})")
-                return False, None
-        return False, None''',
-                priority=2,
-            ),
-        ]
-
-
-class ConfigDrivenPattern(WorkflowPattern):
-    """Load configuration from empathy.config.yml.
-
-    Use for: Configurable thresholds, options, and behavior.
-    Examples: bug-predict (risk threshold), health-check (check toggles).
-    """
-
-    id: str = "config-driven"
-    name: str = "Configuration-Driven Workflow"
-    category: PatternCategory = PatternCategory.BEHAVIOR
-    description: str = "Loads settings from empathy.config.yml"
-    complexity: WorkflowComplexity = WorkflowComplexity.SIMPLE
-    use_cases: list[str] = [
-        "Configurable thresholds",
-        "User-customizable behavior",
-        "Environment-specific settings",
-    ]
-    examples: list[str] = ["bug-predict", "health-check", "security-audit"]
-    risk_weight: float = 1.5
-
-    def generate_code_sections(self, context: dict[str, Any]) -> list[CodeSection]:
-        """Generate code for configuration loading."""
-        workflow_name = context.get("workflow_name", "my-workflow")
-        config_key = workflow_name.replace("-", "_")
-        config_params = context.get(
-            "config_params",
-            {
-                "threshold": 0.7,
-                "enabled": True,
-            },
-        )
-
-        # Generate defaults dict
-        defaults_code = "    defaults = {\n"
-        for key, value in config_params.items():
-            if isinstance(value, str):
-                defaults_code += f'        "{key}": "{value}",\n'
-            else:
-                defaults_code += f'        "{key}": {value},\n'
-        defaults_code += "    }"
-
-        # Generate config loading
-        return [
-            CodeSection(
-                location="imports",
-                code="import yaml\nfrom pathlib import Path",
-                priority=1,
-            ),
-            CodeSection(
-                location="helper_functions",
-                code=f'''def _load_{config_key}_config() -> dict:
-    """Load {config_key} configuration from empathy.config.yml.
-
-    Returns:
-        Dict with {config_key} settings, or defaults if not found.
-
-    """
-{defaults_code}
-
-    config_paths = [
-        Path("empathy.config.yml"),
-        Path("empathy.config.yaml"),
-        Path(".empathy.yml"),
-        Path(".empathy.yaml"),
-    ]
-
-    for config_path in config_paths:
-        if config_path.exists():
-            try:
-                with open(config_path) as f:
-                    config = yaml.safe_load(f)
-                    if config and "{config_key}" in config:
-                        return {{**defaults, **config["{config_key}"]}}
-            except (yaml.YAMLError, OSError):
-                pass
-
-    return defaults''',
-                priority=1,
-            ),
-            CodeSection(
-                location="init_method",
-                code=f"""        # Load configuration
-        self._config = _load_{config_key}_config()""",
-                priority=1,
-            ),
-        ]
-
-
-class CodeScannerPattern(WorkflowPattern):
-    """File scanning and analysis capabilities.
-
-    Use for: Code analysis workflows that scan files.
-    Examples: bug-predict, security-audit, test-gen.
-    """
-
-    id: str = "code-scanner"
-    name: str = "Code Scanner"
-    category: PatternCategory = PatternCategory.BEHAVIOR
-    description: str = "Scan and analyze code files with pattern matching"
-    complexity: WorkflowComplexity = WorkflowComplexity.MODERATE
-    use_cases: list[str] = [
-        "Bug detection",
-        "Security scanning",
-        "Code analysis",
-    ]
-    examples: list[str] = ["bug-predict", "security-audit"]
-    risk_weight: float = 2.0
-
-    def generate_code_sections(self, context: dict[str, Any]) -> list[CodeSection]:
-        """Generate code for file scanning."""
-        scan_pattern = context.get("scan_pattern", "*.py")
-
-        return [
-            CodeSection(
-                location="imports",
-                code="import fnmatch\nfrom pathlib import Path",
-                priority=1,
-            ),
-            CodeSection(
-                location="helper_functions",
-                code=f'''def _should_exclude_file(file_path: str, exclude_patterns: list[str]) -> bool:
-    """Check if a file should be excluded based on glob patterns.
-
-    Args:
-        file_path: Path to the file
-        exclude_patterns: List of glob patterns (e.g., "**/test_*.py")
-
-    Returns:
-        True if the file matches any exclusion pattern.
-
-    """
-    for pattern in exclude_patterns:
-        if "**" in pattern:
-            parts = pattern.split("**")
-            if len(parts) == 2:
-                prefix, suffix = parts
-                if prefix and not file_path.startswith(prefix.rstrip("/")):
-                    continue
-                if suffix and fnmatch.fnmatch(file_path, f"*{{suffix}}"):
-                    return True
-        elif fnmatch.fnmatch(file_path, pattern) or fnmatch.fnmatch(
-            Path(file_path).name,
-            pattern,
-        ):
-            return True
-    return False
-
-
-def _scan_files(
-    root_dir: str = ".",
-    pattern: str = "{scan_pattern}",
-    exclude: list[str] | None = None,
-) -> list[Path]:
-    """Scan directory for files matching pattern.
-
-    Args:
-        root_dir: Root directory to scan
-        pattern: Glob pattern for files
-        exclude: Exclusion patterns
-
-    Returns:
-        List of matching file paths
-
-    """
-    exclude = exclude or []
-    root = Path(root_dir)
-    files = []
-
-    for file_path in root.rglob(pattern):
-        if file_path.is_file() and not _should_exclude_file(str(file_path), exclude):
-            files.append(file_path)
-
-    return files''',
-                priority=1,
-            ),
-        ]

empathy_os/workflow_patterns/core.py

@@ -1,76 +0,0 @@
-"""Core workflow pattern definitions.
-
-Defines Pydantic models for workflow patterns extracted from existing workflows.
-
-Copyright 2025 Smart-AI-Memory
-Licensed under Fair Source License 0.9
-"""
-
-from dataclasses import dataclass
-from enum import Enum
-from typing import Any
-
-from pydantic import BaseModel, Field
-
-
-class PatternCategory(Enum):
-    """Categories for workflow patterns."""
-
-    STRUCTURAL = "structural"  # How workflow is organized
-    TIER = "tier"  # Tier routing strategies
-    INTEGRATION = "integration"  # External integrations
-    OUTPUT = "output"  # Output formatting
-    BEHAVIOR = "behavior"  # Behavioral patterns
-
-
-class WorkflowComplexity(Enum):
-    """Workflow complexity levels."""
-
-    SIMPLE = "simple"  # Single stage, no conditions
-    MODERATE = "moderate"  # Multiple stages, some conditions
-    COMPLEX = "complex"  # Multiple stages, conditional routing, crews
-
-
-@dataclass
-class CodeSection:
-    """A section of code to be generated."""
-
-    location: str  # Where in the file (e.g., "imports", "class_body", "methods")
-    code: str  # The code content
-    priority: int = 0  # Higher priority sections are placed first
-
-
-class WorkflowPattern(BaseModel):
-    """Base model for workflow patterns."""
-
-    id: str = Field(..., description="Unique pattern identifier")
-    name: str = Field(..., description="Human-readable pattern name")
-    category: PatternCategory = Field(..., description="Pattern category")
-    description: str = Field(..., description="Pattern description")
-    complexity: WorkflowComplexity = Field(..., description="Pattern complexity")
-    use_cases: list[str] = Field(default_factory=list, description="When to use this pattern")
-    examples: list[str] = Field(
-        default_factory=list, description="Example workflows using this pattern"
-    )
-    conflicts_with: list[str] = Field(default_factory=list, description="Incompatible pattern IDs")
-    requires: list[str] = Field(default_factory=list, description="Required pattern IDs")
-    risk_weight: float = Field(
-        default=1.0, ge=0.0, le=5.0, description="Risk factor for testing (1=low, 5=high)"
-    )
-
-    def generate_code_sections(self, context: dict[str, Any]) -> list[CodeSection]:
-        """Generate code sections for this pattern.
-
-        Args:
-            context: Context dictionary with workflow metadata
-
-        Returns:
-            List of CodeSection objects to be merged
-
-        """
-        raise NotImplementedError("Subclasses must implement generate_code_sections")
-
-    class Config:
-        """Pydantic config."""
-
-        use_enum_values = True

empathy_os/workflow_patterns/output.py

@@ -1,99 +0,0 @@
-"""Output formatting patterns.
-
-Patterns for structured workflow results.
-
-Copyright 2025 Smart-AI-Memory
-Licensed under Fair Source License 0.9
-"""
-
-from typing import Any
-
-from .core import CodeSection, PatternCategory, WorkflowComplexity, WorkflowPattern
-
-
-class ResultDataclassPattern(WorkflowPattern):
-    """Structured output with dataclass.
-
-    Use for: Type-safe, structured workflow results.
-    Examples: health-check, release-prep.
-    """
-
-    id: str = "result-dataclass"
-    name: str = "Result Dataclass"
-    category: PatternCategory = PatternCategory.OUTPUT
-    description: str = "Structured output format with dataclass"
-    complexity: WorkflowComplexity = WorkflowComplexity.SIMPLE
-    use_cases: list[str] = [
-        "Type-safe results",
-        "Structured output",
-        "API integration",
-    ]
-    examples: list[str] = ["health-check", "release-prep"]
-    risk_weight: float = 1.0
-
-    def generate_code_sections(self, context: dict[str, Any]) -> list[CodeSection]:
-        """Generate code for result dataclass."""
-        context.get("workflow_name", "my-workflow")
-        class_name = context.get("class_name", "MyWorkflow")
-        result_class_name = f"{class_name}Result"
-
-        # Get custom fields from context
-        custom_fields = context.get("result_fields", [])
-
-        # Generate custom fields code
-        custom_fields_code = ""
-        if custom_fields:
-            for field in custom_fields:
-                field_name = field.get("name", "custom_field")
-                field_type = field.get("type", "Any")
-                field_desc = field.get("description", "Custom field")
-                custom_fields_code += f"    {field_name}: {field_type}  # {field_desc}\n"
-
-        return [
-            CodeSection(
-                location="imports",
-                code="from dataclasses import dataclass, field",
-                priority=1,
-            ),
-            CodeSection(
-                location="dataclasses",
-                code=f'''@dataclass
-class {result_class_name}:
-    """Result from {class_name} execution."""
-
-    success: bool
-    {custom_fields_code if custom_fields_code else "    # Add custom fields here"}duration_seconds: float
-    cost: float
-    metadata: dict = field(default_factory=dict)''',
-                priority=1,
-            ),
-            CodeSection(
-                location="methods",
-                code=f'''    def _create_result(
-        self,
-        success: bool,
-        duration: float,
-        cost: float,
-        **kwargs: Any,
-    ) -> {result_class_name}:
-        """Create structured result.
-
-        Args:
-            success: Whether workflow succeeded
-            duration: Execution duration in seconds
-            cost: Total cost in USD
-            **kwargs: Additional result fields
-
-        Returns:
-            {result_class_name} instance
-
-        """
-        return {result_class_name}(
-            success=success,
-            duration_seconds=duration,
-            cost=cost,
-            **kwargs,
-        )''',
-                priority=2,
-            ),
-        ]