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

empathy_os/routing/chain_executor.py

@@ -1,433 +0,0 @@
-"""Chain Executor
-
-Executes workflow chains based on triggers and conditions.
-Handles auto-chaining, approval workflows, and chain tracking.
-
-Copyright 2025 Smart AI Memory, LLC
-Licensed under Fair Source 0.9
-"""
-
-from dataclasses import dataclass, field
-from datetime import datetime
-from pathlib import Path
-from typing import Any
-
-import yaml
-
-from .workflow_registry import WorkflowRegistry
-
-
-@dataclass
-class ChainTrigger:
-    """A trigger condition for auto-chaining."""
-
-    condition: str
-    next_workflow: str
-    approval_required: bool = False
-    reason: str = ""
-
-
-@dataclass
-class ChainConfig:
-    """Configuration for a workflow's chaining behavior."""
-
-    workflow_name: str
-    auto_chain: bool = True
-    description: str = ""
-    triggers: list[ChainTrigger] = field(default_factory=list)
-
-
-@dataclass
-class ChainStep:
-    """A step in an executed chain."""
-
-    workflow_name: str
-    triggered_by: str  # condition or manual
-    approval_required: bool
-    approved: bool | None = None  # None = pending
-    result: dict[str, Any] = field(default_factory=dict)
-    started_at: datetime | None = None
-    completed_at: datetime | None = None
-
-
-@dataclass
-class ChainExecution:
-    """Record of a chain execution."""
-
-    chain_id: str
-    initial_workflow: str
-    steps: list[ChainStep] = field(default_factory=list)
-    started_at: datetime = field(default_factory=datetime.now)
-    completed_at: datetime | None = None
-    status: str = "running"  # running, completed, waiting_approval, failed
-    current_step: int = 0
-
-
-class ChainExecutor:
-    """Executes workflow chains based on configuration and results.
-
-    Usage:
-        executor = ChainExecutor()
-
-        # Check for triggered chains after a workflow run
-        result = {"high_severity_count": 5, "vulnerability_type": "injection"}
-        next_steps = executor.get_triggered_chains("security-audit", result)
-
-        # Execute a chain template
-        execution = await executor.execute_template("full-security-review", input_data)
-    """
-
-    def __init__(
-        self,
-        config_path: str | Path = ".empathy/workflow_chains.yaml",
-    ):
-        """Initialize the chain executor.
-
-        Args:
-            config_path: Path to workflow_chains.yaml
-
-        """
-        self.config_path = Path(config_path)
-        self._configs: dict[str, ChainConfig] = {}
-        self._templates: dict[str, list[str]] = {}
-        self._global_settings: dict[str, Any] = {}
-        self._registry = WorkflowRegistry()
-        self._executions: list[ChainExecution] = []
-
-        self._load_config()
-
-    def _load_config(self) -> None:
-        """Load chain configuration from YAML file."""
-        if not self.config_path.exists():
-            return
-
-        try:
-            with open(self.config_path) as f:
-                data = yaml.safe_load(f) or {}
-
-            # Load global settings
-            self._global_settings = data.get("global", {})
-
-            # Load chain configs
-            chains = data.get("chains", {})
-            for workflow_name, config in chains.items():
-                triggers = []
-                for t in config.get("triggers", []):
-                    triggers.append(
-                        ChainTrigger(
-                            condition=t.get("condition", ""),
-                            next_workflow=t.get("next", ""),
-                            approval_required=t.get("approval_required", False),
-                            reason=t.get("reason", ""),
-                        ),
-                    )
-
-                self._configs[workflow_name] = ChainConfig(
-                    workflow_name=workflow_name,
-                    auto_chain=config.get("auto_chain", True),
-                    description=config.get("description", ""),
-                    triggers=triggers,
-                )
-
-            # Load templates
-            templates = data.get("templates", {})
-            for name, template in templates.items():
-                self._templates[name] = template.get("steps", [])
-
-        except (yaml.YAMLError, OSError) as e:
-            print(f"Warning: Could not load chain config: {e}")
-
-    def get_triggered_chains(
-        self,
-        workflow_name: str,
-        result: dict[str, Any],
-    ) -> list[ChainTrigger]:
-        """Get triggered chain steps based on workflow result.
-
-        Args:
-            workflow_name: The workflow that just completed
-            result: The workflow's result dictionary
-
-        Returns:
-            List of triggered ChainTriggers
-
-        """
-        if not self._global_settings.get("auto_chain_enabled", True):
-            return []
-
-        config = self._configs.get(workflow_name)
-        if not config or not config.auto_chain:
-            return []
-
-        triggered = []
-        for trigger in config.triggers:
-            if self._evaluate_condition(trigger.condition, result):
-                triggered.append(trigger)
-
-        return triggered
-
-    def _evaluate_condition(
-        self,
-        condition: str,
-        context: dict[str, Any],
-    ) -> bool:
-        """Evaluate a trigger condition against a result context.
-
-        Supports:
-        - Comparisons: var > 0, var == 'value', var < 10
-        - Boolean: var == true, var == false
-        - Existence: var != null
-
-        Args:
-            condition: The condition string
-            context: The result dictionary to evaluate against
-
-        Returns:
-            True if condition is met
-
-        """
-        if not condition:
-            return False
-
-        # Parse comparison operators
-        operators = {
-            "==": lambda a, b: a == b,
-            "!=": lambda a, b: a != b,
-            ">": lambda a, b: float(a) > float(b) if _is_numeric(a) and _is_numeric(b) else False,
-            "<": lambda a, b: float(a) < float(b) if _is_numeric(a) and _is_numeric(b) else False,
-            ">=": lambda a, b: float(a) >= float(b) if _is_numeric(a) and _is_numeric(b) else False,
-            "<=": lambda a, b: float(a) <= float(b) if _is_numeric(a) and _is_numeric(b) else False,
-        }
-
-        for op_str, op_func in operators.items():
-            if op_str in condition:
-                parts = condition.split(op_str)
-                if len(parts) == 2:
-                    var_name = parts[0].strip()
-                    value_str = parts[1].strip()
-
-                    # Get actual value from context
-                    actual = context.get(var_name)
-                    if actual is None:
-                        # Try nested access
-                        actual = _get_nested(context, var_name)
-
-                    if actual is None:
-                        return False
-
-                    # Parse expected value
-                    expected = _parse_value(value_str)
-
-                    try:
-                        return bool(op_func(actual, expected))
-                    except (ValueError, TypeError):
-                        return False
-
-        return False
-
-    def should_trigger_chain(
-        self,
-        workflow_name: str,
-        result: dict[str, Any],
-    ) -> tuple[bool, list[ChainTrigger]]:
-        """Check if a chain should be triggered and return triggers.
-
-        Args:
-            workflow_name: The workflow that completed
-            result: The workflow's result
-
-        Returns:
-            Tuple of (should_trigger, list_of_triggers)
-
-        """
-        triggers = self.get_triggered_chains(workflow_name, result)
-        return len(triggers) > 0, triggers
-
-    def get_chain_config(self, workflow_name: str) -> ChainConfig | None:
-        """Get chain configuration for a workflow."""
-        return self._configs.get(workflow_name)
-
-    def get_template(self, template_name: str) -> list[str] | None:
-        """Get a chain template by name."""
-        return self._templates.get(template_name)
-
-    def list_templates(self) -> dict[str, list[str]]:
-        """List all available chain templates."""
-        return dict(self._templates)
-
-    def create_execution(
-        self,
-        initial_workflow: str,
-        triggered_steps: list[ChainTrigger] | None = None,
-    ) -> ChainExecution:
-        """Create a new chain execution record.
-
-        Args:
-            initial_workflow: The starting workflow
-            triggered_steps: Optional list of triggered next steps
-
-        Returns:
-            ChainExecution object
-
-        """
-        execution = ChainExecution(
-            chain_id=f"chain_{datetime.now().strftime('%Y%m%d%H%M%S')}",
-            initial_workflow=initial_workflow,
-        )
-
-        # Add initial step
-        execution.steps.append(
-            ChainStep(
-                workflow_name=initial_workflow,
-                triggered_by="manual",
-                approval_required=False,
-                approved=True,
-            ),
-        )
-
-        # Add triggered steps
-        if triggered_steps:
-            for trigger in triggered_steps:
-                execution.steps.append(
-                    ChainStep(
-                        workflow_name=trigger.next_workflow,
-                        triggered_by=trigger.condition,
-                        approval_required=trigger.approval_required,
-                    ),
-                )
-
-        self._executions.append(execution)
-        return execution
-
-    def approve_step(self, execution: ChainExecution, step_index: int) -> bool:
-        """Approve a pending step in a chain execution."""
-        if step_index < len(execution.steps):
-            execution.steps[step_index].approved = True
-            return True
-        return False
-
-    def reject_step(self, execution: ChainExecution, step_index: int) -> bool:
-        """Reject a pending step in a chain execution."""
-        if step_index < len(execution.steps):
-            execution.steps[step_index].approved = False
-            return True
-        return False
-
-    def get_next_step(self, execution: ChainExecution) -> ChainStep | None:
-        """Get the next step to execute in a chain."""
-        max_depth = self._global_settings.get("max_chain_depth", 3)
-
-        for i, step in enumerate(execution.steps):
-            if i >= max_depth:
-                break
-
-            # Skip completed steps
-            if step.completed_at is not None:
-                continue
-
-            # Check approval
-            if step.approval_required and step.approved is None:
-                execution.status = "waiting_approval"
-                return None
-
-            if step.approval_required and step.approved is False:
-                continue  # Skip rejected steps
-
-            return step
-
-        return None
-
-    def complete_step(
-        self,
-        execution: ChainExecution,
-        step: ChainStep,
-        result: dict[str, Any],
-    ) -> list[ChainTrigger]:
-        """Mark a step as complete and check for new triggers.
-
-        Args:
-            execution: The chain execution
-            step: The step that completed
-            result: The step's result
-
-        Returns:
-            List of newly triggered steps
-
-        """
-        step.completed_at = datetime.now()
-        step.result = result
-
-        # Check for new triggers
-        new_triggers = self.get_triggered_chains(step.workflow_name, result)
-
-        # Add new steps (if not already in chain)
-        existing_workflows = {s.workflow_name for s in execution.steps}
-        for trigger in new_triggers:
-            if trigger.next_workflow not in existing_workflows:
-                execution.steps.append(
-                    ChainStep(
-                        workflow_name=trigger.next_workflow,
-                        triggered_by=trigger.condition,
-                        approval_required=trigger.approval_required,
-                    ),
-                )
-
-        # Check if chain is complete
-        all_done = all(
-            s.completed_at is not None or (s.approval_required and s.approved is False)
-            for s in execution.steps
-        )
-        if all_done:
-            execution.status = "completed"
-            execution.completed_at = datetime.now()
-
-        return new_triggers
-
-
-def _is_numeric(value: Any) -> bool:
-    """Check if a value is numeric."""
-    if isinstance(value, int | float):
-        return True
-    if isinstance(value, str):
-        try:
-            float(value)
-            return True
-        except ValueError:
-            return False
-    return False
-
-
-def _parse_value(value_str: str) -> Any:
-    """Parse a value string to appropriate type."""
-    value_str = value_str.strip().strip("'\"")
-
-    # Boolean
-    if value_str.lower() == "true":
-        return True
-    if value_str.lower() == "false":
-        return False
-    if value_str.lower() == "null":
-        return None
-
-    # Number
-    try:
-        if "." in value_str:
-            return float(value_str)
-        return int(value_str)
-    except ValueError:
-        pass
-
-    # String
-    return value_str
-
-
-def _get_nested(obj: dict[str, Any], path: str) -> Any:
-    """Get a nested value from a dictionary using dot notation."""
-    parts = path.split(".")
-    current: Any = obj
-    for part in parts:
-        if isinstance(current, dict):
-            current = current.get(part)
-        else:
-            return None
-    return current

empathy_os/routing/classifier.py

@@ -1,217 +0,0 @@
-"""LLM-based Request Classifier
-
-Uses a cheap model (Haiku) to classify developer requests
-and route them to appropriate workflow(s).
-
-Copyright 2025 Smart AI Memory, LLC
-Licensed under Fair Source 0.9
-"""
-
-import json
-import os
-from dataclasses import dataclass, field
-from typing import Any
-
-from .workflow_registry import WorkflowRegistry
-
-
-@dataclass
-class ClassificationResult:
-    """Result of classifying a developer request."""
-
-    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)
-    extracted_context: dict[str, Any] = field(default_factory=dict)
-
-
-class HaikuClassifier:
-    """Uses Claude Haiku to classify requests to workflows.
-
-    Why Haiku:
-    - Cheapest tier model
-    - Fast response times
-    - Sufficient for classification tasks
-    - Cost-effective for high-volume routing
-    """
-
-    def __init__(self, api_key: str | None = None):
-        """Initialize the classifier.
-
-        Args:
-            api_key: Anthropic API key (defaults to ANTHROPIC_API_KEY env var)
-
-        """
-        self._api_key = api_key or os.getenv("ANTHROPIC_API_KEY")
-        self._client = None
-        self._registry = WorkflowRegistry()
-
-    def _get_client(self):
-        """Lazy-load the Anthropic client."""
-        if self._client is None and self._api_key:
-            try:
-                import anthropic
-
-                self._client = anthropic.Anthropic(api_key=self._api_key)
-            except ImportError:
-                pass
-        return self._client
-
-    async def classify(
-        self,
-        request: str,
-        context: dict[str, Any] | None = None,
-        available_workflows: dict[str, str] | None = None,
-    ) -> ClassificationResult:
-        """Classify a developer request and determine which workflow(s) to invoke.
-
-        Args:
-            request: The developer's natural language request
-            context: Optional context (current file, project type, etc.)
-            available_workflows: Override for available workflow descriptions
-
-        Returns:
-            ClassificationResult with primary and secondary workflow recommendations
-
-        """
-        if available_workflows is None:
-            available_workflows = self._registry.get_descriptions_for_classification()
-
-        # Build classification prompt
-        workflow_list = "\n".join(f"- {name}: {desc}" for name, desc in available_workflows.items())
-
-        context_str = ""
-        if context:
-            context_str = f"\n\nContext:\n{json.dumps(context, indent=2)}"
-
-        system_prompt = """You are a request router that classifies requests to the appropriate workflow.
-
-Analyze the request and determine:
-1. The PRIMARY workflow that best handles this request
-2. Any SECONDARY workflows that could provide additional value
-3. Your confidence level (0.0 - 1.0)
-4. Brief reasoning for your choice
-
-Respond in JSON format:
-{
-    "primary_workflow": "workflow-name",
-    "secondary_workflows": ["workflow-name-2"],
-    "confidence": 0.85,
-    "reasoning": "Brief explanation",
-    "extracted_context": {
-        "file_mentioned": "auth.py",
-        "issue_type": "performance"
-    }
-}"""
-
-        user_prompt = f"""Available workflows:
-{workflow_list}
-
-Developer request: "{request}"{context_str}
-
-Classify this request."""
-
-        # Try LLM classification
-        client = self._get_client()
-        if client:
-            try:
-                response = client.messages.create(
-                    model="claude-3-5-haiku-20241022",
-                    max_tokens=500,
-                    system=system_prompt,
-                    messages=[{"role": "user", "content": user_prompt}],
-                )
-
-                content = response.content[0].text if response.content else "{}"
-
-                # Parse JSON response
-                try:
-                    # Extract JSON from response (handle markdown code blocks)
-                    if "```json" in content:
-                        content = content.split("```json")[1].split("```")[0]
-                    elif "```" in content:
-                        content = content.split("```")[1].split("```")[0]
-
-                    data = json.loads(content.strip())
-                    return ClassificationResult(
-                        primary_workflow=data.get("primary_workflow", "code-review"),
-                        secondary_workflows=data.get("secondary_workflows", []),
-                        confidence=data.get("confidence", 0.5),
-                        reasoning=data.get("reasoning", ""),
-                        extracted_context=data.get("extracted_context", {}),
-                    )
-                except json.JSONDecodeError:
-                    pass
-
-            except Exception as e:
-                print(f"LLM classification error: {e}")
-
-        # Fallback to keyword-based classification
-        return self._keyword_classify(request, available_workflows)
-
-    def _keyword_classify(
-        self,
-        request: str,
-        available_workflows: dict[str, str],
-    ) -> ClassificationResult:
-        """Fallback keyword-based classification."""
-        request_lower = request.lower()
-
-        # Score each workflow based on keyword matches
-        scores: dict[str, float] = {}
-
-        for workflow in self._registry.list_all():
-            score = 0.0
-            for keyword in workflow.keywords:
-                if keyword in request_lower:
-                    score += 1.0
-                    # Exact word match bonus
-                    if f" {keyword} " in f" {request_lower} ":
-                        score += 0.5
-
-            if score > 0:
-                scores[workflow.name] = score
-
-        if not scores:
-            # Default to code-review
-            return ClassificationResult(
-                primary_workflow="code-review",
-                confidence=0.3,
-                reasoning="No keyword matches, defaulting to code-review",
-            )
-
-        # Sort by score
-        sorted_workflows = sorted(scores.items(), key=lambda x: x[1], reverse=True)
-        primary = sorted_workflows[0][0]
-        primary_score = sorted_workflows[0][1]
-
-        # Get secondary if significantly different
-        secondary = []
-        if len(sorted_workflows) > 1:
-            for name, score in sorted_workflows[1:3]:
-                if score >= primary_score * 0.5:
-                    secondary.append(name)
-
-        # Normalize confidence
-        max_possible = max(len(w.keywords) for w in self._registry.list_all())
-        confidence = min(primary_score / max_possible, 1.0)
-
-        return ClassificationResult(
-            primary_workflow=primary,
-            secondary_workflows=secondary,
-            confidence=confidence,
-            reasoning=f"Keyword match score: {primary_score}",
-        )
-
-    def classify_sync(
-        self,
-        request: str,
-        context: dict[str, Any] | None = None,
-    ) -> ClassificationResult:
-        """Synchronous classification using keyword matching only."""
-        return self._keyword_classify(
-            request,
-            self._registry.get_descriptions_for_classification(),
-        )