attune-ai 2.0.0__py3-none-any.whl

attune/routing/smart_router.py

@@ -0,0 +1,234 @@
+"""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)

attune/routing/workflow_registry.py

@@ -0,0 +1,343 @@
+"""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