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

coach_wizards/generate_wizards.py

@@ -1,347 +0,0 @@
-#!/usr/bin/env python3
-"""Generate all 16 Coach wizards from template.
-
-This script generates the 16 specialized Coach wizards.
-This is a development/build utility, excluded from coverage via .coveragerc.
-"""
-
-WIZARD_SPECS = [
-    {
-        "name": "SecurityWizard",
-        "filename": "security_wizard.py",
-        "description": "Security vulnerability detection and prevention",
-        "category": "Security",
-        "languages": ["python", "javascript", "typescript", "java", "go", "rust"],
-        "detects": ["SQL injection", "XSS", "CSRF", "insecure dependencies", "hardcoded secrets"],
-        "predicts": ["emerging vulnerabilities", "dependency risks", "attack surface growth"],
-    },
-    {
-        "name": "PerformanceWizard",
-        "filename": "performance_wizard.py",
-        "description": "Performance optimization and bottleneck detection",
-        "category": "Performance",
-        "languages": ["python", "javascript", "typescript", "java", "go", "rust", "cpp"],
-        "detects": [
-            "N+1 queries",
-            "inefficient algorithms",
-            "memory leaks",
-            "slow database queries",
-        ],
-        "predicts": ["scalability bottlenecks", "response time degradation", "resource exhaustion"],
-    },
-    {
-        "name": "AccessibilityWizard",
-        "filename": "accessibility_wizard.py",
-        "description": "Web accessibility (WCAG) compliance",
-        "category": "Accessibility",
-        "languages": ["html", "jsx", "tsx", "vue", "svelte"],
-        "detects": [
-            "missing alt text",
-            "no ARIA labels",
-            "insufficient color contrast",
-            "keyboard navigation issues",
-        ],
-        "predicts": ["compliance violations", "user experience degradation", "legal exposure"],
-    },
-    {
-        "name": "TestingWizard",
-        "filename": "testing_wizard.py",
-        "description": "Test coverage and quality analysis",
-        "category": "Testing",
-        "languages": ["python", "javascript", "typescript", "java", "go", "rust"],
-        "detects": [
-            "untested code paths",
-            "missing edge cases",
-            "flaky tests",
-            "low code coverage",
-        ],
-        "predicts": ["production bugs", "regression risks", "test maintenance burden"],
-    },
-    {
-        "name": "RefactoringWizard",
-        "filename": "refactoring_wizard.py",
-        "description": "Code quality and refactoring opportunities",
-        "category": "Code Quality",
-        "languages": ["python", "javascript", "typescript", "java", "go", "rust", "cpp"],
-        "detects": ["code smells", "high complexity", "duplicated code", "god classes"],
-        "predicts": [
-            "maintenance burden increase",
-            "bug introduction risk",
-            "team velocity impact",
-        ],
-    },
-    {
-        "name": "DatabaseWizard",
-        "filename": "database_wizard.py",
-        "description": "Database optimization and schema analysis",
-        "category": "Database",
-        "languages": ["sql", "python", "javascript", "typescript", "java", "go"],
-        "detects": ["missing indexes", "N+1 queries", "inefficient joins", "schema issues"],
-        "predicts": ["query performance degradation", "data growth impact", "scaling limitations"],
-    },
-    {
-        "name": "APIWizard",
-        "filename": "api_wizard.py",
-        "description": "API design and integration analysis",
-        "category": "API",
-        "languages": ["python", "javascript", "typescript", "java", "go", "rust"],
-        "detects": [
-            "inconsistent endpoints",
-            "missing validation",
-            "poor error handling",
-            "versioning issues",
-        ],
-        "predicts": [
-            "breaking changes impact",
-            "backward compatibility issues",
-            "integration failures",
-        ],
-    },
-    {
-        "name": "DebuggingWizard",
-        "filename": "debugging_wizard.py",
-        "description": "Error detection and debugging assistance",
-        "category": "Debugging",
-        "languages": ["python", "javascript", "typescript", "java", "go", "rust", "cpp"],
-        "detects": [
-            "potential null references",
-            "unhandled exceptions",
-            "race conditions",
-            "logic errors",
-        ],
-        "predicts": ["runtime errors", "production incidents", "debugging complexity"],
-    },
-    {
-        "name": "ScalingWizard",
-        "filename": "scaling_wizard.py",
-        "description": "Scalability and architecture analysis",
-        "category": "Scalability",
-        "languages": ["python", "javascript", "typescript", "java", "go", "rust"],
-        "detects": ["single points of failure", "synchronous bottlenecks", "resource constraints"],
-        "predicts": ["load handling capacity", "scaling challenges", "architecture limitations"],
-    },
-    {
-        "name": "ObservabilityWizard",
-        "filename": "observability_wizard.py",
-        "description": "Logging, metrics, and tracing analysis",
-        "category": "Observability",
-        "languages": ["python", "javascript", "typescript", "java", "go", "rust"],
-        "detects": ["missing logs", "no metrics", "poor error tracking", "lack of tracing"],
-        "predicts": ["debugging difficulties", "incident response delays", "unknown unknowns"],
-    },
-    {
-        "name": "CICDWizard",
-        "filename": "cicd_wizard.py",
-        "description": "CI/CD pipeline optimization",
-        "category": "DevOps",
-        "languages": ["yaml", "groovy", "python", "bash"],
-        "detects": ["slow pipelines", "flaky tests", "deployment risks", "missing automation"],
-        "predicts": ["deployment failures", "pipeline maintenance burden", "release delays"],
-    },
-    {
-        "name": "DocumentationWizard",
-        "filename": "documentation_wizard.py",
-        "description": "Documentation quality and completeness",
-        "category": "Documentation",
-        "languages": ["python", "javascript", "typescript", "java", "go", "rust", "markdown"],
-        "detects": ["missing docstrings", "outdated docs", "unclear explanations", "no examples"],
-        "predicts": ["knowledge loss", "onboarding difficulties", "support burden"],
-    },
-    {
-        "name": "ComplianceWizard",
-        "filename": "compliance_wizard.py",
-        "description": "Regulatory and compliance checking",
-        "category": "Compliance",
-        "languages": ["python", "javascript", "typescript", "java", "go"],
-        "detects": ["PII handling issues", "GDPR violations", "SOC 2 gaps", "audit trail missing"],
-        "predicts": ["regulatory audits", "compliance violations", "legal exposure"],
-    },
-    {
-        "name": "MigrationWizard",
-        "filename": "migration_wizard.py",
-        "description": "Code migration and upgrade assistance",
-        "category": "Migration",
-        "languages": ["python", "javascript", "typescript", "java", "go", "rust"],
-        "detects": ["deprecated APIs", "breaking changes", "incompatibilities", "migration risks"],
-        "predicts": ["upgrade complexity", "compatibility issues", "migration timeline"],
-    },
-    {
-        "name": "MonitoringWizard",
-        "filename": "monitoring_wizard.py",
-        "description": "System monitoring and alerting",
-        "category": "Monitoring",
-        "languages": ["python", "javascript", "typescript", "java", "go", "yaml"],
-        "detects": ["missing alerts", "alert fatigue", "no SLOs", "blind spots"],
-        "predicts": ["undetected incidents", "alert storm risk", "monitoring gaps"],
-    },
-    {
-        "name": "LocalizationWizard",
-        "filename": "localization_wizard.py",
-        "description": "Internationalization and localization",
-        "category": "Localization",
-        "languages": ["python", "javascript", "typescript", "java", "go", "html", "jsx", "tsx"],
-        "detects": ["hardcoded strings", "missing translations", "locale issues", "RTL problems"],
-        "predicts": [
-            "i18n technical debt",
-            "translation maintenance burden",
-            "locale coverage gaps",
-        ],
-    },
-]
-
-WIZARD_TEMPLATE = '''"""
-{name} - {description}
-
-Level 4 Anticipatory Empathy for {category} using the Empathy Framework.
-
-Copyright 2025 Smart AI Memory, LLC
-Licensed under Fair Source 0.9
-"""
-
-from typing import List, Dict, Any
-from datetime import datetime, timedelta
-from .base_wizard import BaseCoachWizard, WizardIssue, WizardPrediction
-
-
-class {name}(BaseCoachWizard):
-    """
-    {description}
-
-    Detects:
-{detects_list}
-
-    Predicts (Level 4):
-{predicts_list}
-    """
-
-    def __init__(self):
-        super().__init__(
-            name="{name}",
-            category="{category}",
-            languages={languages}
-        )
-
-    def analyze_code(self, code: str, file_path: str, language: str) -> List[WizardIssue]:
-        """
-        Analyze code for {category_lower} 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 {category_lower}
-            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 {category_lower} 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 {category_lower} issue
-
-        Returns:
-            Detailed fix suggestion with code examples
-        """
-        # Implementation depends on issue type
-        return f"Fix suggestion for {{issue.category}} issue: {{issue.message}}"
-
-
-# Example usage
-if __name__ == "__main__":
-    wizard = {name}()
-
-    # Example code to analyze
-    sample_code = '''
-# Add sample code relevant to {category_lower}
-"""
-
-    result = wizard.run_full_analysis(
-        code=sample_code,
-        file_path="example.py",
-        language="python",
-        project_context={{
-            "team_size": 10,
-            "deployment_frequency": "daily",
-            "code_churn_rate": 0.15
-        }}
-    )
-
-    print(f"Analysis: {{result.summary}}")
-    print(f"Issues found: {{len(result.issues)}}")
-    print(f"Predictions: {{len(result.predictions)}}")
-"""
-
-
-def generate_wizard(spec):
-    """Generate a wizard file from spec"""
-    detects_list = "\n".join([f"    - {d}" for d in spec["detects"]])
-    predicts_list = "\n".join([f"    - {p}" for p in spec["predicts"]])
-
-    content = WIZARD_TEMPLATE.format(
-        name=spec["name"],
-        filename=spec["filename"],
-        description=spec["description"],
-        category=spec["category"],
-        category_lower=spec["category"].lower(),
-        languages=spec["languages"],
-        detects_list=detects_list,
-        predicts_list=predicts_list,
-    )
-
-    with open(spec["filename"], "w") as f:
-        f.write(content)
-
-    print(f"✓ Generated {spec['filename']}")
-
-
-def main():
-    """Generate all 16 Coach wizards"""
-    print("Generating 16 Coach wizards...")
-    print()
-
-    for spec in WIZARD_SPECS:
-        generate_wizard(spec)
-
-    print()
-    print("✓ All 16 Coach wizards generated successfully!")
-    print()
-    print("Wizards created:")
-    for spec in WIZARD_SPECS:
-        print(f"  - {spec['name']}: {spec['description']}")
-
-
-if __name__ == "__main__":
-    main()

coach_wizards/localization_wizard.py

@@ -1,173 +0,0 @@
-"""LocalizationWizard - Internationalization and localization
-
-Level 4 Anticipatory Empathy for Localization 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 LocalizationWizard(BaseCoachWizard):
-    """Internationalization and localization
-
-    Detects:
-    - hardcoded strings
-    - missing translations
-    - locale issues
-    - RTL problems
-
-    Predicts (Level 4):
-    - i18n technical debt
-    - translation maintenance burden
-    - locale coverage gaps
-    """
-
-    def __init__(self):
-        super().__init__(
-            name="LocalizationWizard",
-            category="Localization",
-            languages=["python", "javascript", "typescript", "java", "go", "html", "jsx", "tsx"],
-        )
-
-    def analyze_code(self, code: str, file_path: str, language: str) -> list[WizardIssue]:
-        """Analyze code for localization 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: list[WizardIssue] = []
-
-        # Use generator-based iteration to avoid large list copies
-        # splitlines() is more memory-efficient than split("\n")
-        for line_num, line in enumerate(code.splitlines(), 1):
-            # Detect hardcoded strings (basic heuristic)
-            issue = self._check_hardcoded_string(line, line_num, file_path, language)
-            if issue:
-                issues.append(issue)
-
-        self.logger.info(f"{self.name} found {len(issues)} issues in {file_path}")
-        return issues
-
-    def _check_hardcoded_string(
-        self,
-        line: str,
-        line_num: int,
-        file_path: str,
-        language: str,
-    ) -> WizardIssue | None:
-        """Check a single line for hardcoded user-facing strings."""
-        # Skip comments and imports
-        stripped = line.strip()
-        if not stripped or stripped.startswith(("#", "//", "/*", "*", "import", "from")):
-            return None
-
-        # Basic detection patterns by language
-        # In production, use language-specific AST parsing
-        patterns = {
-            "python": self._check_python_hardcoded,
-            "javascript": self._check_js_hardcoded,
-            "typescript": self._check_js_hardcoded,
-            "jsx": self._check_js_hardcoded,
-            "tsx": self._check_js_hardcoded,
-        }
-
-        checker = patterns.get(language)
-        if checker:
-            return checker(line, line_num, file_path)
-        return None
-
-    def _check_python_hardcoded(
-        self,
-        line: str,
-        line_num: int,
-        file_path: str,
-    ) -> WizardIssue | None:
-        """Check Python code for hardcoded UI strings."""
-        # Look for print() or raise with string literals
-        # Skip logging, docstrings, and comments
-        if "print(" in line or "raise " in line:
-            # Check for quoted strings that look like UI text
-            if '"' in line or "'" in line:
-                # Basic heuristic: strings > 10 chars that aren't paths/URLs
-                import re
-
-                strings = re.findall(r'["\']([^"\']{10,})["\']', line)
-                for s in strings:
-                    if not s.startswith(("/", "http", "\\", ".")):
-                        return WizardIssue(
-                            category="hardcoded_string",
-                            severity="warning",
-                            message=f"Potential hardcoded UI string: '{s[:30]}...'",
-                            file_path=file_path,
-                            line_number=line_num,
-                            code_snippet=line.strip(),
-                            fix_suggestion="Consider using i18n translation function",
-                            confidence=0.7,
-                        )
-        return None
-
-    def _check_js_hardcoded(self, line: str, line_num: int, file_path: str) -> WizardIssue | None:
-        """Check JavaScript/TypeScript for hardcoded UI strings."""
-        # Look for JSX text content or string assignments
-        import re
-
-        # Check for text in JSX elements: <div>Hello World</div>
-        jsx_text = re.search(r">([A-Z][^<]{5,})<", line)
-        if jsx_text:
-            text = jsx_text.group(1).strip()
-            if text and not text.startswith("{"):
-                return WizardIssue(
-                    category="hardcoded_string",
-                    severity="warning",
-                    message=f"Hardcoded JSX text: '{text[:30]}...'",
-                    file_path=file_path,
-                    line_number=line_num,
-                    code_snippet=line.strip(),
-                    fix_suggestion="Use i18n: {t('key')} instead of hardcoded text",
-                    confidence=0.8,
-                )
-        return None
-
-    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 localization issues {timeline_days} days ahead
-
-        Uses:
-        - Historical patterns
-        - Code trajectory analysis
-        - Dependency evolution
-        - Team velocity
-        - Industry trends
-        """
-        predictions: list[WizardPrediction] = []
-
-        # 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 localization 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/migration_wizard.py

@@ -1,91 +0,0 @@
-"""MigrationWizard - Code migration and upgrade assistance
-
-Level 4 Anticipatory Empathy for Migration 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 MigrationWizard(BaseCoachWizard):
-    """Code migration and upgrade assistance
-
-    Detects:
-    - deprecated APIs
-    - breaking changes
-    - incompatibilities
-    - migration risks
-
-    Predicts (Level 4):
-    - upgrade complexity
-    - compatibility issues
-    - migration timeline
-    """
-
-    def __init__(self):
-        super().__init__(
-            name="MigrationWizard",
-            category="Migration",
-            languages=["python", "javascript", "typescript", "java", "go", "rust"],
-        )
-
-    def analyze_code(self, code: str, file_path: str, language: str) -> list[WizardIssue]:
-        """Analyze code for migration 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 migration
-            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 migration 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 migration issue
-
-        Returns:
-            Detailed fix suggestion with code examples
-
-        """
-        # Implementation depends on issue type
-        return f"Fix suggestion for {issue.category} issue: {issue.message}"