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

coach_wizards/__init__.py

@@ -1,5 +1,4 @@
-"""
-Coach Wizards - 16 Specialized Software Development Wizards
+"""Coach Wizards - 17 Specialized Software Development Wizards
 
 Level 4 Anticipatory Empathy for software development using the Empathy Framework.
 
@@ -19,26 +18,28 @@ from .migration_wizard import MigrationWizard
 from .monitoring_wizard import MonitoringWizard
 from .observability_wizard import ObservabilityWizard
 from .performance_wizard import PerformanceWizard
+from .prompt_engineering_wizard import PromptEngineeringWizard
 from .refactoring_wizard import RefactoringWizard
 from .scaling_wizard import ScalingWizard
 from .security_wizard import SecurityWizard
 from .testing_wizard import TestingWizard
 
 __all__ = [
-    "SecurityWizard",
-    "PerformanceWizard",
+    "APIWizard",
     "AccessibilityWizard",
-    "TestingWizard",
-    "RefactoringWizard",
+    "CICDWizard",
+    "ComplianceWizard",
     "DatabaseWizard",
-    "APIWizard",
     "DebuggingWizard",
-    "ScalingWizard",
-    "ObservabilityWizard",
-    "CICDWizard",
     "DocumentationWizard",
-    "ComplianceWizard",
+    "LocalizationWizard",
     "MigrationWizard",
     "MonitoringWizard",
-    "LocalizationWizard",
+    "ObservabilityWizard",
+    "PerformanceWizard",
+    "PromptEngineeringWizard",
+    "RefactoringWizard",
+    "ScalingWizard",
+    "SecurityWizard",
+    "TestingWizard",
 ]

coach_wizards/accessibility_wizard.py

@@ -1,5 +1,4 @@
-"""
-AccessibilityWizard - Web accessibility (WCAG) compliance
+"""AccessibilityWizard - Web accessibility (WCAG) compliance
 
 Level 4 Anticipatory Empathy for Accessibility using the Empathy Framework.
 
@@ -13,8 +12,7 @@ from .base_wizard import BaseCoachWizard, WizardIssue, WizardPrediction
 
 
 class AccessibilityWizard(BaseCoachWizard):
-    """
-    Web accessibility (WCAG) compliance
+    """Web accessibility (WCAG) compliance
 
     Detects:
     - missing alt text
@@ -36,8 +34,7 @@ class AccessibilityWizard(BaseCoachWizard):
         )
 
     def analyze_code(self, code: str, file_path: str, language: str) -> list[WizardIssue]:
-        """
-        Analyze code for accessibility issues
+        """Analyze code for accessibility issues
 
         This is a reference implementation. In production, integrate with:
         - Static analysis tools
@@ -57,10 +54,13 @@ class AccessibilityWizard(BaseCoachWizard):
         return issues
 
     def predict_future_issues(
-        self, code: str, file_path: str, project_context: dict[str, Any], timeline_days: int = 90
+        self,
+        code: str,
+        file_path: str,
+        project_context: dict[str, Any],
+        timeline_days: int = 90,
     ) -> list[WizardPrediction]:
-        """
-        Level 4 Anticipatory: Predict accessibility issues {timeline_days} days ahead
+        """Level 4 Anticipatory: Predict accessibility issues {timeline_days} days ahead
 
         Uses:
         - Historical patterns
@@ -76,16 +76,16 @@ class AccessibilityWizard(BaseCoachWizard):
 
         self.logger.info(
             f"{self.name} predicted {len(predictions)} future issues "
-            f"for {file_path} ({timeline_days} days ahead)"
+            f"for {file_path} ({timeline_days} days ahead)",
         )
         return predictions
 
     def suggest_fixes(self, issue: WizardIssue) -> str:
-        """
-        Suggest how to fix a accessibility issue
+        """Suggest how to fix a accessibility issue
 
         Returns:
             Detailed fix suggestion with code examples
+
         """
         # Implementation depends on issue type
         return f"Fix suggestion for {issue.category} issue: {issue.message}"

coach_wizards/api_wizard.py

@@ -1,5 +1,4 @@
-"""
-APIWizard - API design and integration analysis
+"""APIWizard - API design and integration analysis
 
 Level 4 Anticipatory Empathy for API using the Empathy Framework.
 
@@ -13,8 +12,7 @@ from .base_wizard import BaseCoachWizard, WizardIssue, WizardPrediction
 
 
 class APIWizard(BaseCoachWizard):
-    """
-    API design and integration analysis
+    """API design and integration analysis
 
     Detects:
     - inconsistent endpoints
@@ -36,8 +34,7 @@ class APIWizard(BaseCoachWizard):
         )
 
     def analyze_code(self, code: str, file_path: str, language: str) -> list[WizardIssue]:
-        """
-        Analyze code for api issues
+        """Analyze code for api issues
 
         This is a reference implementation. In production, integrate with:
         - Static analysis tools
@@ -57,10 +54,13 @@ class APIWizard(BaseCoachWizard):
         return issues
 
     def predict_future_issues(
-        self, code: str, file_path: str, project_context: dict[str, Any], timeline_days: int = 90
+        self,
+        code: str,
+        file_path: str,
+        project_context: dict[str, Any],
+        timeline_days: int = 90,
     ) -> list[WizardPrediction]:
-        """
-        Level 4 Anticipatory: Predict api issues {timeline_days} days ahead
+        """Level 4 Anticipatory: Predict api issues {timeline_days} days ahead
 
         Uses:
         - Historical patterns
@@ -76,16 +76,16 @@ class APIWizard(BaseCoachWizard):
 
         self.logger.info(
             f"{self.name} predicted {len(predictions)} future issues "
-            f"for {file_path} ({timeline_days} days ahead)"
+            f"for {file_path} ({timeline_days} days ahead)",
         )
         return predictions
 
     def suggest_fixes(self, issue: WizardIssue) -> str:
-        """
-        Suggest how to fix a api issue
+        """Suggest how to fix a api issue
 
         Returns:
             Detailed fix suggestion with code examples
+
         """
         # Implementation depends on issue type
         return f"Fix suggestion for {issue.category} issue: {issue.message}"

coach_wizards/base_wizard.py

@@ -1,5 +1,4 @@
-"""
-Base Coach Wizard - Foundation for all Coach wizards
+"""Base Coach Wizard - Foundation for all Coach wizards
 
 Level 4 Anticipatory Empathy implementation using the Empathy Framework.
 
@@ -56,8 +55,7 @@ class WizardResult:
 
 
 class BaseCoachWizard(ABC):
-    """
-    Base class for all Coach wizards
+    """Base class for all Coach wizards
 
     Implements Level 4 Anticipatory Empathy:
     - Analyzes current code
@@ -73,8 +71,7 @@ class BaseCoachWizard(ABC):
 
     @abstractmethod
     def analyze_code(self, code: str, file_path: str, language: str) -> list[WizardIssue]:
-        """
-        Analyze code for current issues
+        """Analyze code for current issues
 
         Args:
             code: Source code to analyze
@@ -83,15 +80,18 @@ class BaseCoachWizard(ABC):
 
         Returns:
             List of issues found
+
         """
-        pass
 
     @abstractmethod
     def predict_future_issues(
-        self, code: str, file_path: str, project_context: dict[str, Any], timeline_days: int = 90
+        self,
+        code: str,
+        file_path: str,
+        project_context: dict[str, Any],
+        timeline_days: int = 90,
     ) -> list[WizardPrediction]:
-        """
-        Level 4 Anticipatory: Predict issues 30-90 days ahead
+        """Level 4 Anticipatory: Predict issues 30-90 days ahead
 
         Args:
             code: Source code to analyze
@@ -101,21 +101,20 @@ class BaseCoachWizard(ABC):
 
         Returns:
             List of predicted future issues
+
         """
-        pass
 
     @abstractmethod
     def suggest_fixes(self, issue: WizardIssue) -> str:
-        """
-        Suggest how to fix an issue
+        """Suggest how to fix an issue
 
         Args:
             issue: The issue to fix
 
         Returns:
             Fix suggestion with code examples
+
         """
-        pass
 
     def run_full_analysis(
         self,
@@ -124,8 +123,7 @@ class BaseCoachWizard(ABC):
         language: str,
         project_context: dict[str, Any] | None = None,
     ) -> WizardResult:
-        """
-        Run complete analysis: current issues + future predictions
+        """Run complete analysis: current issues + future predictions
 
         Args:
             code: Source code to analyze
@@ -135,6 +133,7 @@ class BaseCoachWizard(ABC):
 
         Returns:
             Complete wizard result
+
         """
         start_time = datetime.now()
 
@@ -145,7 +144,10 @@ class BaseCoachWizard(ABC):
         predictions = []
         if project_context:
             predictions = self.predict_future_issues(
-                code, file_path, project_context, timeline_days=90
+                code,
+                file_path,
+                project_context,
+                timeline_days=90,
             )
 
         # Generate recommendations
@@ -167,7 +169,9 @@ class BaseCoachWizard(ABC):
         )
 
     def _generate_recommendations(
-        self, issues: list[WizardIssue], predictions: list[WizardPrediction]
+        self,
+        issues: list[WizardIssue],
+        predictions: list[WizardPrediction],
     ) -> list[str]:
         """Generate actionable recommendations"""
         recommendations = []
@@ -181,13 +185,15 @@ class BaseCoachWizard(ABC):
         high_probability_predictions = [p for p in predictions if p.probability > 0.7]
         if high_probability_predictions:
             recommendations.append(
-                f"Prevent {len(high_probability_predictions)} predicted issues with high probability"
+                f"Prevent {len(high_probability_predictions)} predicted issues with high probability",
             )
 
         return recommendations
 
     def _generate_summary(
-        self, issues: list[WizardIssue], predictions: list[WizardPrediction]
+        self,
+        issues: list[WizardIssue],
+        predictions: list[WizardPrediction],
     ) -> str:
         """Generate human-readable summary"""
         error_count = len([i for i in issues if i.severity == "error"])

coach_wizards/cicd_wizard.py

@@ -1,5 +1,4 @@
-"""
-CICDWizard - CI/CD pipeline optimization
+"""CICDWizard - CI/CD pipeline optimization
 
 Level 4 Anticipatory Empathy for DevOps using the Empathy Framework.
 
@@ -13,8 +12,7 @@ from .base_wizard import BaseCoachWizard, WizardIssue, WizardPrediction
 
 
 class CICDWizard(BaseCoachWizard):
-    """
-    CI/CD pipeline optimization
+    """CI/CD pipeline optimization
 
     Detects:
     - slow pipelines
@@ -30,12 +28,13 @@ class CICDWizard(BaseCoachWizard):
 
     def __init__(self):
         super().__init__(
-            name="CICDWizard", category="DevOps", languages=["yaml", "groovy", "python", "bash"]
+            name="CICDWizard",
+            category="DevOps",
+            languages=["yaml", "groovy", "python", "bash"],
         )
 
     def analyze_code(self, code: str, file_path: str, language: str) -> list[WizardIssue]:
-        """
-        Analyze code for devops issues
+        """Analyze code for devops issues
 
         This is a reference implementation. In production, integrate with:
         - Static analysis tools
@@ -55,10 +54,13 @@ class CICDWizard(BaseCoachWizard):
         return issues
 
     def predict_future_issues(
-        self, code: str, file_path: str, project_context: dict[str, Any], timeline_days: int = 90
+        self,
+        code: str,
+        file_path: str,
+        project_context: dict[str, Any],
+        timeline_days: int = 90,
     ) -> list[WizardPrediction]:
-        """
-        Level 4 Anticipatory: Predict devops issues {timeline_days} days ahead
+        """Level 4 Anticipatory: Predict devops issues {timeline_days} days ahead
 
         Uses:
         - Historical patterns
@@ -74,16 +76,16 @@ class CICDWizard(BaseCoachWizard):
 
         self.logger.info(
             f"{self.name} predicted {len(predictions)} future issues "
-            f"for {file_path} ({timeline_days} days ahead)"
+            f"for {file_path} ({timeline_days} days ahead)",
         )
         return predictions
 
     def suggest_fixes(self, issue: WizardIssue) -> str:
-        """
-        Suggest how to fix a devops issue
+        """Suggest how to fix a devops issue
 
         Returns:
             Detailed fix suggestion with code examples
+
         """
         # Implementation depends on issue type
         return f"Fix suggestion for {issue.category} issue: {issue.message}"

coach_wizards/code_reviewer_README.md

@@ -0,0 +1,60 @@
+# Code Reviewer Wizard
+
+**Domain:** software
+**Type:** Wizard
+**Generated:** Pattern-Compose Methodology
+
+## Overview
+
+Auto-generated wizard using proven patterns from the Empathy Framework.
+
+## Patterns Used
+
+- **Empathy Level**: 0-4 empathy level configuration
+- **User Guidance**: Help text, examples, and prompts
+- **Code Analysis Input**: Standard code analysis input (code, file_path, language)
+- **Risk Assessment**: Level 4 Anticipatory risk analysis
+- **Prediction**: Level 4 Anticipatory prediction of future issues
+- **Config Validation**: Validate wizard configuration on initialization
+
+## Usage
+
+```python
+from coach_wizards.code_reviewer_wizard import CodeReviewerWizard
+
+wizard = CodeReviewerWizard()
+result = await wizard.process(user_input="...")
+```
+
+## API Endpoints
+
+```bash
+# Process with wizard
+POST /api/wizard/code_reviewer/process
+{
+  "input": "your input here",
+  "context": {}
+}
+```
+
+## Testing
+
+```bash
+# Run unit tests
+pytest tests/unit/wizards/test_code_reviewer_wizard.py
+
+# Run with coverage
+pytest tests/unit/wizards/test_code_reviewer_wizard.py --cov
+```
+
+## Next Steps
+
+1. Customize wizard logic as needed
+2. Add domain-specific validation
+3. Extend with additional features
+4. Update tests for custom logic
+
+---
+
+**Generated by:** Empathy Framework - Wizard Factory
+**Methodology:** Pattern-Compose

coach_wizards/code_reviewer_wizard.py

@@ -0,0 +1,180 @@
+"""Code reviewer Coach Wizard.
+
+Auto-generated by Empathy Framework Scaffolding
+Methodology: pattern-compose
+Domain: software
+Patterns: empathy_level, user_guidance, code_analysis_input, risk_assessment, prediction, config_validation
+Generated: 2026-01-05T20:15:45.111917
+"""
+
+import logging
+from typing import Any
+
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel, Field
+
+from patterns import get_pattern_registry
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter(prefix="/code_reviewer", tags=["code_reviewer"])
+
+# Pattern registry for recommendations
+registry = get_pattern_registry()
+
+
+# Request/Response Models
+class AnalysisRequest(BaseModel):
+    """Request to analyze code."""
+
+    code: str = Field(..., description="Code to analyze")
+    context: dict[str, Any] = Field(default_factory=dict, description="Additional context")
+    include_risk_assessment: bool = Field(default=True, description="Include risk analysis")
+
+
+class AnalysisResult(BaseModel):
+    """Analysis result."""
+
+    wizard_id: str
+    analysis: dict[str, Any]
+    risk_assessment: dict[str, Any] | None = None
+    predictions: list[dict[str, Any]] = Field(default_factory=list)
+
+
+# In-memory session storage (replace with Redis in production)
+sessions: dict[str, dict[str, Any]] = {}
+
+
+@router.post("/analyze", response_model=AnalysisResult)
+async def analyze_code(request: AnalysisRequest) -> AnalysisResult:
+    """Analyze code and provide recommendations.
+
+    Args:
+        request: Analysis request with code and context
+
+    Returns:
+        Analysis results with recommendations
+
+    Raises:
+        HTTPException: If analysis fails
+    """
+    try:
+        # Create session
+        wizard_id = f"code_reviewer_{len(sessions) + 1}"
+
+        # Perform code analysis
+        analysis = await _analyze_code(request.code, request.context)
+
+        result = AnalysisResult(
+            wizard_id=wizard_id,
+            analysis=analysis,
+        )
+
+        # Perform risk assessment
+        if request.include_risk_assessment:
+            risk_assessment = await _assess_risk(analysis)
+            result.risk_assessment = risk_assessment
+
+        # Generate predictions
+        predictions = await _generate_predictions(analysis)
+        result.predictions = predictions
+
+        # Store session
+        sessions[wizard_id] = {
+            "wizard_id": wizard_id,
+            "code": request.code,
+            "analysis": analysis,
+            "result": result.model_dump(),
+        }
+
+        logger.info(f"Analysis complete for {wizard_id}")
+        return result
+
+    except Exception as e:
+        logger.exception(f"Analysis failed: {e}")
+        raise HTTPException(status_code=500, detail=f"Analysis failed: {str(e)}")
+
+
+@router.get("/{wizard_id}/report", response_model=dict[str, Any])
+async def get_report(wizard_id: str) -> dict[str, Any]:
+    """Get analysis report.
+
+    Args:
+        wizard_id: Wizard session ID
+
+    Returns:
+        Complete analysis report
+
+    Raises:
+        HTTPException: If session not found
+    """
+    if wizard_id not in sessions:
+        raise HTTPException(status_code=404, detail="Session not found")
+
+    session = sessions[wizard_id]
+    return {
+        "wizard_id": wizard_id,
+        "analysis": session["analysis"],
+        "result": session["result"],
+    }
+
+
+# Helper functions
+async def _analyze_code(code: str, context: dict[str, Any]) -> dict[str, Any]:
+    """Analyze code (placeholder - implement actual analysis).
+
+    Args:
+        code: Code to analyze
+        context: Additional context
+
+    Returns:
+        Analysis results
+    """
+    # TODO: Implement actual code analysis
+    return {
+        "lines_of_code": len(code.split("\n")),
+        "complexity": "medium",
+        "issues_found": 0,
+        "context": context,
+    }
+
+
+async def _assess_risk(analysis: dict[str, Any]) -> dict[str, Any]:
+    """Assess risk based on analysis.
+
+    Args:
+        analysis: Code analysis results
+
+    Returns:
+        Risk assessment
+    """
+    # TODO: Implement actual risk assessment
+    return {
+        "alert_level": "LOW",
+        "risk_score": 0.2,
+        "by_risk_level": {
+            "critical": 0,
+            "high": 0,
+            "medium": 0,
+            "low": 0,
+        },
+    }
+
+
+async def _generate_predictions(analysis: dict[str, Any]) -> list[dict[str, Any]]:
+    """Generate predictions about future issues.
+
+    Args:
+        analysis: Code analysis results
+
+    Returns:
+        List of predictions
+    """
+    # TODO: Implement actual predictions
+    return [
+        {
+            "type": "performance",
+            "confidence": 0.8,
+            "description": "May experience performance issues with large datasets",
+        }
+    ]

coach_wizards/compliance_wizard.py

@@ -1,5 +1,4 @@
-"""
-ComplianceWizard - Regulatory and compliance checking
+"""ComplianceWizard - Regulatory and compliance checking
 
 Level 4 Anticipatory Empathy for Compliance using the Empathy Framework.
 
@@ -13,8 +12,7 @@ from .base_wizard import BaseCoachWizard, WizardIssue, WizardPrediction
 
 
 class ComplianceWizard(BaseCoachWizard):
-    """
-    Regulatory and compliance checking
+    """Regulatory and compliance checking
 
     Detects:
     - PII handling issues
@@ -36,8 +34,7 @@ class ComplianceWizard(BaseCoachWizard):
         )
 
     def analyze_code(self, code: str, file_path: str, language: str) -> list[WizardIssue]:
-        """
-        Analyze code for compliance issues
+        """Analyze code for compliance issues
 
         This is a reference implementation. In production, integrate with:
         - Static analysis tools
@@ -57,10 +54,13 @@ class ComplianceWizard(BaseCoachWizard):
         return issues
 
     def predict_future_issues(
-        self, code: str, file_path: str, project_context: dict[str, Any], timeline_days: int = 90
+        self,
+        code: str,
+        file_path: str,
+        project_context: dict[str, Any],
+        timeline_days: int = 90,
     ) -> list[WizardPrediction]:
-        """
-        Level 4 Anticipatory: Predict compliance issues {timeline_days} days ahead
+        """Level 4 Anticipatory: Predict compliance issues {timeline_days} days ahead
 
         Uses:
         - Historical patterns
@@ -76,16 +76,16 @@ class ComplianceWizard(BaseCoachWizard):
 
         self.logger.info(
             f"{self.name} predicted {len(predictions)} future issues "
-            f"for {file_path} ({timeline_days} days ahead)"
+            f"for {file_path} ({timeline_days} days ahead)",
         )
         return predictions
 
     def suggest_fixes(self, issue: WizardIssue) -> str:
-        """
-        Suggest how to fix a compliance issue
+        """Suggest how to fix a compliance issue
 
         Returns:
             Detailed fix suggestion with code examples
+
         """
         # Implementation depends on issue type
         return f"Fix suggestion for {issue.category} issue: {issue.message}"