attune-ai 2.0.0__py3-none-any.whl

attune/workflow_patterns/registry.py

@@ -0,0 +1,255 @@
+"""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

attune/workflow_patterns/structural.py

@@ -0,0 +1,288 @@
+"""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 attune_llm.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,
+            ),
+        ]