attune-ai 2.0.0__py3-none-any.whl

attune_software/plugin.py

@@ -0,0 +1,188 @@
+"""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 attune.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

@@ -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 attune.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

@@ -0,0 +1,265 @@
+"""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 attune.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" / "attune" / "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,
+        }