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

empathy_os/routing/smart_router.py

@@ -0,0 +1,234 @@
+"""Smart Router
+
+Intelligent dispatcher that analyzes developer input and routes
+to the appropriate wizard(s) using LLM classification.
+
+Copyright 2025 Smart AI Memory, LLC
+Licensed under Fair Source 0.9
+"""
+
+from dataclasses import dataclass, field
+from typing import Any
+
+from .classifier import ClassificationResult, HaikuClassifier
+from .wizard_registry import WizardInfo, WizardRegistry
+
+
+@dataclass
+class RoutingDecision:
+    """Decision from the smart router."""
+
+    primary_wizard: str
+    secondary_wizards: list[str] = field(default_factory=list)
+    confidence: float = 0.0
+    reasoning: str = ""
+    suggested_chain: list[str] = field(default_factory=list)
+    context: dict[str, Any] = field(default_factory=dict)
+
+    # Metadata
+    classification_method: str = "llm"  # llm, keyword, manual
+    request_summary: str = ""
+
+
+class SmartRouter:
+    """Routes developer requests to appropriate wizard(s).
+
+    Uses LLM classification (Haiku) to understand natural language
+    requests and route them to the best wizard(s).
+
+    Usage:
+        router = SmartRouter()
+
+        # Async routing (preferred - uses LLM)
+        decision = await router.route("Fix the security issue in auth.py")
+        print(f"Primary: {decision.primary_wizard}")
+        print(f"Confidence: {decision.confidence}")
+
+        # Sync routing (keyword fallback)
+        decision = router.route_sync("Optimize database queries")
+    """
+
+    def __init__(self, api_key: str | None = None):
+        """Initialize the smart router.
+
+        Args:
+            api_key: Optional Anthropic API key for LLM classification
+
+        """
+        self._registry = WizardRegistry()
+        self._classifier = HaikuClassifier(api_key=api_key)
+
+    async def route(
+        self,
+        request: str,
+        context: dict[str, Any] | None = None,
+    ) -> RoutingDecision:
+        """Route a request to the appropriate wizard(s).
+
+        Uses LLM classification for accurate natural language understanding.
+
+        Args:
+            request: Developer's natural language request
+            context: Optional context (current file, project info, etc.)
+
+        Returns:
+            RoutingDecision with wizard recommendations
+
+        """
+        # Classify the request
+        classification = await self._classifier.classify(
+            request=request,
+            context=context,
+        )
+
+        # Build suggested chain based on wizard triggers
+        suggested_chain = self._build_chain(classification)
+
+        # Merge extracted context
+        merged_context = {**(context or {}), **classification.extracted_context}
+
+        return RoutingDecision(
+            primary_wizard=classification.primary_wizard,
+            secondary_wizards=classification.secondary_wizards,
+            confidence=classification.confidence,
+            reasoning=classification.reasoning,
+            suggested_chain=suggested_chain,
+            context=merged_context,
+            classification_method="llm",
+            request_summary=request[:100],
+        )
+
+    def route_sync(
+        self,
+        request: str,
+        context: dict[str, Any] | None = None,
+    ) -> RoutingDecision:
+        """Synchronous routing using keyword matching.
+
+        Faster but less accurate than LLM classification.
+
+        Args:
+            request: Developer's request
+            context: Optional context
+
+        Returns:
+            RoutingDecision with wizard recommendations
+
+        """
+        classification = self._classifier.classify_sync(
+            request=request,
+            context=context,
+        )
+
+        suggested_chain = self._build_chain(classification)
+
+        return RoutingDecision(
+            primary_wizard=classification.primary_wizard,
+            secondary_wizards=classification.secondary_wizards,
+            confidence=classification.confidence,
+            reasoning=classification.reasoning,
+            suggested_chain=suggested_chain,
+            context=context or {},
+            classification_method="keyword",
+            request_summary=request[:100],
+        )
+
+    def _build_chain(self, classification: ClassificationResult) -> list[str]:
+        """Build suggested wizard chain based on triggers."""
+        chain = [classification.primary_wizard]
+
+        # Add secondary wizards to chain
+        for secondary in classification.secondary_wizards:
+            if secondary not in chain:
+                chain.append(secondary)
+
+        # Check for auto-chain triggers from primary wizard
+        triggers = self._registry.get_chain_triggers(classification.primary_wizard)
+        for trigger in triggers:
+            next_wizard = trigger.get("next")
+            if next_wizard and next_wizard not in chain:
+                chain.append(next_wizard)
+
+        return chain
+
+    def get_wizard_info(self, name: str) -> WizardInfo | None:
+        """Get information about a specific wizard."""
+        return self._registry.get(name)
+
+    def list_wizards(self) -> list[WizardInfo]:
+        """List all available wizards."""
+        return self._registry.list_all()
+
+    def suggest_for_file(self, file_path: str) -> list[str]:
+        """Suggest wizards based on file type.
+
+        Args:
+            file_path: Path to the file
+
+        Returns:
+            List of suggested wizard names
+
+        """
+        suggestions = []
+
+        # Get file extension
+        ext = "." + file_path.rsplit(".", 1)[-1] if "." in file_path else ""
+        filename = file_path.rsplit("/", 1)[-1]
+
+        for wizard in self._registry.list_all():
+            if ext in wizard.handles_file_types or filename in wizard.handles_file_types:
+                suggestions.append(wizard.name)
+
+        # Default suggestions if no matches
+        if not suggestions:
+            suggestions = ["code-review", "security-audit"]
+
+        return suggestions
+
+    def suggest_for_error(self, error_type: str) -> list[str]:
+        """Suggest wizards based on error type.
+
+        Args:
+            error_type: Type of error (e.g., "TypeError", "SecurityError")
+
+        Returns:
+            List of suggested wizard names
+
+        """
+        error_lower = error_type.lower()
+
+        # Map error types to wizards
+        error_wizard_map = {
+            "security": ["security-audit", "code-review"],
+            "type": ["code-review", "bug-predict"],
+            "null": ["bug-predict", "test-gen"],
+            "undefined": ["bug-predict", "test-gen"],
+            "timeout": ["perf-audit", "bug-predict"],
+            "memory": ["perf-audit", "code-review"],
+            "import": ["dependency-check", "code-review"],
+            "permission": ["security-audit", "code-review"],
+            "syntax": ["code-review"],
+            "test": ["test-gen", "bug-predict"],
+        }
+
+        for keyword, wizards in error_wizard_map.items():
+            if keyword in error_lower:
+                return wizards
+
+        return ["bug-predict", "code-review"]
+
+
+# Convenience function for quick routing
+async def quick_route(request: str, context: dict | None = None) -> RoutingDecision:
+    """Quick routing helper.
+
+    Args:
+        request: Developer request
+        context: Optional context
+
+    Returns:
+        RoutingDecision
+
+    """
+    router = SmartRouter()
+    return await router.route(request, context)

empathy_os/routing/wizard_registry.py

@@ -0,0 +1,307 @@
+"""Wizard Registry
+
+Central registry of available wizards with their descriptions,
+capabilities, and auto-chain rules.
+
+Copyright 2025 Smart AI Memory, LLC
+Licensed under Fair Source 0.9
+"""
+
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from typing import Any
+
+
+@dataclass
+class WizardInfo:
+    """Information about a registered wizard."""
+
+    name: str
+    description: str
+    keywords: list[str]  # Keywords for classification
+
+    # Classification hints
+    primary_domain: str = ""  # security, performance, testing, etc.
+    handles_file_types: list[str] = field(default_factory=list)
+    complexity: str = "medium"  # low, medium, high
+
+    # Chaining configuration
+    auto_chain: bool = False
+    chain_triggers: list[dict[str, Any]] = field(default_factory=list)
+
+    # Optional wizard class or factory
+    wizard_class: type | None = None
+    factory: Callable[..., Any] | None = None
+
+
+# Default wizard registry
+WIZARD_REGISTRY: dict[str, WizardInfo] = {
+    # Workflows (cost-optimized pipelines)
+    "security-audit": WizardInfo(
+        name="security-audit",
+        description="Analyze code for security vulnerabilities, injection risks, compliance",
+        keywords=[
+            "security",
+            "vulnerability",
+            "injection",
+            "xss",
+            "sql",
+            "auth",
+            "authentication",
+            "authorization",
+            "sensitive",
+            "credential",
+            "password",
+            "secret",
+            "owasp",
+            "cve",
+            "exploit",
+        ],
+        primary_domain="security",
+        handles_file_types=[".py", ".js", ".ts", ".java", ".go", ".rb"],
+        auto_chain=True,
+        chain_triggers=[
+            {"condition": "high_severity_count > 0", "next": "dependency-check"},
+            {"condition": "vulnerability_type == 'injection'", "next": "code-review"},
+        ],
+    ),
+    "code-review": WizardInfo(
+        name="code-review",
+        description="Review code for quality, best practices, maintainability, and bugs",
+        keywords=[
+            "review",
+            "code",
+            "quality",
+            "lint",
+            "style",
+            "convention",
+            "best practice",
+            "maintainability",
+            "readable",
+            "clean",
+            "refactor",
+            "smell",
+        ],
+        primary_domain="quality",
+        handles_file_types=[".py", ".js", ".ts", ".java", ".go", ".rb", ".cpp", ".c"],
+        auto_chain=True,
+        chain_triggers=[
+            {"condition": "has_complexity_issues", "next": "refactor-plan"},
+        ],
+    ),
+    "bug-predict": WizardInfo(
+        name="bug-predict",
+        description="Predict potential bugs based on code patterns and historical data",
+        keywords=[
+            "bug",
+            "error",
+            "crash",
+            "exception",
+            "fail",
+            "broken",
+            "fix",
+            "issue",
+            "problem",
+            "defect",
+            "null",
+            "undefined",
+        ],
+        primary_domain="debugging",
+        auto_chain=True,
+        chain_triggers=[
+            {"condition": "risk_score > 0.7", "next": "test-gen"},
+        ],
+    ),
+    "perf-audit": WizardInfo(
+        name="perf-audit",
+        description="Analyze code for performance issues, bottlenecks, optimizations",
+        keywords=[
+            "performance",
+            "perf",
+            "slow",
+            "fast",
+            "speed",
+            "optimize",
+            "bottleneck",
+            "memory",
+            "cpu",
+            "latency",
+            "throughput",
+            "cache",
+            "profile",
+        ],
+        primary_domain="performance",
+        auto_chain=True,
+        chain_triggers=[
+            {"condition": "hotspot_count > 5", "next": "refactor-plan"},
+        ],
+    ),
+    "refactor-plan": WizardInfo(
+        name="refactor-plan",
+        description="Plan code refactoring to improve structure, reduce complexity",
+        keywords=[
+            "refactor",
+            "restructure",
+            "reorganize",
+            "simplify",
+            "complexity",
+            "architecture",
+            "design",
+            "pattern",
+            "clean",
+        ],
+        primary_domain="architecture",
+        auto_chain=False,  # Require approval for refactoring
+    ),
+    "test-gen": WizardInfo(
+        name="test-gen",
+        description="Generate test cases and improve test coverage",
+        keywords=[
+            "test",
+            "testing",
+            "unit",
+            "integration",
+            "coverage",
+            "pytest",
+            "jest",
+            "mock",
+            "assert",
+            "spec",
+        ],
+        primary_domain="testing",
+        handles_file_types=[".py", ".js", ".ts", ".java"],
+        auto_chain=True,
+        chain_triggers=[
+            {"condition": "coverage_low", "next": "bug-predict"},
+        ],
+    ),
+    "doc-gen": WizardInfo(
+        name="doc-gen",
+        description="Generate documentation from code including API docs, READMEs, and guides",
+        keywords=[
+            "document",
+            "doc",
+            "readme",
+            "api",
+            "explain",
+            "describe",
+            "comment",
+            "docstring",
+            "jsdoc",
+        ],
+        primary_domain="documentation",
+        auto_chain=False,
+    ),
+    "dependency-check": WizardInfo(
+        name="dependency-check",
+        description="Audit dependencies for vulnerabilities, updates, and license issues",
+        keywords=[
+            "dependency",
+            "package",
+            "npm",
+            "pip",
+            "library",
+            "version",
+            "update",
+            "outdated",
+            "license",
+            "vulnerability",
+        ],
+        primary_domain="dependencies",
+        handles_file_types=["requirements.txt", "package.json", "pyproject.toml", "Cargo.toml"],
+        auto_chain=True,
+        chain_triggers=[
+            {"condition": "critical_vuln_count > 0", "next": "security-audit"},
+        ],
+    ),
+    "release-prep": WizardInfo(
+        name="release-prep",
+        description="Pre-release quality gate with health checks, security scan, and changelog",
+        keywords=[
+            "release",
+            "deploy",
+            "publish",
+            "ship",
+            "version",
+            "changelog",
+            "ready",
+            "production",
+        ],
+        primary_domain="release",
+        auto_chain=False,  # Always require approval
+    ),
+    "research": WizardInfo(
+        name="research",
+        description="Research and synthesize information from multiple sources",
+        keywords=[
+            "research",
+            "investigate",
+            "explore",
+            "analyze",
+            "study",
+            "understand",
+            "learn",
+            "compare",
+        ],
+        primary_domain="research",
+        auto_chain=False,
+    ),
+}
+
+
+class WizardRegistry:
+    """Registry for managing available wizards.
+
+    Usage:
+        registry = WizardRegistry()
+        info = registry.get("security-audit")
+        all_wizards = registry.list_all()
+    """
+
+    def __init__(self):
+        """Initialize with default wizards."""
+        self._wizards: dict[str, WizardInfo] = dict(WIZARD_REGISTRY)
+
+    def register(self, info: WizardInfo) -> None:
+        """Register a new wizard."""
+        self._wizards[info.name] = info
+
+    def get(self, name: str) -> WizardInfo | None:
+        """Get wizard info by name."""
+        return self._wizards.get(name)
+
+    def list_all(self) -> list[WizardInfo]:
+        """List all registered wizards."""
+        return list(self._wizards.values())
+
+    def find_by_domain(self, domain: str) -> list[WizardInfo]:
+        """Find wizards by primary domain."""
+        return [w for w in self._wizards.values() if w.primary_domain == domain]
+
+    def find_by_keyword(self, keyword: str) -> list[WizardInfo]:
+        """Find wizards that handle a keyword."""
+        keyword = keyword.lower()
+        return [
+            w for w in self._wizards.values() if any(keyword in kw.lower() for kw in w.keywords)
+        ]
+
+    def get_descriptions_for_classification(self) -> dict[str, str]:
+        """Get wizard name to description mapping for LLM classification."""
+        return {
+            name: f"{info.description} (domain: {info.primary_domain})"
+            for name, info in self._wizards.items()
+        }
+
+    def get_chain_triggers(self, wizard_name: str) -> list[dict[str, Any]]:
+        """Get auto-chain triggers for a wizard."""
+        info = self._wizards.get(wizard_name)
+        if info and info.auto_chain:
+            return info.chain_triggers
+        return []
+
+    def unregister(self, name: str) -> bool:
+        """Remove a wizard from the registry."""
+        if name in self._wizards:
+            del self._wizards[name]
+            return True
+        return False

empathy_os/templates.py

@@ -1,5 +1,4 @@
-"""
-Template Starters for Empathy Framework
+"""Template Starters for Empathy Framework
 
 Scaffold new projects with Empathy pre-configured for different use cases.
 
@@ -14,9 +13,10 @@ Licensed under Fair Source License 0.9
 """
 
 from pathlib import Path
+from typing import Any
 
 # Template definitions
-TEMPLATES = {
+TEMPLATES: dict[str, dict[str, Any]] = {
     "minimal": {
         "name": "Minimal",
         "description": "Just the Empathy config files - add to existing project",
@@ -618,10 +618,12 @@ def list_templates() -> list:
 
 
 def scaffold_project(
-    template_name: str, project_name: str, target_dir: str | None = None, force: bool = False
+    template_name: str,
+    project_name: str,
+    target_dir: str | None = None,
+    force: bool = False,
 ) -> dict:
-    """
-    Create a new project from a template.
+    """Create a new project from a template.
 
     Args:
         template_name: Template ID (minimal, python-cli, python-fastapi, python-agent)
@@ -631,6 +633,7 @@ def scaffold_project(
 
     Returns:
         Dict with created files and status
+
     """
     if template_name not in TEMPLATES:
         return {
@@ -647,7 +650,7 @@ def scaffold_project(
         if any(target.iterdir()):
             return {
                 "success": False,
-                "error": f"Directory '{target}' already exists and is not empty. Use --force to overwrite.",
+                "error": f"Directory '{target}' exists and is not empty. Use --force to overwrite.",
             }
 
     # Create directory
@@ -660,7 +663,10 @@ def scaffold_project(
 
     # Create files
     created_files = []
-    for file_path, content in template["files"].items():
+    files = template["files"]
+    if not isinstance(files, dict):
+        return {"success": False, "error": "Invalid template structure"}
+    for file_path, content in files.items():
         # Replace placeholders in path
         actual_path = file_path.replace("{{project_name}}", project_name)
 
@@ -738,9 +744,8 @@ def cmd_new(args):
             print(f"    $ {step}")
         print()
         return 0
-    else:
-        print(f"\n  Error: {result['error']}")
-        if "available" in result:
-            print(f"  Available templates: {', '.join(result['available'])}")
-        print()
-        return 1
+    print(f"\n  Error: {result['error']}")
+    if "available" in result:
+        print(f"  Available templates: {', '.join(result['available'])}")
+    print()
+    return 1

empathy_os/trust/__init__.py

@@ -0,0 +1,28 @@
+"""Trust Management Module
+
+Cross-domain transfer of reliability patterns to human-AI trust management.
+Implements Level 5 (Systems Thinking) capability.
+
+Pattern Source: Circuit Breaker (reliability/circuit_breaker.py)
+Transfer: Protect user trust like protecting system stability
+"""
+
+from .circuit_breaker import (
+                              TrustCircuitBreaker,
+                              TrustConfig,
+                              TrustDamageEvent,
+                              TrustDamageType,
+                              TrustRecoveryEvent,
+                              TrustState,
+                              create_trust_breaker,
+)
+
+__all__ = [
+    "TrustCircuitBreaker",
+    "TrustConfig",
+    "TrustDamageEvent",
+    "TrustDamageType",
+    "TrustRecoveryEvent",
+    "TrustState",
+    "create_trust_breaker",
+]