empathy-framework 2.4.0__py3-none-any.whl → 3.8.2__py3-none-any.whl

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")
+        class_name = 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")
+        class_name = 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")
+        class_name = 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,
+            ),
+        ]

workflow_scaffolding/__init__.py

@@ -0,0 +1,11 @@
+"""Workflow scaffolding module.
+
+Generates workflow code from patterns.
+
+Copyright 2025 Smart-AI-Memory
+Licensed under Fair Source License 0.9
+"""
+
+from .generator import WorkflowGenerator
+
+__all__ = ["WorkflowGenerator"]

workflow_scaffolding/__main__.py

@@ -0,0 +1,12 @@
+"""Entry point for workflow_scaffolding module.
+
+Allows running as: python -m workflow_scaffolding
+
+Copyright 2025 Smart-AI-Memory
+Licensed under Fair Source License 0.9
+"""
+
+from .cli import main
+
+if __name__ == "__main__":
+    main()

workflow_scaffolding/cli.py

@@ -0,0 +1,206 @@
+"""CLI for workflow scaffolding.
+
+Provides command-line interface for creating workflows.
+
+Copyright 2025 Smart-AI-Memory
+Licensed under Fair Source License 0.9
+"""
+
+import sys
+from pathlib import Path
+
+from rich.console import Console
+from rich.table import Table
+
+from workflow_patterns import get_workflow_pattern_registry
+
+from .generator import WorkflowGenerator
+
+console = Console()
+
+
+def cmd_create(args):
+    """Create a new workflow."""
+    workflow_name = args.name
+    description = args.description or f"{workflow_name} workflow"
+    patterns = args.patterns.split(",") if args.patterns else []
+
+    # Auto-select patterns if none provided
+    if not patterns:
+        console.print("[yellow]No patterns specified, using defaults for simple workflow[/yellow]")
+        patterns = ["single-stage"]
+
+    # Create generator
+    generator = WorkflowGenerator()
+    registry = get_workflow_pattern_registry()
+
+    # Validate patterns
+    valid, error = registry.validate_pattern_combination(patterns)
+    if not valid:
+        console.print(f"[red]Error: {error}[/red]")
+        sys.exit(1)
+
+    console.print(f"[bold]Creating workflow:[/bold] {workflow_name}")
+    console.print(f"[bold]Description:[/bold] {description}")
+    console.print(f"[bold]Patterns:[/bold] {', '.join(patterns)}")
+
+    # Generate and write
+    output_dir = Path(args.output) if args.output else Path.cwd()
+
+    try:
+        written = generator.write_workflow(
+            output_dir=output_dir,
+            workflow_name=workflow_name,
+            description=description,
+            patterns=patterns,
+            stages=args.stages.split(",") if args.stages else None,
+            tier_map=_parse_tier_map(args.tier_map) if args.tier_map else None,
+        )
+
+        console.print("\n[green]✓[/green] Workflow created successfully!\n")
+        console.print("[bold]Generated files:[/bold]")
+        for file_type, path in written.items():
+            console.print(f"  - {file_type}: {path}")
+
+        console.print("\n[bold]Next steps:[/bold]")
+        console.print("1. Review generated files")
+        console.print("2. Implement stage logic (search for TODO comments)")
+        console.print(f"3. Run tests: pytest {written['test']}")
+        console.print(f"4. Run workflow: empathy workflow run {workflow_name}")
+
+    except Exception as e:
+        console.print(f"[red]Error creating workflow: {e}[/red]")
+        sys.exit(1)
+
+
+def cmd_list_patterns(args):
+    """List available patterns."""
+    registry = get_workflow_pattern_registry()
+    patterns = registry.list_all()
+
+    # Create table
+    table = Table(title="Workflow Patterns")
+    table.add_column("ID", style="cyan")
+    table.add_column("Name", style="green")
+    table.add_column("Category", style="yellow")
+    table.add_column("Complexity", style="magenta")
+    table.add_column("Risk", justify="right")
+
+    for pattern in sorted(patterns, key=lambda p: p.id):
+        table.add_row(
+            pattern.id,
+            pattern.name,
+            pattern.category.value,
+            pattern.complexity.value,
+            f"{pattern.risk_weight:.1f}",
+        )
+
+    console.print(table)
+
+    # Show usage examples
+    console.print("\n[bold]Common Combinations:[/bold]")
+    console.print("  Simple workflow:       single-stage")
+    console.print("  Code analysis:         multi-stage,code-scanner,conditional-tier")
+    console.print("  Multi-agent:           crew-based,result-dataclass")
+    console.print("  Configurable:          multi-stage,config-driven")
+
+
+def cmd_recommend(args):
+    """Recommend patterns for a workflow type."""
+    registry = get_workflow_pattern_registry()
+    workflow_type = args.type
+
+    recommendations = registry.recommend_for_workflow(workflow_type)
+
+    if not recommendations:
+        console.print(f"[yellow]No recommendations found for type: {workflow_type}[/yellow]")
+        console.print(
+            "\nAvailable types: code-analysis, simple, multi-agent, configurable, cost-optimized"
+        )
+        return
+
+    console.print(f"[bold]Recommendations for '{workflow_type}':[/bold]\n")
+
+    for pattern in recommendations:
+        console.print(f"[cyan]{pattern.id}[/cyan] - {pattern.name}")
+        console.print(f"  {pattern.description}")
+        if pattern.use_cases:
+            console.print(f"  Use for: {', '.join(pattern.use_cases)}")
+        console.print()
+
+    pattern_ids = [p.id for p in recommendations]
+    console.print("[bold]Create command:[/bold]")
+    console.print(
+        f"python -m workflow_scaffolding create my-workflow --patterns {','.join(pattern_ids)}"
+    )
+
+
+def _parse_tier_map(tier_map_str: str) -> dict[str, str]:
+    """Parse tier map from string.
+
+    Args:
+        tier_map_str: Format "stage1:CHEAP,stage2:CAPABLE"
+
+    Returns:
+        Dict mapping stage to tier
+
+    """
+    tier_map = {}
+    for pair in tier_map_str.split(","):
+        stage, tier = pair.split(":")
+        tier_map[stage.strip()] = tier.strip()
+    return tier_map
+
+
+def main():
+    """Main CLI entry point."""
+    import argparse
+
+    parser = argparse.ArgumentParser(
+        description="Workflow Factory - Create workflows 12x faster",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+
+    subparsers = parser.add_subparsers(dest="command", help="Command to run")
+
+    # create command
+    parser_create = subparsers.add_parser("create", help="Create a new workflow")
+    parser_create.add_argument("name", help="Workflow name (kebab-case, e.g., bug-scanner)")
+    parser_create.add_argument("--description", "-d", help="Workflow description")
+    parser_create.add_argument(
+        "--patterns",
+        "-p",
+        help="Comma-separated pattern IDs (e.g., multi-stage,conditional-tier)",
+    )
+    parser_create.add_argument("--stages", "-s", help="Comma-separated stage names")
+    parser_create.add_argument(
+        "--tier-map",
+        "-t",
+        help="Tier map (e.g., analyze:CHEAP,process:CAPABLE)",
+    )
+    parser_create.add_argument("--output", "-o", help="Output directory (default: current)")
+    parser_create.set_defaults(func=cmd_create)
+
+    # list-patterns command
+    parser_list = subparsers.add_parser("list-patterns", help="List available patterns")
+    parser_list.set_defaults(func=cmd_list_patterns)
+
+    # recommend command
+    parser_recommend = subparsers.add_parser("recommend", help="Recommend patterns for a type")
+    parser_recommend.add_argument(
+        "type",
+        help="Workflow type (code-analysis, simple, multi-agent, etc.)",
+    )
+    parser_recommend.set_defaults(func=cmd_recommend)
+
+    args = parser.parse_args()
+
+    if not args.command:
+        parser.print_help()
+        sys.exit(1)
+
+    args.func(args)
+
+
+if __name__ == "__main__":
+    main()