empathy-framework 5.3.0__py3-none-any.whl → 5.4.0__py3-none-any.whl

empathy_os/routing/smart_router.py

@@ -1,234 +0,0 @@
-"""Smart Router
-
-Intelligent dispatcher that analyzes developer input and routes
-to the appropriate workflow(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 .workflow_registry import WorkflowInfo, WorkflowRegistry
-
-
-@dataclass
-class RoutingDecision:
-    """Decision from the smart router."""
-
-    primary_workflow: str
-    secondary_workflows: 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 workflow(s).
-
-    Uses LLM classification (Haiku) to understand natural language
-    requests and route them to the best workflow(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_workflow}")
-        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 = WorkflowRegistry()
-        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 workflow(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 workflow recommendations
-
-        """
-        # Classify the request
-        classification = await self._classifier.classify(
-            request=request,
-            context=context,
-        )
-
-        # Build suggested chain based on workflow triggers
-        suggested_chain = self._build_chain(classification)
-
-        # Merge extracted context
-        merged_context = {**(context or {}), **classification.extracted_context}
-
-        return RoutingDecision(
-            primary_workflow=classification.primary_workflow,
-            secondary_workflows=classification.secondary_workflows,
-            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 workflow recommendations
-
-        """
-        classification = self._classifier.classify_sync(
-            request=request,
-            context=context,
-        )
-
-        suggested_chain = self._build_chain(classification)
-
-        return RoutingDecision(
-            primary_workflow=classification.primary_workflow,
-            secondary_workflows=classification.secondary_workflows,
-            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 workflow chain based on triggers."""
-        chain = [classification.primary_workflow]
-
-        # Add secondary workflows to chain
-        for secondary in classification.secondary_workflows:
-            if secondary not in chain:
-                chain.append(secondary)
-
-        # Check for auto-chain triggers from primary workflow
-        triggers = self._registry.get_chain_triggers(classification.primary_workflow)
-        for trigger in triggers:
-            next_workflow = trigger.get("next")
-            if next_workflow and next_workflow not in chain:
-                chain.append(next_workflow)
-
-        return chain
-
-    def get_workflow_info(self, name: str) -> WorkflowInfo | None:
-        """Get information about a specific workflow."""
-        return self._registry.get(name)
-
-    def list_workflows(self) -> list[WorkflowInfo]:
-        """List all available workflows."""
-        return self._registry.list_all()
-
-    def suggest_for_file(self, file_path: str) -> list[str]:
-        """Suggest workflows based on file type.
-
-        Args:
-            file_path: Path to the file
-
-        Returns:
-            List of suggested workflow names
-
-        """
-        suggestions = []
-
-        # Get file extension
-        ext = "." + file_path.rsplit(".", 1)[-1] if "." in file_path else ""
-        filename = file_path.rsplit("/", 1)[-1]
-
-        for workflow in self._registry.list_all():
-            if ext in workflow.handles_file_types or filename in workflow.handles_file_types:
-                suggestions.append(workflow.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 workflows based on error type.
-
-        Args:
-            error_type: Type of error (e.g., "TypeError", "SecurityError")
-
-        Returns:
-            List of suggested workflow names
-
-        """
-        error_lower = error_type.lower()
-
-        # Map error types to workflows
-        error_workflow_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, workflows in error_workflow_map.items():
-            if keyword in error_lower:
-                return workflows
-
-        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/workflow_registry.py

@@ -1,343 +0,0 @@
-"""Workflow Registry
-
-Central registry of available workflows 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 WorkflowInfo:
-    """Information about a registered workflow."""
-
-    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 workflow class or factory
-    workflow_class: type | None = None
-    factory: Callable[..., Any] | None = None
-
-
-# Default workflow registry
-WORKFLOW_REGISTRY: dict[str, WorkflowInfo] = {
-    # Workflows (cost-optimized pipelines)
-    "security-audit": WorkflowInfo(
-        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": WorkflowInfo(
-        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": WorkflowInfo(
-        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": WorkflowInfo(
-        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": WorkflowInfo(
-        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": WorkflowInfo(
-        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": WorkflowInfo(
-        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,
-    ),
-    "seo-optimization": WorkflowInfo(
-        name="seo-optimization",
-        description="Audit and optimize SEO for documentation sites (meta tags, content structure, technical SEO, links)",
-        keywords=[
-            "seo",
-            "search",
-            "optimization",
-            "meta",
-            "meta tag",
-            "meta description",
-            "title tag",
-            "opengraph",
-            "og:title",
-            "og:description",
-            "twitter card",
-            "sitemap",
-            "robots.txt",
-            "keywords",
-            "search engine",
-            "google",
-            "ranking",
-            "visibility",
-            "documentation seo",
-            "mkdocs seo",
-            "content optimization",
-            "headings",
-            "h1",
-            "canonical",
-            "broken links",
-            "internal links",
-            "schema markup",
-        ],
-        primary_domain="documentation",
-        handles_file_types=[".md", ".html"],
-        auto_chain=False,  # SEO fixes require approval
-    ),
-    "dependency-check": WorkflowInfo(
-        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": WorkflowInfo(
-        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": WorkflowInfo(
-        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 WorkflowRegistry:
-    """Registry for managing available workflows.
-
-    Usage:
-        registry = WorkflowRegistry()
-        info = registry.get("security-audit")
-        all_workflows = registry.list_all()
-    """
-
-    def __init__(self):
-        """Initialize with default workflows."""
-        self._workflows: dict[str, WorkflowInfo] = dict(WORKFLOW_REGISTRY)
-
-    def register(self, info: WorkflowInfo) -> None:
-        """Register a new workflow."""
-        self._workflows[info.name] = info
-
-    def get(self, name: str) -> WorkflowInfo | None:
-        """Get workflow info by name."""
-        return self._workflows.get(name)
-
-    def list_all(self) -> list[WorkflowInfo]:
-        """List all registered workflows."""
-        return list(self._workflows.values())
-
-    def find_by_domain(self, domain: str) -> list[WorkflowInfo]:
-        """Find workflows by primary domain."""
-        return [w for w in self._workflows.values() if w.primary_domain == domain]
-
-    def find_by_keyword(self, keyword: str) -> list[WorkflowInfo]:
-        """Find workflows that handle a keyword."""
-        keyword = keyword.lower()
-        return [
-            w for w in self._workflows.values() if any(keyword in kw.lower() for kw in w.keywords)
-        ]
-
-    def get_descriptions_for_classification(self) -> dict[str, str]:
-        """Get workflow name to description mapping for LLM classification."""
-        return {
-            name: f"{info.description} (domain: {info.primary_domain})"
-            for name, info in self._workflows.items()
-        }
-
-    def get_chain_triggers(self, workflow_name: str) -> list[dict[str, Any]]:
-        """Get auto-chain triggers for a workflow."""
-        info = self._workflows.get(workflow_name)
-        if info and info.auto_chain:
-            return info.chain_triggers
-        return []
-
-    def unregister(self, name: str) -> bool:
-        """Remove a workflow from the registry."""
-        if name in self._workflows:
-            del self._workflows[name]
-            return True
-        return False