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

empathy_os/workflow_patterns/registry.py

@@ -1,255 +0,0 @@
-"""Workflow Pattern Registry.
-
-Manages workflow patterns and provides pattern recommendation.
-
-Copyright 2025 Smart-AI-Memory
-Licensed under Fair Source License 0.9
-"""
-
-from typing import Any
-
-from .behavior import CodeScannerPattern, ConditionalTierPattern, ConfigDrivenPattern
-from .core import PatternCategory, WorkflowComplexity, WorkflowPattern
-from .output import ResultDataclassPattern
-from .structural import CrewBasedPattern, MultiStagePattern, SingleStagePattern
-
-
-class WorkflowPatternRegistry:
-    """Registry for workflow patterns."""
-
-    def __init__(self):
-        """Initialize pattern registry."""
-        self._patterns: dict[str, WorkflowPattern] = {}
-        self._register_default_patterns()
-
-    def _register_default_patterns(self) -> None:
-        """Register all default patterns."""
-        patterns = [
-            # Structural
-            SingleStagePattern(),
-            MultiStagePattern(),
-            CrewBasedPattern(),
-            # Behavioral
-            ConditionalTierPattern(),
-            ConfigDrivenPattern(),
-            CodeScannerPattern(),
-            # Output
-            ResultDataclassPattern(),
-        ]
-
-        for pattern in patterns:
-            self._patterns[pattern.id] = pattern
-
-    def register(self, pattern: WorkflowPattern) -> None:
-        """Register a new pattern.
-
-        Args:
-            pattern: Pattern to register
-
-        """
-        self._patterns[pattern.id] = pattern
-
-    def get(self, pattern_id: str) -> WorkflowPattern | None:
-        """Get pattern by ID.
-
-        Args:
-            pattern_id: Pattern identifier
-
-        Returns:
-            WorkflowPattern or None if not found
-
-        """
-        return self._patterns.get(pattern_id)
-
-    def list_all(self) -> list[WorkflowPattern]:
-        """List all registered patterns.
-
-        Returns:
-            List of all patterns
-
-        """
-        return list(self._patterns.values())
-
-    def list_by_category(self, category: PatternCategory) -> list[WorkflowPattern]:
-        """List patterns by category.
-
-        Args:
-            category: Pattern category
-
-        Returns:
-            List of patterns in category
-
-        """
-        return [p for p in self._patterns.values() if p.category == category]
-
-    def list_by_complexity(self, complexity: WorkflowComplexity) -> list[WorkflowPattern]:
-        """List patterns by complexity.
-
-        Args:
-            complexity: Complexity level
-
-        Returns:
-            List of patterns with specified complexity
-
-        """
-        return [p for p in self._patterns.values() if p.complexity == complexity]
-
-    def search(self, query: str) -> list[WorkflowPattern]:
-        """Search patterns by name or description.
-
-        Args:
-            query: Search query
-
-        Returns:
-            List of matching patterns
-
-        """
-        query_lower = query.lower()
-        results = []
-
-        for pattern in self._patterns.values():
-            if (
-                query_lower in pattern.name.lower()
-                or query_lower in pattern.description.lower()
-                or any(query_lower in uc.lower() for uc in pattern.use_cases)
-            ):
-                results.append(pattern)
-
-        return results
-
-    def recommend_for_workflow(
-        self,
-        workflow_type: str,
-        complexity: WorkflowComplexity | None = None,
-    ) -> list[WorkflowPattern]:
-        """Recommend patterns for a workflow type.
-
-        Args:
-            workflow_type: Type of workflow (e.g., "code-analysis", "multi-agent")
-            complexity: Desired complexity level
-
-        Returns:
-            List of recommended patterns
-
-        """
-        recommendations = []
-
-        # Type-based recommendations
-        type_map = {
-            "code-analysis": ["multi-stage", "code-scanner", "conditional-tier"],
-            "simple": ["single-stage"],
-            "multi-agent": ["crew-based", "result-dataclass"],
-            "configurable": ["config-driven", "multi-stage"],
-            "cost-optimized": ["conditional-tier", "multi-stage"],
-        }
-
-        pattern_ids = type_map.get(workflow_type.lower(), [])
-
-        # Get patterns
-        for pattern_id in pattern_ids:
-            pattern = self.get(pattern_id)
-            if pattern:
-                if complexity is None or pattern.complexity == complexity:
-                    recommendations.append(pattern)
-
-        # Always include progress tracking and telemetry (built-in)
-        # These are inherited from BaseWorkflow
-
-        return recommendations
-
-    def validate_pattern_combination(self, pattern_ids: list[str]) -> tuple[bool, str | None]:
-        """Validate that pattern IDs can be used together.
-
-        Args:
-            pattern_ids: List of pattern IDs to validate
-
-        Returns:
-            Tuple of (is_valid, error_message)
-
-        """
-        patterns = []
-        for pattern_id in pattern_ids:
-            pattern = self.get(pattern_id)
-            if not pattern:
-                return False, f"Unknown pattern: {pattern_id}"
-            patterns.append(pattern)
-
-        # Check for conflicts
-        for pattern in patterns:
-            for other_pattern in patterns:
-                if other_pattern.id in pattern.conflicts_with:
-                    return False, f"Conflict: {pattern.id} conflicts with {other_pattern.id}"
-
-        # Check for missing requirements
-        for pattern in patterns:
-            for required_id in pattern.requires:
-                if required_id not in pattern_ids:
-                    return False, f"{pattern.id} requires {required_id}"
-
-        return True, None
-
-    def get_total_risk_weight(self, pattern_ids: list[str]) -> float:
-        """Calculate total risk weight for pattern combination.
-
-        Args:
-            pattern_ids: List of pattern IDs
-
-        Returns:
-            Total risk weight
-
-        """
-        total = 0.0
-        for pattern_id in pattern_ids:
-            pattern = self.get(pattern_id)
-            if pattern:
-                total += pattern.risk_weight
-        return total
-
-    def generate_code_sections(
-        self,
-        pattern_ids: list[str],
-        context: dict[str, Any],
-    ) -> dict[str, list[Any]]:
-        """Generate all code sections from patterns.
-
-        Args:
-            pattern_ids: List of pattern IDs to use
-            context: Context dictionary for code generation
-
-        Returns:
-            Dict mapping location to list of CodeSection objects
-
-        """
-        from collections import defaultdict
-
-        sections_by_location = defaultdict(list)
-
-        for pattern_id in pattern_ids:
-            pattern = self.get(pattern_id)
-            if pattern:
-                sections = pattern.generate_code_sections(context)
-                for section in sections:
-                    sections_by_location[section.location].append(section)
-
-        # Sort sections by priority within each location
-        for location in sections_by_location:
-            sections_by_location[location].sort(key=lambda s: -s.priority)
-
-        return dict(sections_by_location)
-
-
-# Global registry instance
-_registry: WorkflowPatternRegistry | None = None
-
-
-def get_workflow_pattern_registry() -> WorkflowPatternRegistry:
-    """Get the global workflow pattern registry.
-
-    Returns:
-        WorkflowPatternRegistry instance
-
-    """
-    global _registry
-    if _registry is None:
-        _registry = WorkflowPatternRegistry()
-    return _registry

empathy_os/workflow_patterns/structural.py

@@ -1,288 +0,0 @@
-"""Structural workflow patterns.
-
-How workflows are organized and structured.
-
-Copyright 2025 Smart-AI-Memory
-Licensed under Fair Source License 0.9
-"""
-
-from typing import Any
-
-from .core import CodeSection, PatternCategory, WorkflowComplexity, WorkflowPattern
-
-
-class SingleStagePattern(WorkflowPattern):
-    """Single-stage workflow - simplest pattern.
-
-    Use for: Quick tasks that don't need multiple steps.
-    Examples: Simple text analysis, single API call, basic validation.
-    """
-
-    id: str = "single-stage"
-    name: str = "Single Stage Workflow"
-    category: PatternCategory = PatternCategory.STRUCTURAL
-    description: str = "Simple one-stage workflow with single tier"
-    complexity: WorkflowComplexity = WorkflowComplexity.SIMPLE
-    use_cases: list[str] = [
-        "Quick analysis tasks",
-        "Single API calls",
-        "Basic validation or formatting",
-    ]
-    examples: list[str] = []
-    risk_weight: float = 1.0
-
-    def generate_code_sections(self, context: dict[str, Any]) -> list[CodeSection]:
-        """Generate code for single-stage workflow."""
-        workflow_name = context.get("workflow_name", "MyWorkflow")
-        context.get("class_name", "MyWorkflow")
-        description = context.get("description", "Single-stage workflow")
-        tier = context.get("tier", "CAPABLE")
-
-        return [
-            CodeSection(
-                location="class_attributes",
-                code=f"""    name = "{workflow_name}"
-    description = "{description}"
-    stages = ["process"]
-    tier_map = {{
-        "process": ModelTier.{tier},
-    }}""",
-                priority=1,
-            ),
-            CodeSection(
-                location="methods",
-                code='''    async def run_stage(
-        self,
-        stage_name: str,
-        tier: ModelTier,
-        input_data: Any,
-    ) -> tuple[Any, int, int]:
-        """Execute the single processing stage."""
-        if stage_name == "process":
-            return await self._process(input_data, tier)
-        raise ValueError(f"Unknown stage: {stage_name}")
-
-    async def _process(
-        self,
-        input_data: Any,
-        tier: ModelTier,
-    ) -> tuple[Any, int, int]:
-        """Process the input data.
-
-        Args:
-            input_data: Input data to process
-            tier: Model tier to use
-
-        Returns:
-            Tuple of (result, input_tokens, output_tokens)
-
-        """
-        # TODO: Implement processing logic
-        prompt = f"Process this input: {input_data}"
-
-        # Use LLM executor if available
-        if self.executor:
-            result = await self.executor.execute(
-                prompt=prompt,
-                tier=tier.to_unified() if hasattr(tier, "to_unified") else tier,
-            )
-            return result.content, result.input_tokens, result.output_tokens
-
-        # Fallback to basic processing
-        return {"result": "Processed", "input": input_data}, 0, 0''',
-                priority=2,
-            ),
-        ]
-
-
-class MultiStagePattern(WorkflowPattern):
-    """Multi-stage workflow with sequential execution.
-
-    Use for: Complex tasks requiring multiple processing steps.
-    Examples: Code review (classify → scan → recommend), bug prediction.
-    """
-
-    id: str = "multi-stage"
-    name: str = "Multi-Stage Workflow"
-    category: PatternCategory = PatternCategory.STRUCTURAL
-    description: str = "Multiple sequential stages with different tiers"
-    complexity: WorkflowComplexity = WorkflowComplexity.MODERATE
-    use_cases: list[str] = [
-        "Code analysis pipelines",
-        "Multi-step processing",
-        "Tiered cost optimization",
-    ]
-    examples: list[str] = ["bug-predict", "code-review", "pr-review"]
-    risk_weight: float = 2.5
-
-    def generate_code_sections(self, context: dict[str, Any]) -> list[CodeSection]:
-        """Generate code for multi-stage workflow."""
-        workflow_name = context.get("workflow_name", "my-workflow")
-        context.get("class_name", "MyWorkflow")
-        description = context.get("description", "Multi-stage workflow")
-        stages = context.get("stages", ["analyze", "process", "report"])
-        tier_map = context.get(
-            "tier_map",
-            {
-                "analyze": "CHEAP",
-                "process": "CAPABLE",
-                "report": "PREMIUM",
-            },
-        )
-
-        # Generate tier map code
-        tier_map_code = "    tier_map = {\n"
-        for stage, tier in tier_map.items():
-            tier_map_code += f'        "{stage}": ModelTier.{tier},\n'
-        tier_map_code += "    }"
-
-        # Generate stage routing
-        stage_routing = []
-        for _i, stage in enumerate(stages):
-            stage_routing.append(
-                f"""        if stage_name == "{stage}":
-            return await self._{stage}(input_data, tier)"""
-            )
-
-        stage_routing_code = "\n".join(stage_routing)
-
-        # Generate stage method templates
-        stage_methods = []
-        for stage in stages:
-            stage_methods.append(
-                f'''    async def _{stage}(
-        self,
-        input_data: Any,
-        tier: ModelTier,
-    ) -> tuple[Any, int, int]:
-        """{stage.replace("_", " ").title()} stage.
-
-        Args:
-            input_data: Input from previous stage
-            tier: Model tier to use
-
-        Returns:
-            Tuple of (result, input_tokens, output_tokens)
-
-        """
-        # TODO: Implement {stage} logic
-        prompt = f"{{stage}} stage: {{input_data}}"
-
-        if self.executor:
-            result = await self.executor.execute(
-                prompt=prompt,
-                tier=tier.to_unified() if hasattr(tier, "to_unified") else tier,
-            )
-            return result.content, result.input_tokens, result.output_tokens
-
-        return {{"stage": "{stage}", "input": input_data}}, 0, 0'''
-            )
-
-        return [
-            CodeSection(
-                location="class_attributes",
-                code=f"""    name = "{workflow_name}"
-    description = "{description}"
-    stages = {stages}
-{tier_map_code}""",
-                priority=1,
-            ),
-            CodeSection(
-                location="methods",
-                code=f'''    async def run_stage(
-        self,
-        stage_name: str,
-        tier: ModelTier,
-        input_data: Any,
-    ) -> tuple[Any, int, int]:
-        """Route to specific stage implementation."""
-{stage_routing_code}
-        raise ValueError(f"Unknown stage: {{stage_name}}")
-
-{chr(10).join(stage_methods)}''',
-                priority=2,
-            ),
-        ]
-
-
-class CrewBasedPattern(WorkflowPattern):
-    """Workflow that wraps a CrewAI crew.
-
-    Use for: Multi-agent collaboration tasks.
-    Examples: Health check, security audit, code review.
-    """
-
-    id: str = "crew-based"
-    name: str = "Crew-Based Workflow"
-    category: PatternCategory = PatternCategory.INTEGRATION
-    description: str = "Wraps CrewAI crew for multi-agent collaboration"
-    complexity: WorkflowComplexity = WorkflowComplexity.COMPLEX
-    use_cases: list[str] = [
-        "Multi-agent tasks",
-        "Complex analysis requiring specialized roles",
-        "Collaborative problem solving",
-    ]
-    examples: list[str] = ["health-check", "security-audit"]
-    conflicts_with: list[str] = ["single-stage"]
-    risk_weight: float = 3.5
-
-    def generate_code_sections(self, context: dict[str, Any]) -> list[CodeSection]:
-        """Generate code for crew-based workflow."""
-        workflow_name = context.get("workflow_name", "my-crew-workflow")
-        context.get("class_name", "MyCrewWorkflow")
-        description = context.get("description", "Crew-based workflow")
-        crew_name = context.get("crew_name", "MyCrew")
-
-        return [
-            CodeSection(
-                location="class_attributes",
-                code=f"""    name = "{workflow_name}"
-    description = "{description}"
-    stages = ["analyze", "fix"]
-    tier_map = {{
-        "analyze": ModelTier.CAPABLE,
-        "fix": ModelTier.CAPABLE,
-    }}""",
-                priority=1,
-            ),
-            CodeSection(
-                location="init_method",
-                code="""        self._crew: Any = None
-        self._crew_available = False""",
-                priority=1,
-            ),
-            CodeSection(
-                location="methods",
-                code=f'''    async def _initialize_crew(self) -> None:
-        """Initialize the {crew_name}."""
-        if self._crew is not None:
-            return
-
-        try:
-            from empathy_llm_toolkit.agent_factory.crews import {crew_name}
-
-            self._crew = {crew_name}()
-            self._crew_available = True
-            logger.info("{crew_name} initialized successfully")
-        except ImportError as e:
-            logger.warning(f"{crew_name} not available: {{e}}")
-            self._crew_available = False
-
-    async def run_stage(
-        self,
-        stage_name: str,
-        tier: ModelTier,
-        input_data: Any,
-    ) -> tuple[Any, int, int]:
-        """Route to crew for execution."""
-        await self._initialize_crew()
-
-        if not self._crew_available:
-            return {{"error": "Crew not available"}}, 0, 0
-
-        # Execute crew task
-        result = await self._crew.execute(stage_name, input_data)
-        return result, 0, 0  # Crew handles token counting internally''',
-                priority=2,
-            ),
-        ]