attune-ai 2.0.0__py3-none-any.whl

attune/metrics/__init__.py

@@ -0,0 +1,12 @@
+"""Prompt performance metrics tracking and analysis.
+
+This module provides tools for tracking, analyzing, and optimizing
+prompt performance across the Empathy Framework.
+
+Copyright 2026 Smart-AI-Memory
+Licensed under Fair Source License 0.9
+"""
+
+from attune.metrics.prompt_metrics import MetricsTracker, PromptMetrics
+
+__all__ = ["MetricsTracker", "PromptMetrics"]

attune/metrics/collector.py

@@ -0,0 +1,31 @@
+"""Metrics collector stub (deprecated).
+
+This module is a placeholder for legacy code compatibility.
+The functionality has been moved to other modules.
+
+Copyright 2025 Smart-AI-Memory
+Licensed under Fair Source License 0.9
+"""
+
+
+class MetricsCollector:
+    """Deprecated metrics collector class.
+
+    This class is maintained for backward compatibility but is deprecated.
+    """
+
+    def __init__(self, db_path: str | None = None):
+        """Initialize metrics collector.
+
+        Args:
+            db_path: Path to database (deprecated parameter)
+        """
+        self.db_path = db_path
+
+    def collect(self):
+        """Collect metrics (deprecated)."""
+        return {}
+
+    def get_stats(self):
+        """Get statistics (deprecated)."""
+        return {}

attune/metrics/prompt_metrics.py

@@ -0,0 +1,194 @@
+"""Prompt performance metrics tracking
+
+Tracks token usage, latency, success rates, and other metrics for
+XML-enhanced prompts to enable optimization and A/B testing.
+
+Copyright 2026 Smart-AI-Memory
+Licensed under Fair Source License 0.9
+"""
+
+import json
+import logging
+from dataclasses import asdict, dataclass
+from datetime import datetime
+from pathlib import Path
+from typing import Any
+
+from attune.config import _validate_file_path
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class PromptMetrics:
+    """Metrics for a single prompt execution.
+
+    Tracks comprehensive performance data for prompt optimization
+    and A/B testing.
+
+    Attributes:
+        timestamp: ISO format timestamp of execution
+        workflow: Workflow name (e.g., "code_review", "bug_predict")
+        agent_role: Role of the agent (e.g., "Code Reviewer")
+        task_description: Brief description of task (truncated to 100 chars)
+        model: Model name (e.g., "gpt-4", "claude-sonnet")
+        prompt_tokens: Number of input tokens
+        completion_tokens: Number of output tokens
+        total_tokens: Total tokens (input + output)
+        latency_ms: Execution time in milliseconds
+        retry_count: Number of retry attempts
+        parsing_success: Whether XML parsing succeeded
+        validation_success: Whether XML validation succeeded (None if not validated)
+        error_message: Error message if execution failed (None if successful)
+        xml_structure_used: Whether XML-enhanced prompts were used
+    """
+
+    timestamp: str
+    workflow: str
+    agent_role: str
+    task_description: str
+    model: str
+    prompt_tokens: int
+    completion_tokens: int
+    total_tokens: int
+    latency_ms: float
+    retry_count: int
+    parsing_success: bool
+    validation_success: bool | None
+    error_message: str | None
+    xml_structure_used: bool
+
+    def to_dict(self) -> dict:
+        """Convert to dictionary for JSON serialization."""
+        return asdict(self)
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "PromptMetrics":
+        """Create from dictionary (deserialization)."""
+        return cls(**data)
+
+
+class MetricsTracker:
+    """Tracks and persists prompt metrics to disk.
+
+    Uses JSON Lines format for append-only writes and efficient reading.
+    Metrics are stored in .attune/prompt_metrics.json by default.
+
+    Usage:
+        tracker = MetricsTracker()
+        metric = PromptMetrics(...)
+        tracker.log_metric(metric)
+
+        summary = tracker.get_summary(workflow="code_review")
+        print(f"Avg tokens: {summary['avg_tokens']}")
+    """
+
+    def __init__(self, metrics_file: str = ".attune/prompt_metrics.json"):
+        """Initialize metrics tracker.
+
+        Args:
+            metrics_file: Path to metrics file (JSON Lines format)
+        """
+        self.metrics_file = Path(metrics_file)
+        self.metrics_file.parent.mkdir(parents=True, exist_ok=True)
+
+        # Create file if it doesn't exist
+        if not self.metrics_file.exists():
+            validated_path = _validate_file_path(str(self.metrics_file))
+            validated_path.write_text("")
+
+    def log_metric(self, metric: PromptMetrics) -> None:
+        """Log a single metric to file (JSON Lines format).
+
+        Args:
+            metric: PromptMetrics instance to log
+        """
+        try:
+            validated_path = _validate_file_path(str(self.metrics_file))
+            with open(validated_path, "a") as f:
+                f.write(json.dumps(metric.to_dict()) + "\n")
+        except (OSError, ValueError) as e:
+            logger.error(f"Failed to log metric: {e}")
+
+    def get_metrics(
+        self,
+        workflow: str | None = None,
+        start_date: datetime | None = None,
+        end_date: datetime | None = None,
+    ) -> list[PromptMetrics]:
+        """Retrieve metrics with optional filtering.
+
+        Args:
+            workflow: Filter by workflow name (None = all workflows)
+            start_date: Filter by start date (None = no lower bound)
+            end_date: Filter by end date (None = no upper bound)
+
+        Returns:
+            List of PromptMetrics matching filters
+        """
+        metrics: list[PromptMetrics] = []
+
+        try:
+            if not self.metrics_file.exists():
+                return metrics
+
+            with open(self.metrics_file) as f:
+                for line in f:
+                    if line.strip():
+                        data = json.loads(line)
+                        metric = PromptMetrics.from_dict(data)
+
+                        # Apply filters
+                        if workflow and metric.workflow != workflow:
+                            continue
+
+                        metric_time = datetime.fromisoformat(metric.timestamp)
+                        if start_date and metric_time < start_date:
+                            continue
+                        if end_date and metric_time > end_date:
+                            continue
+
+                        metrics.append(metric)
+        except Exception as e:
+            logger.error(f"Failed to read metrics: {e}")
+
+        return metrics
+
+    def get_summary(self, workflow: str | None = None) -> dict[str, Any]:
+        """Get aggregated metrics summary.
+
+        Args:
+            workflow: Filter by workflow name (None = all workflows)
+
+        Returns:
+            Dictionary with aggregated metrics:
+            - total_prompts: Total number of prompts
+            - avg_tokens: Average total tokens
+            - avg_latency_ms: Average latency in milliseconds
+            - success_rate: Ratio of successful parses
+            - retry_rate: Average retry count per prompt
+        """
+        metrics = self.get_metrics(workflow=workflow)
+
+        if not metrics:
+            return {
+                "total_prompts": 0,
+                "avg_tokens": 0,
+                "avg_latency_ms": 0,
+                "success_rate": 0,
+                "retry_rate": 0,
+            }
+
+        total_prompts = len(metrics)
+        total_tokens = sum(m.total_tokens for m in metrics)
+        total_latency = sum(m.latency_ms for m in metrics)
+        successful = sum(1 for m in metrics if m.parsing_success)
+        retries = sum(m.retry_count for m in metrics)
+
+        return {
+            "total_prompts": total_prompts,
+            "avg_tokens": total_tokens / total_prompts,
+            "avg_latency_ms": total_latency / total_prompts,
+            "success_rate": successful / total_prompts,
+            "retry_rate": retries / total_prompts,
+        }

attune/models/__init__.py

@@ -0,0 +1,172 @@
+"""Unified Model Registry for Empathy Framework
+
+Single source of truth for model configurations across:
+- attune_llm.routing.ModelRouter
+- src/attune/workflows.WorkflowConfig
+- src/attune.cost_tracker
+
+Copyright 2025 Smart-AI-Memory
+Licensed under Fair Source License 0.9
+"""
+
+from .adaptive_routing import AdaptiveModelRouter, ModelPerformance
+from .auth_strategy import (
+    AUTH_STRATEGY_FILE,
+    AuthMode,
+    AuthStrategy,
+    SubscriptionTier,
+    configure_auth_interactive,
+    count_lines_of_code,
+    get_auth_strategy,
+    get_module_size_category,
+)
+from .empathy_executor import EmpathyLLMExecutor
+from .executor import ExecutionContext, LLMExecutor, LLMResponse, MockLLMExecutor
+from .fallback import (
+    DEFAULT_FALLBACK_POLICY,
+    DEFAULT_RETRY_POLICY,
+    CircuitBreaker,
+    CircuitBreakerState,
+    FallbackPolicy,
+    FallbackStep,
+    FallbackStrategy,
+    ResilientExecutor,
+    RetryPolicy,
+    TierFallbackHelper,
+)
+from .provider_config import (
+    ProviderConfig,
+    ProviderMode,
+    configure_provider_cli,
+    configure_provider_interactive,
+    get_provider_config,
+    reset_provider_config,
+    set_provider_config,
+)
+from .registry import (
+    MODEL_REGISTRY,
+    ModelInfo,
+    ModelProvider,
+    ModelRegistry,
+    ModelTier,
+    get_all_models,
+    get_model,
+    get_pricing_for_model,
+)
+from .tasks import (
+    CAPABLE_TASKS,
+    CHEAP_TASKS,
+    PREMIUM_TASKS,
+    TASK_TIER_MAP,
+    TaskInfo,
+    TaskType,
+    get_all_tasks,
+    get_tasks_for_tier,
+    get_tier_for_task,
+    is_known_task,
+    normalize_task_type,
+)
+from .telemetry import (
+    AgentAssignmentRecord,
+    CoverageRecord,
+    FileTestRecord,
+    LLMCallRecord,
+    TaskRoutingRecord,
+    TelemetryAnalytics,
+    TelemetryBackend,
+    TelemetryStore,
+    TestExecutionRecord,
+    WorkflowRunRecord,
+    WorkflowStageRecord,
+    get_telemetry_store,
+    log_llm_call,
+    log_workflow_run,
+)
+from .validation import (
+    ConfigValidator,
+    ValidationError,
+    ValidationResult,
+    validate_config,
+    validate_yaml_file,
+)
+
+__all__ = [
+    "CAPABLE_TASKS",
+    "CHEAP_TASKS",
+    "DEFAULT_FALLBACK_POLICY",
+    "DEFAULT_RETRY_POLICY",
+    "MODEL_REGISTRY",
+    "PREMIUM_TASKS",
+    "TASK_TIER_MAP",
+    "AdaptiveModelRouter",
+    "AgentAssignmentRecord",
+    # Auth strategy exports
+    "AUTH_STRATEGY_FILE",
+    "AuthMode",
+    "AuthStrategy",
+    "CircuitBreaker",
+    "CircuitBreakerState",
+    "ConfigValidator",
+    "CoverageRecord",
+    "EmpathyLLMExecutor",
+    "ExecutionContext",
+    "FallbackPolicy",
+    "FallbackStep",
+    # Fallback exports
+    "FallbackStrategy",
+    # Telemetry exports
+    "FileTestRecord",
+    "LLMCallRecord",
+    # Executor exports
+    "LLMExecutor",
+    "LLMResponse",
+    "MockLLMExecutor",
+    "ModelInfo",
+    "ModelPerformance",
+    "ModelProvider",
+    # Registry exports
+    "ModelRegistry",
+    "ModelTier",
+    "ProviderConfig",
+    # Provider config exports
+    "ProviderMode",
+    "ResilientExecutor",
+    "RetryPolicy",
+    "SubscriptionTier",
+    "TaskInfo",
+    "TierFallbackHelper",
+    # Task exports
+    "TaskRoutingRecord",
+    "TaskType",
+    "TelemetryAnalytics",
+    "TelemetryBackend",
+    "TelemetryStore",
+    "TestExecutionRecord",
+    # Validation exports
+    "ValidationError",
+    "ValidationResult",
+    "WorkflowRunRecord",
+    "WorkflowStageRecord",
+    "configure_auth_interactive",
+    "configure_provider_cli",
+    "configure_provider_interactive",
+    "count_lines_of_code",
+    "get_all_models",
+    "get_all_tasks",
+    "get_auth_strategy",
+    "get_model",
+    "get_module_size_category",
+    "get_pricing_for_model",
+    "get_provider_config",
+    "get_tasks_for_tier",
+    "get_telemetry_store",
+    "get_tier_for_task",
+    "is_known_task",
+    "log_llm_call",
+    "log_workflow_run",
+    "normalize_task_type",
+    "reset_provider_config",
+    "set_provider_config",
+    "validate_config",
+    "validate_yaml_file",
+]

attune/models/__main__.py

@@ -0,0 +1,13 @@
+"""Enable running the models CLI as a module.
+
+Usage:
+    python -m attune.models registry
+    python -m attune.models tasks
+    python -m attune.models validate config.yaml
+    python -m attune.models costs
+"""
+
+from .cli import main
+
+if __name__ == "__main__":
+    exit(main())