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

empathy_os/workflows/step_config.py

@@ -0,0 +1,234 @@
+"""Workflow Step Configuration for Multi-Model Pipelines
+
+Provides declarative step configuration that integrates with:
+- empathy_os.models.registry for model lookup
+- empathy_os.models.tasks for task-type routing
+- empathy_os.models.fallback for resilience policies
+
+Copyright 2025 Smart-AI-Memory
+Licensed under Fair Source License 0.9
+"""
+
+from dataclasses import dataclass, field
+from typing import Any
+
+from empathy_os.models import (
+    FallbackPolicy,
+    ModelTier,
+    RetryPolicy,
+    get_tier_for_task,
+    normalize_task_type,
+)
+
+
+@dataclass
+class WorkflowStepConfig:
+    """Configuration for a single workflow step.
+
+    Combines declarative routing configuration with optional overrides
+    for provider, tier, and resilience policies.
+
+    Example:
+        >>> step = WorkflowStepConfig(
+        ...     name="triage",
+        ...     task_type="classify",
+        ...     tier_hint="cheap",
+        ...     timeout_seconds=30,
+        ... )
+        >>> step.effective_tier
+        'cheap'
+
+        >>> step2 = WorkflowStepConfig(
+        ...     name="analysis",
+        ...     task_type="fix_bug",
+        ...     # tier_hint not specified, uses task_type routing
+        ... )
+        >>> step2.effective_tier
+        'capable'
+
+    """
+
+    # Required fields
+    name: str
+    task_type: str  # Canonical task type (e.g., "summarize", "fix_bug", "coordinate")
+
+    # Optional routing hints (override task-based routing)
+    tier_hint: str | None = None  # "cheap" | "capable" | "premium"
+    provider_hint: str | None = None  # "anthropic" | "openai" | "ollama"
+
+    # Optional resilience configuration
+    fallback_policy: FallbackPolicy | None = None
+    retry_policy: RetryPolicy | None = None
+
+    # Optional execution constraints
+    timeout_seconds: int | None = None
+    max_tokens: int | None = None
+
+    # Optional metadata
+    description: str = ""
+    metadata: dict[str, Any] = field(default_factory=dict)
+
+    def __post_init__(self) -> None:
+        """Normalize task_type on creation."""
+        self.task_type = normalize_task_type(self.task_type)
+
+    @property
+    def effective_tier(self) -> str:
+        """Get the effective tier for this step.
+
+        Priority:
+        1. tier_hint if specified
+        2. Tier derived from task_type routing
+
+        Returns:
+            Tier name ("cheap", "capable", or "premium")
+
+        """
+        if self.tier_hint:
+            return self.tier_hint
+
+        tier = get_tier_for_task(self.task_type)
+        return tier.value
+
+    @property
+    def effective_tier_enum(self) -> ModelTier:
+        """Get effective tier as ModelTier enum."""
+        return ModelTier(self.effective_tier)
+
+    def with_overrides(
+        self,
+        tier_hint: str | None = None,
+        provider_hint: str | None = None,
+        fallback_policy: FallbackPolicy | None = None,
+        retry_policy: RetryPolicy | None = None,
+        timeout_seconds: int | None = None,
+    ) -> "WorkflowStepConfig":
+        """Create a new step config with overrides applied.
+
+        Useful for runtime customization without mutating the original.
+
+        Returns:
+            New WorkflowStepConfig with overrides applied
+
+        """
+        return WorkflowStepConfig(
+            name=self.name,
+            task_type=self.task_type,
+            tier_hint=tier_hint if tier_hint is not None else self.tier_hint,
+            provider_hint=provider_hint if provider_hint is not None else self.provider_hint,
+            fallback_policy=(
+                fallback_policy if fallback_policy is not None else self.fallback_policy
+            ),
+            retry_policy=retry_policy if retry_policy is not None else self.retry_policy,
+            timeout_seconds=(
+                timeout_seconds if timeout_seconds is not None else self.timeout_seconds
+            ),
+            max_tokens=self.max_tokens,
+            description=self.description,
+            metadata=self.metadata.copy(),
+        )
+
+    def to_dict(self) -> dict[str, Any]:
+        """Convert to dictionary for serialization."""
+        return {
+            "name": self.name,
+            "task_type": self.task_type,
+            "tier_hint": self.tier_hint,
+            "provider_hint": self.provider_hint,
+            "effective_tier": self.effective_tier,
+            "timeout_seconds": self.timeout_seconds,
+            "max_tokens": self.max_tokens,
+            "description": self.description,
+            "metadata": self.metadata,
+            "has_fallback_policy": self.fallback_policy is not None,
+            "has_retry_policy": self.retry_policy is not None,
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> "WorkflowStepConfig":
+        """Create from dictionary.
+
+        Note: fallback_policy and retry_policy are not restored from dict
+        (they should be configured programmatically).
+        """
+        return cls(
+            name=data["name"],
+            task_type=data["task_type"],
+            tier_hint=data.get("tier_hint"),
+            provider_hint=data.get("provider_hint"),
+            timeout_seconds=data.get("timeout_seconds"),
+            max_tokens=data.get("max_tokens"),
+            description=data.get("description", ""),
+            metadata=data.get("metadata", {}),
+        )
+
+
+def validate_step_config(step: WorkflowStepConfig) -> list[str]:
+    """Validate a step configuration.
+
+    Returns:
+        List of validation error messages (empty if valid)
+
+    """
+    errors = []
+
+    if not step.name:
+        errors.append("Step name is required")
+
+    if not step.task_type:
+        errors.append("Step task_type is required")
+
+    if step.tier_hint and step.tier_hint not in ("cheap", "capable", "premium"):
+        errors.append(f"Invalid tier_hint: {step.tier_hint}")
+
+    if step.provider_hint and step.provider_hint not in (
+        "anthropic",
+        "openai",
+        "google",
+        "ollama",
+        "hybrid",
+    ):
+        errors.append(f"Invalid provider_hint: {step.provider_hint}")
+
+    if step.timeout_seconds is not None and step.timeout_seconds <= 0:
+        errors.append(f"timeout_seconds must be positive: {step.timeout_seconds}")
+
+    if step.max_tokens is not None and step.max_tokens <= 0:
+        errors.append(f"max_tokens must be positive: {step.max_tokens}")
+
+    return errors
+
+
+def steps_from_tier_map(
+    stages: list[str],
+    tier_map: dict[str, str],
+    task_type_default: str = "generate_code",
+) -> list[WorkflowStepConfig]:
+    """Convert legacy stages/tier_map to WorkflowStepConfig list.
+
+    Useful for migrating existing workflows.
+
+    Args:
+        stages: List of stage names
+        tier_map: Mapping of stage name to tier
+        task_type_default: Default task type if not inferrable
+
+    Returns:
+        List of WorkflowStepConfig
+
+    """
+    steps = []
+    for stage_name in stages:
+        tier = tier_map.get(stage_name, "capable")
+        # Handle both string and enum tier values
+        if hasattr(tier, "value"):
+            tier = tier.value
+
+        steps.append(
+            WorkflowStepConfig(
+                name=stage_name,
+                task_type=task_type_default,
+                tier_hint=tier,
+            ),
+        )
+    return steps

empathy_os/workflows/test5.py

@@ -0,0 +1,125 @@
+"""scan code for bugs or opportunities to improve the code and generate a detailed report.
+
+Stages:
+1. analyze - Analyze
+2. process - Process
+3. test - Test
+4. report - Report
+
+Copyright 2025 Smart-AI-Memory
+Licensed under Fair Source License 0.9
+"""
+
+import logging
+from typing import Any
+
+from empathy_os.workflows.base import BaseWorkflow, ModelTier
+
+logger = logging.getLogger(__name__)
+
+
+class Test5Workflow(BaseWorkflow):
+    """scan code for bugs or opportunities to improve the code and generate a detailed report.
+
+
+    Usage:
+        workflow = Test5Workflow()
+        result = await workflow.execute(
+            # Add parameters here
+        )
+    """
+
+    name = "test5"
+    description = (
+        "scan code for bugs or opportunities to improve the code and generate a detailed report."
+    )
+    stages = ["analyze", "fix"]
+    tier_map = {
+        "analyze": ModelTier.CAPABLE,
+        "fix": ModelTier.CAPABLE,
+    }
+
+    def __init__(
+        self,
+        **kwargs: Any,
+    ):
+        """Initialize test5 workflow.
+
+        Args:
+            **kwargs: Additional arguments passed to BaseWorkflow
+
+        """
+        super().__init__(**kwargs)
+        self._crew: Any = None
+        self._crew_available = False
+
+    async def _initialize_crew(self) -> None:
+        """Initialize the Refactoring Crew."""
+        if self._crew is not None:
+            return
+
+        try:
+            from empathy_llm_toolkit.agent_factory.crews.refactoring import RefactoringCrew
+
+            self._crew = RefactoringCrew()
+            self._crew_available = True
+            logger.info("RefactoringCrew initialized successfully")
+        except ImportError as e:
+            logger.warning(f"RefactoringCrew not available: {e}")
+            self._crew_available = False
+
+    async def run_stage(
+        self,
+        stage_name: str,
+        tier: ModelTier,
+        input_data: Any,
+    ) -> tuple[Any, int, int]:
+        """Execute RefactoringCrew for the given stage."""
+        await self._initialize_crew()
+
+        if not self._crew_available:
+            return {"error": "Crew not available"}, 0, 0
+
+        try:
+            if stage_name == "analyze":
+                # Use RefactoringCrew's analyze method
+                result = await self._crew.analyze(
+                    code=input_data.get("code", ""), file_path=input_data.get("path", ".")
+                )
+
+                return (
+                    {
+                        "findings": [
+                            {
+                                "title": f.title,
+                                "description": f.description,
+                                "category": f.category.value,
+                                "severity": f.severity.value,
+                                "file": f.file_path,
+                                "lines": f"{f.start_line}-{f.end_line}",
+                            }
+                            for f in result.findings
+                        ],
+                        "summary": f"Found {len(result.findings)} refactoring opportunities",
+                    },
+                    0,
+                    0,
+                )
+
+            elif stage_name == "fix":
+                # Apply refactorings (placeholder for now)
+                return (
+                    {
+                        "status": "Refactoring recommendations ready",
+                        "message": "Review findings from analyze stage to apply fixes",
+                    },
+                    0,
+                    0,
+                )
+
+            else:
+                return {"error": f"Unknown stage: {stage_name}"}, 0, 0
+
+        except Exception as e:
+            logger.error(f"Crew execution failed: {e}")
+            return {"error": str(e)}, 0, 0

empathy_os/workflows/test5_README.md

@@ -0,0 +1,158 @@
+# Test5Workflow
+
+**scan code for bugs or opportunities to improve the code and generate a detailed report.**
+
+---
+
+## Overview
+
+**Patterns Used:**
+- `crew-based` - Wraps CrewAI crew for multi-agent collaboration
+
+**Complexity:** COMPLEX
+
+**Stages:**
+1. **analyze** - CHEAP tier
+2. **process** - CAPABLE tier
+3. **test** - CAPABLE tier
+4. **report** - PREMIUM tier
+
+---
+
+## Usage
+
+```python
+from empathy_os.workflows.test5 import Test5Workflow
+
+# Initialize workflow
+workflow = Test5Workflow(
+)
+
+# Execute
+result = await workflow.execute(
+    # Add your input data here
+)
+
+# Check result
+print(f"Success: {result.success}")
+```
+
+---
+
+## CLI Usage
+
+```bash
+# Run via empathy CLI
+empathy workflow run test5 --input '{"key": "value"}'
+
+# With options
+```
+
+---
+
+## Configuration
+
+This workflow does not use configuration files.
+
+---
+
+## Stages
+
+### 1. Analyze
+
+**Tier:** CHEAP
+
+**Purpose:** TODO: Add description
+**Input:** TODO: Add description
+**Output:** TODO: Add description
+### 2. Process
+
+**Tier:** CAPABLE
+
+**Purpose:** TODO: Add description
+**Input:** TODO: Add description
+**Output:** TODO: Add description
+### 3. Test
+
+**Tier:** CAPABLE
+
+**Purpose:** TODO: Add description
+**Input:** TODO: Add description
+**Output:** TODO: Add description
+### 4. Report
+
+**Tier:** PREMIUM
+
+**Purpose:** TODO: Add description
+**Input:** TODO: Add description
+**Output:** TODO: Add description
+
+---
+
+## Testing
+
+```bash
+# Run tests
+pytest tests/unit/workflows/test_test5.py -v
+
+# Run with coverage
+pytest tests/unit/workflows/test_test5.py --cov
+
+# Run specific test
+pytest tests/unit/workflows/test_test5.py::TestTest5Workflow::test_workflow_execution_basic -v
+```
+
+---
+
+## Cost Optimization
+
+**Tier Distribution:**
+- CHEAP: 1 stage(s)
+- CAPABLE: 2 stage(s)
+- PREMIUM: 1 stage(s)
+
+---
+
+## Examples
+
+### Example 1: Basic Usage
+
+```python
+workflow = Test5Workflow()
+result = await workflow.execute(
+    # TODO: Add example input
+)
+```
+
+### Example 2: With Custom Settings
+
+```python
+workflow = Test5Workflow(
+)
+result = await workflow.execute(
+    # TODO: Add example input
+)
+```
+
+---
+
+## Troubleshooting
+
+### Common Issues
+
+**Issue:** Workflow fails with "X not found"
+**Solution:** TODO: Add solution
+
+**Issue:** High costs
+**Solution:** Consider adding conditional tier routing
+---
+
+## Related Workflows
+
+- TODO: Add related workflows
+
+---
+
+**Generated:** 2026-01-05
+**Patterns:** crew-based
+**Complexity:** COMPLEX