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

empathy_software_plugin/plugin.py

@@ -1,188 +0,0 @@
-"""Software Development Plugin for Empathy Framework
-
-This plugin provides 16+ Coach wizards for code analysis,
-demonstrating Level 4 Anticipatory Empathy in software development.
-
-Based on real-world experience developing AI systems where the framework
-transformed productivity with higher quality code developed many times faster.
-
-Copyright 2025 Smart AI Memory, LLC
-Licensed under Fair Source 0.9
-"""
-
-import logging
-import os
-
-# Import from core framework
-import sys
-
-sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", "src"))
-
-from empathy_os.plugins import BasePlugin, BaseWizard, PluginMetadata
-
-logger = logging.getLogger(__name__)
-
-
-class SoftwarePlugin(BasePlugin):
-    """Software Development Domain Plugin
-
-    Provides wizards for:
-    - Security analysis
-    - Performance optimization
-    - Architecture review
-    - Testing strategy
-    - Code quality assessment
-    - And more...
-
-    All wizards operate at Level 3 (Proactive) or Level 4 (Anticipatory)
-    empathy levels.
-    """
-
-    def get_metadata(self) -> PluginMetadata:
-        """Return plugin metadata"""
-        return PluginMetadata(
-            name="Empathy Framework - Software Development",
-            version="1.0.0",
-            domain="software",
-            description=(
-                "16+ Coach wizards for code analysis and anticipatory "
-                "software development. Alerts you to bottlenecks, security "
-                "vulnerabilities, and architectural issues before they "
-                "become critical."
-            ),
-            author="Smart AI Memory, LLC",
-            license="Apache-2.0",
-            requires_core_version="1.0.0",
-            dependencies=[],  # Add any domain-specific deps
-        )
-
-    def register_wizards(self) -> dict[str, type[BaseWizard]]:
-        """Register all software development wizards.
-
-        In our experience building these wizards, we found that the framework
-        enables a fundamental shift: instead of reactive debugging, the system
-        alerts you to emerging issues that would surface weeks later.
-        """
-        wizards = {}
-
-        # Import wizards with graceful degradation
-        # (some wizards may have optional dependencies)
-
-        try:
-            from .wizards.security_wizard import SecurityWizard
-
-            wizards["security"] = SecurityWizard
-        except ImportError as e:
-            logger.warning(f"SecurityWizard not available: {e}")
-
-        try:
-            from .wizards.performance_wizard import PerformanceWizard
-
-            wizards["performance"] = PerformanceWizard
-        except ImportError as e:
-            logger.warning(f"PerformanceWizard not available: {e}")
-
-        try:
-            from .wizards.testing_wizard import TestingWizard
-
-            wizards["testing"] = TestingWizard
-        except ImportError as e:
-            logger.warning(f"TestingWizard not available: {e}")
-
-        try:
-            from .wizards.architecture_wizard import ArchitectureWizard
-
-            wizards["architecture"] = ArchitectureWizard
-        except ImportError as e:
-            logger.warning(f"ArchitectureWizard not available: {e}")
-
-        # AI Development Wizards (Level 4 Anticipatory)
-        try:
-            from .wizards.prompt_engineering_wizard import PromptEngineeringWizard
-
-            wizards["prompt_engineering"] = PromptEngineeringWizard
-        except ImportError as e:
-            logger.warning(f"PromptEngineeringWizard not available: {e}")
-
-        try:
-            from .wizards.ai_context_wizard import AIContextWindowWizard
-
-            wizards["context_window"] = AIContextWindowWizard
-        except ImportError as e:
-            logger.warning(f"AIContextWindowWizard not available: {e}")
-
-        try:
-            from .wizards.ai_collaboration_wizard import AICollaborationWizard
-
-            wizards["collaboration_pattern"] = AICollaborationWizard
-        except ImportError as e:
-            logger.warning(f"AICollaborationWizard not available: {e}")
-
-        try:
-            from .wizards.ai_documentation_wizard import AIDocumentationWizard
-
-            wizards["ai_documentation"] = AIDocumentationWizard
-        except ImportError as e:
-            logger.warning(f"AIDocumentationWizard not available: {e}")
-
-        try:
-            from .wizards.agent_orchestration_wizard import AgentOrchestrationWizard
-
-            wizards["agent_orchestration"] = AgentOrchestrationWizard
-        except ImportError as e:
-            logger.warning(f"AgentOrchestrationWizard not available: {e}")
-
-        try:
-            from .wizards.rag_pattern_wizard import RAGPatternWizard
-
-            wizards["rag_pattern"] = RAGPatternWizard
-        except ImportError as e:
-            logger.warning(f"RAGPatternWizard not available: {e}")
-
-        try:
-            from .wizards.multi_model_wizard import MultiModelWizard
-
-            wizards["multi_model"] = MultiModelWizard
-        except ImportError as e:
-            logger.warning(f"MultiModelWizard not available: {e}")
-
-        # Add remaining wizards...
-        # In production, you'd import all 16+ wizards
-
-        logger.info(f"Software plugin registered {len(wizards)} wizards")
-
-        return wizards
-
-    def register_patterns(self) -> dict:
-        """Register software development patterns.
-
-        These patterns were learned from real-world usage and enable
-        cross-domain learning (Level 5 Systems Empathy).
-        """
-        return {
-            "domain": "software",
-            "patterns": {
-                "testing_bottleneck": {
-                    "description": (
-                        "Manual testing burden grows faster than team size. "
-                        "Alert: When test count > 25 or test time > 15min, "
-                        "recommend automation framework."
-                    ),
-                    "indicators": ["test_count_growth_rate", "manual_test_time", "wizard_count"],
-                    "threshold": "test_time > 900 seconds",
-                    "recommendation": "Implement test automation framework",
-                },
-                "security_drift": {
-                    "description": (
-                        "Security practices degrade over time without active "
-                        "monitoring. Alert: When new code bypasses security "
-                        "patterns established in existing code."
-                    ),
-                    "indicators": [
-                        "input_validation_coverage",
-                        "authentication_consistency",
-                        "data_sanitization_patterns",
-                    ],
-                },
-            },
-        }

workflow_scaffolding/__init__.py

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

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

@@ -1,206 +0,0 @@
-"""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 empathy_os.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()

workflow_scaffolding/generator.py

@@ -1,265 +0,0 @@
-"""Workflow code generator.
-
-Generates workflow code from patterns and templates.
-
-Copyright 2025 Smart-AI-Memory
-Licensed under Fair Source License 0.9
-"""
-
-from datetime import datetime
-from pathlib import Path
-from typing import Any
-
-from jinja2 import Environment, FileSystemLoader
-
-from empathy_os.workflow_patterns import get_workflow_pattern_registry
-
-
-class WorkflowGenerator:
-    """Generates workflow code from patterns."""
-
-    def __init__(self, templates_dir: Path | None = None):
-        """Initialize generator.
-
-        Args:
-            templates_dir: Path to templates directory
-
-        """
-        if templates_dir is None:
-            templates_dir = Path(__file__).parent / "templates"
-
-        self.templates_dir = templates_dir
-        self.env = Environment(
-            loader=FileSystemLoader(str(templates_dir)),
-            trim_blocks=True,
-            lstrip_blocks=True,
-        )
-        self.registry = get_workflow_pattern_registry()
-
-    def _workflow_name_to_class_name(self, workflow_name: str) -> str:
-        """Convert workflow-name to WorkflowName class name.
-
-        Args:
-            workflow_name: Workflow name (e.g., "bug-scanner")
-
-        Returns:
-            Class name (e.g., "BugScannerWorkflow")
-
-        """
-        parts = workflow_name.replace("-", "_").replace("_", " ").split()
-        return "".join(p.capitalize() for p in parts) + "Workflow"
-
-    def _workflow_name_to_file_name(self, workflow_name: str) -> str:
-        """Convert workflow-name to file_name.
-
-        Args:
-            workflow_name: Workflow name (e.g., "bug-scanner")
-
-        Returns:
-            File name (e.g., "bug_scanner")
-
-        """
-        return workflow_name.replace("-", "_")
-
-    def _merge_code_sections(self, sections_by_location: dict) -> dict[str, str]:
-        """Merge code sections into single strings per location.
-
-        Args:
-            sections_by_location: Dict mapping location to list of CodeSection
-
-        Returns:
-            Dict mapping location to merged code string
-
-        """
-        merged = {}
-
-        for location, sections in sections_by_location.items():
-            # Sort by priority (highest first)
-            sections = sorted(sections, key=lambda s: -s.priority)
-
-            # Merge code
-            code_parts = [s.code for s in sections]
-            merged[location] = "\n\n".join(code_parts)
-
-        return merged
-
-    def generate_workflow(
-        self,
-        workflow_name: str,
-        description: str,
-        patterns: list[str],
-        stages: list[str] | None = None,
-        tier_map: dict[str, str] | None = None,
-        **kwargs: Any,
-    ) -> dict[str, str]:
-        """Generate workflow code.
-
-        Args:
-            workflow_name: Workflow name (e.g., "bug-scanner")
-            description: Workflow description
-            patterns: List of pattern IDs to use
-            stages: List of stage names (auto-generated if None)
-            tier_map: Mapping of stage to tier (auto-generated if None)
-            **kwargs: Additional context for code generation
-
-        Returns:
-            Dict with generated files:
-                - "workflow": Main workflow file content
-                - "test": Test file content
-                - "readme": README content
-
-        """
-        # Validate patterns
-        valid, error = self.registry.validate_pattern_combination(patterns)
-        if not valid:
-            raise ValueError(f"Invalid pattern combination: {error}")
-
-        # Auto-generate stages if not provided
-        if stages is None:
-            if "single-stage" in patterns:
-                stages = ["process"]
-            elif "multi-stage" in patterns:
-                stages = ["analyze", "process", "report"]
-            elif "crew-based" in patterns:
-                stages = ["diagnose", "fix"]
-            else:
-                stages = ["execute"]
-
-        # Auto-generate tier map if not provided
-        if tier_map is None:
-            if len(stages) == 1:
-                tier_map = {stages[0]: "CAPABLE"}
-            elif len(stages) == 2:
-                tier_map = {stages[0]: "CHEAP", stages[1]: "CAPABLE"}
-            else:
-                tier_map = {
-                    stages[0]: "CHEAP",
-                    **dict.fromkeys(stages[1:-1], "CAPABLE"),
-                    stages[-1]: "PREMIUM",
-                }
-
-        # Generate class and file names
-        class_name = self._workflow_name_to_class_name(workflow_name)
-        workflow_file = self._workflow_name_to_file_name(workflow_name)
-
-        # Build context
-        context = {
-            "workflow_name": workflow_name,
-            "class_name": class_name,
-            "workflow_file": workflow_file,
-            "description": description,
-            "stages": stages,
-            "tier_map": tier_map,
-            "generation_date": datetime.now().strftime("%Y-%m-%d"),
-            "complexity": self._determine_complexity(patterns),
-            "patterns": [self.registry.get(p) for p in patterns if self.registry.get(p)],
-            # Pattern flags
-            "has_conditional_tier": "conditional-tier" in patterns,
-            "has_config_driven": "config-driven" in patterns,
-            "has_crew_based": "crew-based" in patterns,
-            "has_result_dataclass": "result-dataclass" in patterns,
-            "has_code_scanner": "code-scanner" in patterns,
-            "has_imports": False,
-            "has_step_config": False,
-            **kwargs,
-        }
-
-        # Generate code sections from patterns
-        sections_by_location = self.registry.generate_code_sections(patterns, context)
-        merged_sections = self._merge_code_sections(sections_by_location)
-
-        # Update context with merged sections
-        context.update(
-            {
-                "imports": merged_sections.get("imports", ""),
-                "helper_functions": merged_sections.get("helper_functions", ""),
-                "dataclasses": merged_sections.get("dataclasses", ""),
-                "class_attributes": merged_sections.get("class_attributes", ""),
-                "init_method": merged_sections.get("init_method", ""),
-                "methods": merged_sections.get("methods", ""),
-            }
-        )
-
-        # Update flags
-        context["has_imports"] = bool(context["imports"])
-        context["has_step_config"] = "WorkflowStepConfig" in str(merged_sections)
-
-        # Generate files
-        workflow_template = self.env.get_template("workflow.py.j2")
-        test_template = self.env.get_template("test.py.j2")
-        readme_template = self.env.get_template("README.md.j2")
-
-        return {
-            "workflow": workflow_template.render(**context),
-            "test": test_template.render(**context),
-            "readme": readme_template.render(**context),
-        }
-
-    def _determine_complexity(self, patterns: list[str]) -> str:
-        """Determine overall workflow complexity.
-
-        Args:
-            patterns: List of pattern IDs
-
-        Returns:
-            Complexity level string
-
-        """
-        if "crew-based" in patterns or "multi-stage" in patterns:
-            return "COMPLEX"
-        if "conditional-tier" in patterns or "config-driven" in patterns:
-            return "MODERATE"
-        return "SIMPLE"
-
-    def write_workflow(
-        self,
-        output_dir: Path,
-        workflow_name: str,
-        description: str,
-        patterns: list[str],
-        **kwargs: Any,
-    ) -> dict[str, Path]:
-        """Generate and write workflow files.
-
-        Args:
-            output_dir: Base output directory
-            workflow_name: Workflow name
-            description: Workflow description
-            patterns: List of pattern IDs
-            **kwargs: Additional generation parameters
-
-        Returns:
-            Dict mapping file type to written path
-
-        """
-        # Generate code
-        generated = self.generate_workflow(
-            workflow_name,
-            description,
-            patterns,
-            **kwargs,
-        )
-
-        # Determine file paths
-        workflow_file = self._workflow_name_to_file_name(workflow_name)
-
-        workflow_dir = output_dir / "src" / "empathy_os" / "workflows"
-        test_dir = output_dir / "tests" / "unit" / "workflows"
-
-        workflow_dir.mkdir(parents=True, exist_ok=True)
-        test_dir.mkdir(parents=True, exist_ok=True)
-
-        workflow_path = workflow_dir / f"{workflow_file}.py"
-        test_path = test_dir / f"test_{workflow_file}.py"
-        readme_path = workflow_dir / f"{workflow_file}_README.md"
-
-        # Write files
-        workflow_path.write_text(generated["workflow"])
-        test_path.write_text(generated["test"])
-        readme_path.write_text(generated["readme"])
-
-        return {
-            "workflow": workflow_path,
-            "test": test_path,
-            "readme": readme_path,
-        }