empathy-framework 4.6.6__py3-none-any.whl → 4.7.0__py3-none-any.whl

empathy_software_plugin/cli.py

@@ -570,127 +570,5 @@ Examples:
     return 0
 
 
-def scan_command():
-    """Entry point for empathy-scan command (converted from bin/empathy-scan).
-    One-click security & performance scanner.
-    """
-    logger.info("Empathy Framework security and performance scanner started")
-
-    if len(sys.argv) < 3:
-        logger.warning("Insufficient arguments provided to scan_command")
-        print("Usage: empathy-scan [security|performance|all] <file-or-directory>")
-        print("\nExamples:")
-        print("  empathy-scan security app.py")
-        print("  empathy-scan performance ./src")
-        print("  empathy-scan all ./project")
-        sys.exit(1)
-
-    scan_type = sys.argv[1].lower()
-    target = sys.argv[2]
-
-    logger.info(f"Scan initiated: type={scan_type}, target={target}")
-
-    # Import wizards
-    try:
-        from coach_wizards import PerformanceWizard, SecurityWizard
-    except ImportError:
-        logger.error("Empathy Framework wizards not installed")
-        print("Error: Empathy Framework wizards not installed.")
-        print("Run: pip install empathy-framework[all]")
-        sys.exit(1)
-
-    # Determine if target is file or directory
-    target_path = Path(target)
-    if not target_path.exists():
-        logger.error(f"Target does not exist: {target}")
-        print(f"Error: {target} does not exist")
-        sys.exit(1)
-
-    # Collect files to scan
-    files_to_scan = []
-    if target_path.is_file():
-        files_to_scan = [target_path]
-    else:
-        # Scan directory for Python files
-        files_to_scan = list(target_path.rglob("*.py"))
-
-    if not files_to_scan:
-        logger.warning(f"No Python files found in {target}")
-        print(f"No Python files found in {target}")
-        sys.exit(0)
-
-    logger.info(f"Scanning {len(files_to_scan)} file(s)")
-    print(f"🔍 Scanning {len(files_to_scan)} file(s)...")
-    print()
-
-    total_issues = 0
-    total_predictions = 0
-
-    # Run appropriate wizards
-    wizards = []
-    if scan_type in ["security", "all"]:
-        wizards.append(("Security", SecurityWizard()))
-    if scan_type in ["performance", "all"]:
-        wizards.append(("Performance", PerformanceWizard()))
-
-    if not wizards:
-        print(f"Unknown scan type: {scan_type}")
-        print("Use: security, performance, or all")
-        sys.exit(1)
-
-    # Scan each file
-    for file_path in files_to_scan:
-        try:
-            with open(file_path, encoding="utf-8") as f:
-                code = f.read()
-        except Exception as e:
-            print(f"⚠️  Could not read {file_path}: {e}")
-            continue
-
-        print(f"📄 {file_path}")
-
-        for wizard_name, wizard in wizards:
-            result = wizard.run_full_analysis(
-                code=code,
-                file_path=str(file_path),
-                language="python",
-            )
-
-            if result.issues:
-                print(f"  {wizard_name}: {len(result.issues)} issue(s) found")
-                for issue in result.issues[:3]:  # Show first 3
-                    severity_icon = (
-                        "🔴"
-                        if issue.severity == "high"
-                        else "🟡" if issue.severity == "medium" else "🔵"
-                    )
-                    print(f"    {severity_icon} Line {issue.line_number}: {issue.message}")
-                if len(result.issues) > 3:
-                    print(f"    ... and {len(result.issues) - 3} more")
-                total_issues += len(result.issues)
-            else:
-                print(f"  {wizard_name}: ✅ No issues")
-
-            if result.predictions:
-                print(f"  🔮 {len(result.predictions)} prediction(s) for next 90 days")
-                total_predictions += len(result.predictions)
-
-        print()
-
-    # Summary
-    print("=" * 50)
-    print("📊 SUMMARY")
-    print(f"  Files scanned: {len(files_to_scan)}")
-    print(f"  Current issues: {total_issues}")
-    print(f"  Future predictions: {total_predictions}")
-
-    if total_issues > 0:
-        print(f"\n⚠️  Found {total_issues} issue(s) that need attention")
-        sys.exit(1)
-    else:
-        print("\n✅ All checks passed!")
-        sys.exit(0)
-
-
 if __name__ == "__main__":
     sys.exit(main())

coach_wizards/__init__.py

@@ -1,45 +0,0 @@
-"""Coach Wizards - 17 Specialized Software Development Wizards
-
-Level 4 Anticipatory Empathy for software development using the Empathy Framework.
-
-Copyright 2025 Smart AI Memory, LLC
-Licensed under Fair Source 0.9
-"""
-
-from .accessibility_wizard import AccessibilityWizard
-from .api_wizard import APIWizard
-from .cicd_wizard import CICDWizard
-from .compliance_wizard import ComplianceWizard
-from .database_wizard import DatabaseWizard
-from .debugging_wizard import DebuggingWizard
-from .documentation_wizard import DocumentationWizard
-from .localization_wizard import LocalizationWizard
-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__ = [
-    "APIWizard",
-    "AccessibilityWizard",
-    "CICDWizard",
-    "ComplianceWizard",
-    "DatabaseWizard",
-    "DebuggingWizard",
-    "DocumentationWizard",
-    "LocalizationWizard",
-    "MigrationWizard",
-    "MonitoringWizard",
-    "ObservabilityWizard",
-    "PerformanceWizard",
-    "PromptEngineeringWizard",
-    "RefactoringWizard",
-    "ScalingWizard",
-    "SecurityWizard",
-    "TestingWizard",
-]

coach_wizards/accessibility_wizard.py

@@ -1,91 +0,0 @@
-"""AccessibilityWizard - Web accessibility (WCAG) compliance
-
-Level 4 Anticipatory Empathy for Accessibility using the Empathy Framework.
-
-Copyright 2025 Smart AI Memory, LLC
-Licensed under Fair Source 0.9
-"""
-
-from typing import Any
-
-from .base_wizard import BaseCoachWizard, WizardIssue, WizardPrediction
-
-
-class AccessibilityWizard(BaseCoachWizard):
-    """Web accessibility (WCAG) compliance
-
-    Detects:
-    - missing alt text
-    - no ARIA labels
-    - insufficient color contrast
-    - keyboard navigation issues
-
-    Predicts (Level 4):
-    - compliance violations
-    - user experience degradation
-    - legal exposure
-    """
-
-    def __init__(self):
-        super().__init__(
-            name="AccessibilityWizard",
-            category="Accessibility",
-            languages=["html", "jsx", "tsx", "vue", "svelte"],
-        )
-
-    def analyze_code(self, code: str, file_path: str, language: str) -> list[WizardIssue]:
-        """Analyze code for accessibility issues
-
-        This is a reference implementation. In production, integrate with:
-        - Static analysis tools
-        - Linters and security scanners
-        - Custom rule engines
-        - AI models (Claude, GPT-4)
-        """
-        issues = []
-
-        # Example heuristic detection
-        lines = code.split("\n")
-        for _i, _line in enumerate(lines, 1):
-            # Add detection logic based on accessibility
-            pass
-
-        self.logger.info(f"{self.name} found {len(issues)} issues in {file_path}")
-        return issues
-
-    def predict_future_issues(
-        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
-
-        Uses:
-        - Historical patterns
-        - Code trajectory analysis
-        - Dependency evolution
-        - Team velocity
-        - Industry trends
-        """
-        predictions = []
-
-        # Example prediction logic
-        # In production, use ML models trained on historical data
-
-        self.logger.info(
-            f"{self.name} predicted {len(predictions)} future issues "
-            f"for {file_path} ({timeline_days} days ahead)",
-        )
-        return predictions
-
-    def suggest_fixes(self, issue: WizardIssue) -> str:
-        """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,91 +0,0 @@
-"""APIWizard - API design and integration analysis
-
-Level 4 Anticipatory Empathy for API using the Empathy Framework.
-
-Copyright 2025 Smart AI Memory, LLC
-Licensed under Fair Source 0.9
-"""
-
-from typing import Any
-
-from .base_wizard import BaseCoachWizard, WizardIssue, WizardPrediction
-
-
-class APIWizard(BaseCoachWizard):
-    """API design and integration analysis
-
-    Detects:
-    - inconsistent endpoints
-    - missing validation
-    - poor error handling
-    - versioning issues
-
-    Predicts (Level 4):
-    - breaking changes impact
-    - backward compatibility issues
-    - integration failures
-    """
-
-    def __init__(self):
-        super().__init__(
-            name="APIWizard",
-            category="API",
-            languages=["python", "javascript", "typescript", "java", "go", "rust"],
-        )
-
-    def analyze_code(self, code: str, file_path: str, language: str) -> list[WizardIssue]:
-        """Analyze code for api issues
-
-        This is a reference implementation. In production, integrate with:
-        - Static analysis tools
-        - Linters and security scanners
-        - Custom rule engines
-        - AI models (Claude, GPT-4)
-        """
-        issues = []
-
-        # Example heuristic detection
-        lines = code.split("\n")
-        for _i, _line in enumerate(lines, 1):
-            # Add detection logic based on api
-            pass
-
-        self.logger.info(f"{self.name} found {len(issues)} issues in {file_path}")
-        return issues
-
-    def predict_future_issues(
-        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
-
-        Uses:
-        - Historical patterns
-        - Code trajectory analysis
-        - Dependency evolution
-        - Team velocity
-        - Industry trends
-        """
-        predictions = []
-
-        # Example prediction logic
-        # In production, use ML models trained on historical data
-
-        self.logger.info(
-            f"{self.name} predicted {len(predictions)} future issues "
-            f"for {file_path} ({timeline_days} days ahead)",
-        )
-        return predictions
-
-    def suggest_fixes(self, issue: WizardIssue) -> str:
-        """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,209 +0,0 @@
-"""Base Coach Wizard - Foundation for all Coach wizards
-
-Level 4 Anticipatory Empathy implementation using the Empathy Framework.
-
-Copyright 2025 Smart AI Memory, LLC
-Licensed under Fair Source 0.9
-"""
-
-import logging
-from abc import ABC, abstractmethod
-from dataclasses import dataclass
-from datetime import datetime
-from typing import Any
-
-logger = logging.getLogger(__name__)
-
-
-@dataclass
-class WizardIssue:
-    """Represents an issue found by a wizard"""
-
-    severity: str  # 'error', 'warning', 'info'
-    message: str
-    file_path: str
-    line_number: int | None
-    code_snippet: str | None
-    fix_suggestion: str | None
-    category: str
-    confidence: float  # 0.0 to 1.0
-
-
-@dataclass
-class WizardPrediction:
-    """Level 4 Anticipatory: Predicts future issues"""
-
-    predicted_date: datetime
-    issue_type: str
-    probability: float
-    impact: str  # 'low', 'medium', 'high', 'critical'
-    prevention_steps: list[str]
-    reasoning: str
-
-
-@dataclass
-class WizardResult:
-    """Result from running a wizard"""
-
-    wizard_name: str
-    issues: list[WizardIssue]
-    predictions: list[WizardPrediction]
-    summary: str
-    analyzed_files: int
-    analysis_time: float
-    recommendations: list[str]
-
-
-class BaseCoachWizard(ABC):
-    """Base class for all Coach wizards
-
-    Implements Level 4 Anticipatory Empathy:
-    - Analyzes current code
-    - Predicts future issues (30-90 days ahead)
-    - Provides prevention strategies
-    """
-
-    def __init__(self, name: str, category: str, languages: list[str]):
-        self.name = name
-        self.category = category
-        self.languages = languages
-        self.logger = logging.getLogger(f"coach.{name}")
-
-    @abstractmethod
-    def analyze_code(self, code: str, file_path: str, language: str) -> list[WizardIssue]:
-        """Analyze code for current issues
-
-        Args:
-            code: Source code to analyze
-            file_path: Path to the file being analyzed
-            language: Programming language
-
-        Returns:
-            List of issues found
-
-        """
-
-    @abstractmethod
-    def predict_future_issues(
-        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
-
-        Args:
-            code: Source code to analyze
-            file_path: Path to the file
-            project_context: Project metadata (size, team, deployment frequency, etc.)
-            timeline_days: How far ahead to predict (default 90 days)
-
-        Returns:
-            List of predicted future issues
-
-        """
-
-    @abstractmethod
-    def suggest_fixes(self, issue: WizardIssue) -> str:
-        """Suggest how to fix an issue
-
-        Args:
-            issue: The issue to fix
-
-        Returns:
-            Fix suggestion with code examples
-
-        """
-
-    def run_full_analysis(
-        self,
-        code: str,
-        file_path: str,
-        language: str,
-        project_context: dict[str, Any] | None = None,
-    ) -> WizardResult:
-        """Run complete analysis: current issues + future predictions
-
-        Args:
-            code: Source code to analyze
-            file_path: Path to the file
-            language: Programming language
-            project_context: Optional project context for predictions
-
-        Returns:
-            Complete wizard result
-
-        """
-        start_time = datetime.now()
-
-        # Analyze current code
-        issues = self.analyze_code(code, file_path, language)
-
-        # Predict future issues (Level 4)
-        predictions = []
-        if project_context:
-            predictions = self.predict_future_issues(
-                code,
-                file_path,
-                project_context,
-                timeline_days=90,
-            )
-
-        # Generate recommendations
-        recommendations = self._generate_recommendations(issues, predictions)
-
-        # Calculate summary
-        summary = self._generate_summary(issues, predictions)
-
-        analysis_time = (datetime.now() - start_time).total_seconds()
-
-        return WizardResult(
-            wizard_name=self.name,
-            issues=issues,
-            predictions=predictions,
-            summary=summary,
-            analyzed_files=1,
-            analysis_time=analysis_time,
-            recommendations=recommendations,
-        )
-
-    def _generate_recommendations(
-        self,
-        issues: list[WizardIssue],
-        predictions: list[WizardPrediction],
-    ) -> list[str]:
-        """Generate actionable recommendations"""
-        recommendations = []
-
-        # Address current critical issues
-        critical_issues = [i for i in issues if i.severity == "error"]
-        if critical_issues:
-            recommendations.append(f"Fix {len(critical_issues)} critical issues immediately")
-
-        # Address predictions
-        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",
-            )
-
-        return recommendations
-
-    def _generate_summary(
-        self,
-        issues: list[WizardIssue],
-        predictions: list[WizardPrediction],
-    ) -> str:
-        """Generate human-readable summary"""
-        error_count = len([i for i in issues if i.severity == "error"])
-        warning_count = len([i for i in issues if i.severity == "warning"])
-        prediction_count = len(predictions)
-
-        summary = f"{self.name} Analysis: "
-        summary += f"{error_count} errors, {warning_count} warnings found. "
-
-        if prediction_count > 0:
-            summary += f"{prediction_count} future issues predicted (Level 4 Anticipatory)."
-
-        return summary

coach_wizards/cicd_wizard.py

@@ -1,91 +0,0 @@
-"""CICDWizard - CI/CD pipeline optimization
-
-Level 4 Anticipatory Empathy for DevOps using the Empathy Framework.
-
-Copyright 2025 Smart AI Memory, LLC
-Licensed under Fair Source 0.9
-"""
-
-from typing import Any
-
-from .base_wizard import BaseCoachWizard, WizardIssue, WizardPrediction
-
-
-class CICDWizard(BaseCoachWizard):
-    """CI/CD pipeline optimization
-
-    Detects:
-    - slow pipelines
-    - flaky tests
-    - deployment risks
-    - missing automation
-
-    Predicts (Level 4):
-    - deployment failures
-    - pipeline maintenance burden
-    - release delays
-    """
-
-    def __init__(self):
-        super().__init__(
-            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
-
-        This is a reference implementation. In production, integrate with:
-        - Static analysis tools
-        - Linters and security scanners
-        - Custom rule engines
-        - AI models (Claude, GPT-4)
-        """
-        issues = []
-
-        # Example heuristic detection
-        lines = code.split("\n")
-        for _i, _line in enumerate(lines, 1):
-            # Add detection logic based on devops
-            pass
-
-        self.logger.info(f"{self.name} found {len(issues)} issues in {file_path}")
-        return issues
-
-    def predict_future_issues(
-        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
-
-        Uses:
-        - Historical patterns
-        - Code trajectory analysis
-        - Dependency evolution
-        - Team velocity
-        - Industry trends
-        """
-        predictions = []
-
-        # Example prediction logic
-        # In production, use ML models trained on historical data
-
-        self.logger.info(
-            f"{self.name} predicted {len(predictions)} future issues "
-            f"for {file_path} ({timeline_days} days ahead)",
-        )
-        return predictions
-
-    def suggest_fixes(self, issue: WizardIssue) -> str:
-        """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}"