attune-ai 2.0.0__py3-none-any.whl

attune/workflows/step_config.py

@@ -0,0 +1,234 @@
+"""Workflow Step Configuration for Multi-Model Pipelines
+
+Provides declarative step configuration that integrates with:
+- attune.models.registry for model lookup
+- attune.models.tasks for task-type routing
+- attune.models.fallback for resilience policies
+
+Copyright 2025 Smart-AI-Memory
+Licensed under Fair Source License 0.9
+"""
+
+from dataclasses import dataclass, field
+from typing import Any
+
+from attune.models import (
+    FallbackPolicy,
+    ModelTier,
+    RetryPolicy,
+    get_tier_for_task,
+    normalize_task_type,
+)
+
+
+@dataclass
+class WorkflowStepConfig:
+    """Configuration for a single workflow step.
+
+    Combines declarative routing configuration with optional overrides
+    for provider, tier, and resilience policies.
+
+    Example:
+        >>> step = WorkflowStepConfig(
+        ...     name="triage",
+        ...     task_type="classify",
+        ...     tier_hint="cheap",
+        ...     timeout_seconds=30,
+        ... )
+        >>> step.effective_tier
+        'cheap'
+
+        >>> step2 = WorkflowStepConfig(
+        ...     name="analysis",
+        ...     task_type="fix_bug",
+        ...     # tier_hint not specified, uses task_type routing
+        ... )
+        >>> step2.effective_tier
+        'capable'
+
+    """
+
+    # Required fields
+    name: str
+    task_type: str  # Canonical task type (e.g., "summarize", "fix_bug", "coordinate")
+
+    # Optional routing hints (override task-based routing)
+    tier_hint: str | None = None  # "cheap" | "capable" | "premium"
+    provider_hint: str | None = None  # "anthropic" | "openai" | "ollama"
+
+    # Optional resilience configuration
+    fallback_policy: FallbackPolicy | None = None
+    retry_policy: RetryPolicy | None = None
+
+    # Optional execution constraints
+    timeout_seconds: int | None = None
+    max_tokens: int | None = None
+
+    # Optional metadata
+    description: str = ""
+    metadata: dict[str, Any] = field(default_factory=dict)
+
+    def __post_init__(self) -> None:
+        """Normalize task_type on creation."""
+        self.task_type = normalize_task_type(self.task_type)
+
+    @property
+    def effective_tier(self) -> str:
+        """Get the effective tier for this step.
+
+        Priority:
+        1. tier_hint if specified
+        2. Tier derived from task_type routing
+
+        Returns:
+            Tier name ("cheap", "capable", or "premium")
+
+        """
+        if self.tier_hint:
+            return self.tier_hint
+
+        tier = get_tier_for_task(self.task_type)
+        return tier.value
+
+    @property
+    def effective_tier_enum(self) -> ModelTier:
+        """Get effective tier as ModelTier enum."""
+        return ModelTier(self.effective_tier)
+
+    def with_overrides(
+        self,
+        tier_hint: str | None = None,
+        provider_hint: str | None = None,
+        fallback_policy: FallbackPolicy | None = None,
+        retry_policy: RetryPolicy | None = None,
+        timeout_seconds: int | None = None,
+    ) -> "WorkflowStepConfig":
+        """Create a new step config with overrides applied.
+
+        Useful for runtime customization without mutating the original.
+
+        Returns:
+            New WorkflowStepConfig with overrides applied
+
+        """
+        return WorkflowStepConfig(
+            name=self.name,
+            task_type=self.task_type,
+            tier_hint=tier_hint if tier_hint is not None else self.tier_hint,
+            provider_hint=provider_hint if provider_hint is not None else self.provider_hint,
+            fallback_policy=(
+                fallback_policy if fallback_policy is not None else self.fallback_policy
+            ),
+            retry_policy=retry_policy if retry_policy is not None else self.retry_policy,
+            timeout_seconds=(
+                timeout_seconds if timeout_seconds is not None else self.timeout_seconds
+            ),
+            max_tokens=self.max_tokens,
+            description=self.description,
+            metadata=self.metadata.copy(),
+        )
+
+    def to_dict(self) -> dict[str, Any]:
+        """Convert to dictionary for serialization."""
+        return {
+            "name": self.name,
+            "task_type": self.task_type,
+            "tier_hint": self.tier_hint,
+            "provider_hint": self.provider_hint,
+            "effective_tier": self.effective_tier,
+            "timeout_seconds": self.timeout_seconds,
+            "max_tokens": self.max_tokens,
+            "description": self.description,
+            "metadata": self.metadata,
+            "has_fallback_policy": self.fallback_policy is not None,
+            "has_retry_policy": self.retry_policy is not None,
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> "WorkflowStepConfig":
+        """Create from dictionary.
+
+        Note: fallback_policy and retry_policy are not restored from dict
+        (they should be configured programmatically).
+        """
+        return cls(
+            name=data["name"],
+            task_type=data["task_type"],
+            tier_hint=data.get("tier_hint"),
+            provider_hint=data.get("provider_hint"),
+            timeout_seconds=data.get("timeout_seconds"),
+            max_tokens=data.get("max_tokens"),
+            description=data.get("description", ""),
+            metadata=data.get("metadata", {}),
+        )
+
+
+def validate_step_config(step: WorkflowStepConfig) -> list[str]:
+    """Validate a step configuration.
+
+    Returns:
+        List of validation error messages (empty if valid)
+
+    """
+    errors = []
+
+    if not step.name:
+        errors.append("Step name is required")
+
+    if not step.task_type:
+        errors.append("Step task_type is required")
+
+    if step.tier_hint and step.tier_hint not in ("cheap", "capable", "premium"):
+        errors.append(f"Invalid tier_hint: {step.tier_hint}")
+
+    if step.provider_hint and step.provider_hint not in (
+        "anthropic",
+        "openai",
+        "google",
+        "ollama",
+        "hybrid",
+    ):
+        errors.append(f"Invalid provider_hint: {step.provider_hint}")
+
+    if step.timeout_seconds is not None and step.timeout_seconds <= 0:
+        errors.append(f"timeout_seconds must be positive: {step.timeout_seconds}")
+
+    if step.max_tokens is not None and step.max_tokens <= 0:
+        errors.append(f"max_tokens must be positive: {step.max_tokens}")
+
+    return errors
+
+
+def steps_from_tier_map(
+    stages: list[str],
+    tier_map: dict[str, str],
+    task_type_default: str = "generate_code",
+) -> list[WorkflowStepConfig]:
+    """Convert legacy stages/tier_map to WorkflowStepConfig list.
+
+    Useful for migrating existing workflows.
+
+    Args:
+        stages: List of stage names
+        tier_map: Mapping of stage name to tier
+        task_type_default: Default task type if not inferrable
+
+    Returns:
+        List of WorkflowStepConfig
+
+    """
+    steps = []
+    for stage_name in stages:
+        tier = tier_map.get(stage_name, "capable")
+        # Handle both string and enum tier values
+        if hasattr(tier, "value"):
+            tier = tier.value
+
+        steps.append(
+            WorkflowStepConfig(
+                name=stage_name,
+                task_type=task_type_default,
+                tier_hint=tier,
+            ),
+        )
+    return steps

attune/workflows/telemetry_mixin.py

@@ -0,0 +1,269 @@
+"""Telemetry Mixin for Workflow LLM Call Tracking
+
+Extracted from BaseWorkflow to improve maintainability and reusability.
+Provides telemetry tracking for LLM calls and workflow executions.
+
+Copyright 2025 Smart-AI-Memory
+Licensed under Fair Source License 0.9
+"""
+
+from __future__ import annotations
+
+import logging
+import uuid
+from datetime import datetime
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from attune.models import (
+        TelemetryBackend,
+    )
+
+logger = logging.getLogger(__name__)
+
+# Try to import UsageTracker
+try:
+    from attune.telemetry import UsageTracker
+
+    TELEMETRY_AVAILABLE = True
+except ImportError:
+    TELEMETRY_AVAILABLE = False
+    UsageTracker = None  # type: ignore
+
+
+class TelemetryMixin:
+    """Mixin that provides telemetry tracking for workflow LLM calls.
+
+    This mixin extracts telemetry logic from BaseWorkflow to improve
+    maintainability and enable reuse in other contexts.
+
+    Attributes:
+        _telemetry_backend: Backend for storing telemetry records
+        _telemetry_tracker: UsageTracker singleton for tracking
+        _enable_telemetry: Whether telemetry is enabled
+        _run_id: Current workflow run ID for correlation
+
+    Usage:
+        class MyWorkflow(TelemetryMixin, BaseWorkflow):
+            pass
+
+        # TelemetryMixin methods are now available
+        workflow._track_telemetry(...)
+        workflow._emit_call_telemetry(...)
+        workflow._emit_workflow_telemetry(...)
+    """
+
+    # Instance variables (set by __init__ or subclass)
+    _telemetry_backend: TelemetryBackend | None = None
+    _telemetry_tracker: UsageTracker | None = None
+    _enable_telemetry: bool = True
+    _run_id: str | None = None
+
+    # These must be provided by the class using this mixin
+    name: str = "unknown"
+    _provider_str: str = "unknown"
+
+    def _init_telemetry(self, telemetry_backend: TelemetryBackend | None = None) -> None:
+        """Initialize telemetry tracking.
+
+        Call this from __init__ to set up telemetry.
+
+        Args:
+            telemetry_backend: Optional backend for storing telemetry records.
+                             Defaults to TelemetryStore (JSONL file backend).
+        """
+        from attune.models import get_telemetry_store
+
+        self._telemetry_backend = telemetry_backend or get_telemetry_store()
+        self._telemetry_tracker = None
+        self._enable_telemetry = True
+
+        if TELEMETRY_AVAILABLE and UsageTracker is not None:
+            try:
+                self._telemetry_tracker = UsageTracker.get_instance()
+            except (OSError, PermissionError) as e:
+                # File system errors - log but disable telemetry
+                logger.debug(f"Failed to initialize telemetry tracker (file system error): {e}")
+                self._enable_telemetry = False
+            except (AttributeError, TypeError, ValueError) as e:
+                # Configuration or initialization errors
+                logger.debug(f"Failed to initialize telemetry tracker (config error): {e}")
+                self._enable_telemetry = False
+
+    def _track_telemetry(
+        self,
+        stage: str,
+        tier: Any,  # ModelTier
+        model: str,
+        cost: float,
+        tokens: dict[str, int],
+        cache_hit: bool,
+        cache_type: str | None,
+        duration_ms: int,
+    ) -> None:
+        """Track telemetry for an LLM call.
+
+        Args:
+            stage: Stage name
+            tier: Model tier used (ModelTier enum)
+            model: Model ID used
+            cost: Cost in USD
+            tokens: Dictionary with "input" and "output" token counts
+            cache_hit: Whether this was a cache hit
+            cache_type: Cache type if cache hit
+            duration_ms: Duration in milliseconds
+        """
+        if not self._enable_telemetry or self._telemetry_tracker is None:
+            return
+
+        try:
+            provider_str = getattr(self, "_provider_str", "unknown")
+            self._telemetry_tracker.track_llm_call(
+                workflow=self.name,
+                stage=stage,
+                tier=tier.value.upper() if hasattr(tier, "value") else str(tier).upper(),
+                model=model,
+                provider=provider_str,
+                cost=cost,
+                tokens=tokens,
+                cache_hit=cache_hit,
+                cache_type=cache_type,
+                duration_ms=duration_ms,
+            )
+        except (AttributeError, TypeError, ValueError) as e:
+            # INTENTIONAL: Telemetry tracking failures should never crash workflows
+            logger.debug(f"Failed to track telemetry (config/data error): {e}")
+        except (OSError, PermissionError) as e:
+            # File system errors - log but never crash workflow
+            logger.debug(f"Failed to track telemetry (file system error): {e}")
+
+    def _emit_call_telemetry(
+        self,
+        step_name: str,
+        task_type: str,
+        tier: str,
+        model_id: str,
+        input_tokens: int,
+        output_tokens: int,
+        cost: float,
+        latency_ms: int,
+        success: bool = True,
+        error_message: str | None = None,
+        fallback_used: bool = False,
+    ) -> None:
+        """Emit an LLMCallRecord to the telemetry backend.
+
+        Args:
+            step_name: Name of the workflow step
+            task_type: Task type used for routing
+            tier: Model tier used
+            model_id: Model ID used
+            input_tokens: Input token count
+            output_tokens: Output token count
+            cost: Estimated cost
+            latency_ms: Latency in milliseconds
+            success: Whether the call succeeded
+            error_message: Error message if failed
+            fallback_used: Whether fallback was used
+        """
+        from attune.models import LLMCallRecord
+
+        record = LLMCallRecord(
+            call_id=str(uuid.uuid4()),
+            timestamp=datetime.now().isoformat(),
+            workflow_name=self.name,
+            step_name=step_name,
+            task_type=task_type,
+            provider=getattr(self, "_provider_str", "unknown"),
+            tier=tier,
+            model_id=model_id,
+            input_tokens=input_tokens,
+            output_tokens=output_tokens,
+            estimated_cost=cost,
+            latency_ms=latency_ms,
+            success=success,
+            error_message=error_message,
+            fallback_used=fallback_used,
+            metadata={"run_id": self._run_id},
+        )
+        try:
+            if self._telemetry_backend is not None:
+                self._telemetry_backend.log_call(record)
+        except (AttributeError, ValueError, TypeError):
+            # Telemetry backend errors - log but don't crash workflow
+            logger.debug("Failed to log call telemetry (backend error)")
+        except OSError:
+            # File system errors - log but don't crash workflow
+            logger.debug("Failed to log call telemetry (file system error)")
+        except Exception:  # noqa: BLE001
+            # INTENTIONAL: Telemetry is optional diagnostics - never crash workflow
+            logger.debug("Unexpected error logging call telemetry")
+
+    def _emit_workflow_telemetry(self, result: Any) -> None:
+        """Emit a WorkflowRunRecord to the telemetry backend.
+
+        Args:
+            result: The WorkflowResult to record
+        """
+        from attune.models import WorkflowRunRecord, WorkflowStageRecord
+
+        # Build stage records
+        stages = [
+            WorkflowStageRecord(
+                stage_name=s.name,
+                tier=s.tier.value if hasattr(s.tier, "value") else str(s.tier),
+                model_id=(
+                    self.get_model_for_tier(s.tier)
+                    if hasattr(self, "get_model_for_tier")
+                    else "unknown"
+                ),
+                input_tokens=s.input_tokens,
+                output_tokens=s.output_tokens,
+                cost=s.cost,
+                latency_ms=s.duration_ms,
+                success=not s.skipped and result.error is None,
+                skipped=s.skipped,
+                skip_reason=s.skip_reason,
+            )
+            for s in result.stages
+        ]
+
+        record = WorkflowRunRecord(
+            run_id=self._run_id or str(uuid.uuid4()),
+            workflow_name=self.name,
+            started_at=result.started_at.isoformat(),
+            completed_at=result.completed_at.isoformat(),
+            stages=stages,
+            total_input_tokens=sum(s.input_tokens for s in result.stages if not s.skipped),
+            total_output_tokens=sum(s.output_tokens for s in result.stages if not s.skipped),
+            total_cost=result.cost_report.total_cost,
+            baseline_cost=result.cost_report.baseline_cost,
+            savings=result.cost_report.savings,
+            savings_percent=result.cost_report.savings_percent,
+            total_duration_ms=result.total_duration_ms,
+            success=result.success,
+            error=result.error,
+            providers_used=[getattr(self, "_provider_str", "unknown")],
+            tiers_used=list(result.cost_report.by_tier.keys()),
+        )
+        try:
+            if self._telemetry_backend is not None:
+                self._telemetry_backend.log_workflow(record)
+        except (AttributeError, ValueError, TypeError):
+            # Telemetry backend errors - log but don't crash workflow
+            logger.debug("Failed to log workflow telemetry (backend error)")
+        except OSError:
+            # File system errors - log but don't crash workflow
+            logger.debug("Failed to log workflow telemetry (file system error)")
+        except Exception:  # noqa: BLE001
+            # INTENTIONAL: Telemetry is optional diagnostics - never crash workflow
+            logger.debug("Unexpected error logging workflow telemetry")
+
+    def _generate_run_id(self) -> str:
+        """Generate a new run ID for telemetry correlation.
+
+        Returns:
+            A new UUID string for the run
+        """
+        self._run_id = str(uuid.uuid4())
+        return self._run_id

attune/workflows/test5.py

@@ -0,0 +1,125 @@
+"""scan code for bugs or opportunities to improve the code and generate a detailed report.
+
+Stages:
+1. analyze - Analyze
+2. process - Process
+3. test - Test
+4. report - Report
+
+Copyright 2025 Smart-AI-Memory
+Licensed under Fair Source License 0.9
+"""
+
+import logging
+from typing import Any
+
+from attune.workflows.base import BaseWorkflow, ModelTier
+
+logger = logging.getLogger(__name__)
+
+
+class Test5Workflow(BaseWorkflow):
+    """scan code for bugs or opportunities to improve the code and generate a detailed report.
+
+
+    Usage:
+        workflow = Test5Workflow()
+        result = await workflow.execute(
+            # Add parameters here
+        )
+    """
+
+    name = "test5"
+    description = (
+        "scan code for bugs or opportunities to improve the code and generate a detailed report."
+    )
+    stages = ["analyze", "fix"]
+    tier_map = {
+        "analyze": ModelTier.CAPABLE,
+        "fix": ModelTier.CAPABLE,
+    }
+
+    def __init__(
+        self,
+        **kwargs: Any,
+    ):
+        """Initialize test5 workflow.
+
+        Args:
+            **kwargs: Additional arguments passed to BaseWorkflow
+
+        """
+        super().__init__(**kwargs)
+        self._crew: Any = None
+        self._crew_available = False
+
+    async def _initialize_crew(self) -> None:
+        """Initialize the Refactoring Crew."""
+        if self._crew is not None:
+            return
+
+        try:
+            from attune_llm.agent_factory.crews.refactoring import RefactoringCrew
+
+            self._crew = RefactoringCrew()
+            self._crew_available = True
+            logger.info("RefactoringCrew initialized successfully")
+        except ImportError as e:
+            logger.warning(f"RefactoringCrew not available: {e}")
+            self._crew_available = False
+
+    async def run_stage(
+        self,
+        stage_name: str,
+        tier: ModelTier,
+        input_data: Any,
+    ) -> tuple[Any, int, int]:
+        """Execute RefactoringCrew for the given stage."""
+        await self._initialize_crew()
+
+        if not self._crew_available:
+            return {"error": "Crew not available"}, 0, 0
+
+        try:
+            if stage_name == "analyze":
+                # Use RefactoringCrew's analyze method
+                result = await self._crew.analyze(
+                    code=input_data.get("code", ""), file_path=input_data.get("path", ".")
+                )
+
+                return (
+                    {
+                        "findings": [
+                            {
+                                "title": f.title,
+                                "description": f.description,
+                                "category": f.category.value,
+                                "severity": f.severity.value,
+                                "file": f.file_path,
+                                "lines": f"{f.start_line}-{f.end_line}",
+                            }
+                            for f in result.findings
+                        ],
+                        "summary": f"Found {len(result.findings)} refactoring opportunities",
+                    },
+                    0,
+                    0,
+                )
+
+            elif stage_name == "fix":
+                # Apply refactorings (placeholder for now)
+                return (
+                    {
+                        "status": "Refactoring recommendations ready",
+                        "message": "Review findings from analyze stage to apply fixes",
+                    },
+                    0,
+                    0,
+                )
+
+            else:
+                return {"error": f"Unknown stage: {stage_name}"}, 0, 0
+
+        except Exception as e:
+            logger.error(f"Crew execution failed: {e}")
+            return {"error": str(e)}, 0, 0