attune-ai 2.0.0__py3-none-any.whl

attune_llm/state.py

@@ -0,0 +1,246 @@
+"""Collaboration State Management
+
+Tracks AI-human collaboration over time to enable Level 3+ empathy.
+
+Copyright 2025 Smart AI Memory, LLC
+Licensed under Fair Source 0.9
+"""
+
+from dataclasses import dataclass, field
+from datetime import datetime
+from enum import Enum
+from typing import Any
+
+
+class PatternType(Enum):
+    """Types of patterns that can be detected"""
+
+    SEQUENTIAL = "sequential"  # User always does X then Y
+    TEMPORAL = "temporal"  # User does X at specific time
+    CONDITIONAL = "conditional"  # When Z happens, user does X
+    PREFERENCE = "preference"  # User prefers format/style X
+
+
+@dataclass
+class UserPattern:
+    """A detected pattern in user behavior.
+
+    Enables Level 3 (Proactive) empathy.
+    """
+
+    pattern_type: PatternType
+    trigger: str  # What triggers this pattern
+    action: str  # What user typically does
+    confidence: float  # 0.0 to 1.0
+    occurrences: int  # How many times observed
+    last_seen: datetime
+    context: dict[str, Any] = field(default_factory=dict)
+
+    def should_act(self, trust_level: float) -> bool:
+        """Determine if we should act proactively on this pattern.
+
+        Requires both high confidence and sufficient trust.
+        """
+        return self.confidence > 0.7 and trust_level > 0.6
+
+
+@dataclass
+class Interaction:
+    """Single interaction in conversation history"""
+
+    timestamp: datetime
+    role: str  # "user" or "assistant"
+    content: str
+    empathy_level: int  # Which level was used
+    metadata: dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass
+class CollaborationState:
+    """Tracks AI-human collaboration state over time.
+
+    This is the foundation for Level 2+ empathy:
+    - Level 2: Uses conversation history for context
+    - Level 3: Detects patterns, builds trust
+    - Level 4: Analyzes trajectory
+    - Level 5: Contributes to shared pattern library
+    """
+
+    user_id: str
+    session_start: datetime = field(default_factory=datetime.now)
+
+    # Conversation tracking
+    interactions: list[Interaction] = field(default_factory=list)
+
+    # Pattern detection (Level 3)
+    detected_patterns: list[UserPattern] = field(default_factory=list)
+
+    # Trust building
+    trust_level: float = 0.5  # 0.0 to 1.0, starts neutral
+    successful_actions: int = 0
+    failed_actions: int = 0
+    trust_trajectory: list[float] = field(default_factory=list)
+
+    # Empathy level progression
+    current_level: int = 1  # Start at Level 1
+    level_history: list[int] = field(default_factory=list)
+
+    # User preferences learned over time
+    preferences: dict[str, Any] = field(default_factory=dict)
+
+    # Context that persists across interactions
+    shared_context: dict[str, Any] = field(default_factory=dict)
+
+    @property
+    def success_rate(self) -> float:
+        """Calculate success rate from successful and failed actions."""
+        total = self.successful_actions + self.failed_actions
+        if total == 0:
+            return 1.0  # Default to 100% if no actions yet
+        return self.successful_actions / total
+
+    def add_interaction(
+        self,
+        role: str,
+        content: str,
+        empathy_level: int,
+        metadata: dict | None = None,
+    ):
+        """Add interaction to history"""
+        self.interactions.append(
+            Interaction(
+                timestamp=datetime.now(),
+                role=role,
+                content=content,
+                empathy_level=empathy_level,
+                metadata=metadata or {},
+            ),
+        )
+
+        # Track level history
+        if role == "assistant":
+            self.level_history.append(empathy_level)
+
+    def update_trust(self, outcome: str, magnitude: float = 1.0):
+        """Update trust level based on action outcome.
+
+        Args:
+            outcome: "success" or "failure"
+            magnitude: How much to adjust (0.0 to 1.0)
+
+        """
+        if outcome == "success":
+            adjustment = 0.05 * magnitude
+            self.trust_level = min(1.0, self.trust_level + adjustment)
+            self.successful_actions += 1
+        elif outcome == "failure":
+            adjustment = 0.10 * magnitude  # Trust erodes faster
+            self.trust_level = max(0.0, self.trust_level - adjustment)
+            self.failed_actions += 1
+
+        # Track trajectory
+        self.trust_trajectory.append(self.trust_level)
+
+    def add_pattern(self, pattern: UserPattern):
+        """Add or update a detected pattern"""
+        # Check if pattern already exists
+        for existing in self.detected_patterns:
+            if (
+                existing.pattern_type == pattern.pattern_type
+                and existing.trigger == pattern.trigger
+            ):
+                # Update existing
+                existing.occurrences = pattern.occurrences
+                existing.confidence = pattern.confidence
+                existing.last_seen = pattern.last_seen
+                return
+
+        # Add new pattern
+        self.detected_patterns.append(pattern)
+
+    def find_matching_pattern(self, trigger_text: str) -> UserPattern | None:
+        """Find pattern that matches current input.
+
+        Returns pattern with highest confidence if found.
+        """
+        matches = [
+            p
+            for p in self.detected_patterns
+            if p.trigger.lower() in trigger_text.lower() and p.should_act(self.trust_level)
+        ]
+
+        if matches:
+            # Return highest confidence match
+            return max(matches, key=lambda p: p.confidence)
+
+        return None
+
+    def get_conversation_history(
+        self,
+        max_turns: int = 10,
+        include_metadata: bool = False,
+    ) -> list[dict[str, Any]]:
+        """Get recent conversation history in LLM format.
+
+        Args:
+            max_turns: Maximum number of turns to include
+            include_metadata: Whether to include interaction metadata
+
+        Returns:
+            List of {"role": "user/assistant", "content": "..."}
+
+        """
+        recent = self.interactions[-max_turns:] if max_turns else self.interactions
+
+        if include_metadata:
+            return [{"role": i.role, "content": i.content, "metadata": i.metadata} for i in recent]
+        return [{"role": i.role, "content": i.content} for i in recent]
+
+    def should_progress_to_level(self, level: int) -> bool:
+        """Determine if system should progress to higher empathy level.
+
+        Progression criteria:
+        - Level 2: Immediate (guided questions always helpful)
+        - Level 3: Trust > 0.6, patterns detected
+        - Level 4: Trust > 0.7, sufficient history
+        - Level 5: Trust > 0.8, cross-domain patterns available
+        """
+        if level <= 2:
+            return True  # Level 2 always appropriate
+
+        if level == 3:
+            return self.trust_level > 0.6 and len(self.detected_patterns) > 0
+
+        if level == 4:
+            return (
+                self.trust_level > 0.7
+                and len(self.interactions) > 10
+                and len(self.detected_patterns) > 2
+            )
+
+        if level == 5:
+            return self.trust_level > 0.8
+
+        return False
+
+    def get_statistics(self) -> dict[str, Any]:
+        """Get collaboration statistics"""
+        total_interactions = len(self.interactions)
+        success_rate = (
+            self.successful_actions / (self.successful_actions + self.failed_actions)
+            if (self.successful_actions + self.failed_actions) > 0
+            else 0.0
+        )
+
+        return {
+            "user_id": self.user_id,
+            "session_duration": (datetime.now() - self.session_start).total_seconds(),
+            "total_interactions": total_interactions,
+            "trust_level": self.trust_level,
+            "success_rate": success_rate,
+            "patterns_detected": len(self.detected_patterns),
+            "current_level": self.current_level,
+            "average_level": (
+                sum(self.level_history) / len(self.level_history) if self.level_history else 1
+            ),
+        }

attune_llm/utils/__init__.py

@@ -0,0 +1,5 @@
+"""Utility modules for attune_llm."""
+
+from .tokens import count_message_tokens, count_tokens, estimate_cost
+
+__all__ = ["count_tokens", "count_message_tokens", "estimate_cost"]

attune_llm/utils/tokens.py

@@ -0,0 +1,349 @@
+"""Token counting utilities using Anthropic's tokenizer.
+
+Provides accurate token counting for billing-accurate cost tracking.
+Replaces rough estimates (4 chars per token) with Anthropic's official counter.
+
+Copyright 2025 Smart-AI-Memory
+Licensed under Fair Source License 0.9
+"""
+
+import functools
+import logging
+import os
+from dataclasses import dataclass
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+# Lazy import to avoid requiring dependencies if not used
+_client = None
+_tiktoken_encoding = None
+
+# Try to import tiktoken for fast local estimation
+try:
+    import tiktoken
+
+    TIKTOKEN_AVAILABLE = True
+except ImportError:
+    TIKTOKEN_AVAILABLE = False
+    logger.debug("tiktoken not available - will use API or heuristic fallback")
+
+
+@dataclass
+class TokenCount:
+    """Token count result with metadata."""
+
+    tokens: int
+    method: str  # "anthropic_api", "tiktoken", "heuristic"
+    model: str | None = None
+
+
+def _get_client():
+    """Get or create Anthropic client for token counting."""
+    global _client
+    if _client is None:
+        try:
+            from anthropic import Anthropic
+
+            api_key = os.getenv("ANTHROPIC_API_KEY")
+            if not api_key:
+                raise ValueError(
+                    "ANTHROPIC_API_KEY environment variable required for API token counting"
+                )
+            _client = Anthropic(api_key=api_key)
+        except ImportError as e:
+            raise ImportError(
+                "anthropic package required for token counting. Install with: pip install anthropic"
+            ) from e
+    return _client
+
+
+@functools.lru_cache(maxsize=4)
+def _get_tiktoken_encoding(model: str) -> Any:
+    """Get tiktoken encoding for Claude models (cached)."""
+    if not TIKTOKEN_AVAILABLE:
+        return None
+    try:
+        # Claude uses cl100k_base encoding (similar to GPT-4)
+        return tiktoken.get_encoding("cl100k_base")
+    except Exception as e:
+        logger.warning(f"Failed to get tiktoken encoding: {e}")
+        return None
+
+
+def _count_tokens_tiktoken(text: str, model: str) -> int:
+    """Count tokens using tiktoken (fast local estimation)."""
+    if not text:
+        return 0
+
+    encoding = _get_tiktoken_encoding(model)
+    if not encoding:
+        return 0
+
+    try:
+        return len(encoding.encode(text))
+    except Exception as e:
+        logger.warning(f"tiktoken encoding failed: {e}")
+        return 0
+
+
+def _count_tokens_heuristic(text: str) -> int:
+    """Fallback heuristic token counting (~4 chars per token)."""
+    if not text:
+        return 0
+    return max(1, len(text) // 4)
+
+
+def count_tokens(text: str, model: str = "claude-sonnet-4-5-20250929", use_api: bool = False) -> int:
+    """Count tokens using best available method.
+
+    By default, uses tiktoken for fast local estimation (~98% accurate).
+    Set use_api=True for exact count via Anthropic API (requires network call).
+
+    Args:
+        text: Text to tokenize
+        model: Model ID (different models may have different tokenizers)
+        use_api: Whether to use Anthropic API for exact count (slower, requires API key)
+
+    Returns:
+        Token count
+
+    Example:
+        >>> count_tokens("Hello, world!")
+        4
+        >>> count_tokens("def hello():\\n    print('hi')", use_api=True)
+        8
+
+    Raises:
+        ImportError: If anthropic package not installed (when use_api=True)
+        ValueError: If API key missing (when use_api=True)
+
+    """
+    if not text:
+        return 0
+
+    # Use API if explicitly requested
+    if use_api:
+        try:
+            client = _get_client()
+            # FIXED: Use correct API method - client.messages.count_tokens()
+            result = client.messages.count_tokens(
+                model=model,
+                messages=[{"role": "user", "content": text}],
+            )
+            return int(result.input_tokens)
+        except Exception as e:
+            logger.warning(f"API token counting failed, using fallback: {e}")
+            # Continue to fallback methods
+
+    # Try tiktoken first (fast and accurate)
+    if TIKTOKEN_AVAILABLE:
+        tokens = _count_tokens_tiktoken(text, model)
+        if tokens > 0:
+            return tokens
+
+    # Fallback to heuristic
+    return _count_tokens_heuristic(text)
+
+
+def count_message_tokens(
+    messages: list[dict[str, str]],
+    system_prompt: str | None = None,
+    model: str = "claude-sonnet-4-5-20250929",
+    use_api: bool = False,
+) -> dict[str, int]:
+    """Count tokens in a conversation.
+
+    By default uses tiktoken for fast estimation. Set use_api=True for exact count.
+
+    Args:
+        messages: List of message dicts with "role" and "content"
+        system_prompt: Optional system prompt
+        model: Model ID
+        use_api: Whether to use Anthropic API for exact count
+
+    Returns:
+        Dict with token counts by component:
+        - "system": System prompt tokens
+        - "messages": Message tokens
+        - "total": Sum of all tokens
+
+    Example:
+        >>> messages = [{"role": "user", "content": "Hello!"}]
+        >>> count_message_tokens(messages, system_prompt="You are helpful")
+        {"system": 4, "messages": 6, "total": 10}
+
+    """
+    if not messages:
+        if system_prompt:
+            tokens = count_tokens(system_prompt, model, use_api)
+            return {"system": tokens, "messages": 0, "total": tokens}
+        return {"system": 0, "messages": 0, "total": 0}
+
+    # Use Anthropic API for exact count if requested
+    if use_api:
+        try:
+            client = _get_client()
+            kwargs: dict[str, Any] = {"model": model, "messages": messages}
+            if system_prompt:
+                kwargs["system"] = system_prompt
+
+            result = client.messages.count_tokens(**kwargs)
+            # API returns total input tokens, estimate breakdown
+            total_tokens = result.input_tokens
+
+            # Estimate system vs message breakdown
+            if system_prompt:
+                system_tokens = count_tokens(system_prompt, model, use_api=False)
+                message_tokens = max(0, total_tokens - system_tokens)
+            else:
+                system_tokens = 0
+                message_tokens = total_tokens
+
+            return {
+                "system": system_tokens,
+                "messages": message_tokens,
+                "total": total_tokens,
+            }
+        except Exception as e:
+            logger.warning(f"API token counting failed, using fallback: {e}")
+            # Continue to fallback method
+
+    # Fallback: count each component separately
+    counts: dict[str, int] = {}
+
+    # Count system prompt
+    if system_prompt:
+        counts["system"] = count_tokens(system_prompt, model, use_api=False)
+    else:
+        counts["system"] = 0
+
+    # Count messages with overhead
+    message_tokens = 0
+    for message in messages:
+        content = message.get("content", "")
+        message_tokens += count_tokens(content, model, use_api=False)
+        message_tokens += 4  # Overhead for role markers
+
+    counts["messages"] = message_tokens
+    counts["total"] = counts["system"] + message_tokens
+
+    return counts
+
+
+def estimate_cost(input_tokens: int, output_tokens: int, model: str = "claude-sonnet-4-5") -> float:
+    """Estimate cost in USD based on token counts.
+
+    Args:
+        input_tokens: Input token count
+        output_tokens: Output token count
+        model: Model ID (used to look up pricing)
+
+    Returns:
+        Estimated cost in USD
+
+    Example:
+        >>> estimate_cost(1000, 500, "claude-sonnet-4-5")
+        0.0105  # $3/M input + $15/M output
+
+    Raises:
+        ValueError: If model is unknown
+
+    """
+    # Import here to avoid circular dependency
+    try:
+        from attune.models.registry import get_pricing_for_model
+
+        pricing = get_pricing_for_model(model)
+        if not pricing:
+            raise ValueError(f"Unknown model: {model}")
+
+        input_cost = (input_tokens / 1_000_000) * pricing["input"]
+        output_cost = (output_tokens / 1_000_000) * pricing["output"]
+
+        return input_cost + output_cost
+    except ImportError:
+        # Fallback if registry not available
+        # Use default Sonnet 4.5 pricing
+        input_cost = (input_tokens / 1_000_000) * 3.00
+        output_cost = (output_tokens / 1_000_000) * 15.00
+        return input_cost + output_cost
+
+
+def calculate_cost_with_cache(
+    input_tokens: int,
+    output_tokens: int,
+    cache_creation_tokens: int,
+    cache_read_tokens: int,
+    model: str = "claude-sonnet-4-5",
+) -> dict[str, Any]:
+    """Calculate cost including Anthropic prompt caching.
+
+    Anthropic prompt caching pricing:
+    - Cache writes: 25% markup over standard input pricing
+    - Cache reads: 90% discount from standard input pricing
+
+    Args:
+        input_tokens: Regular input tokens (not cached)
+        output_tokens: Output tokens
+        cache_creation_tokens: Tokens written to cache
+        cache_read_tokens: Tokens read from cache
+        model: Model ID
+
+    Returns:
+        Dict with cost breakdown:
+        - "base_cost": Cost without cache
+        - "cache_write_cost": Cost for cache writes (25% markup)
+        - "cache_read_cost": Cost for cache reads (90% discount)
+        - "total_cost": Sum of all costs
+        - "savings": Amount saved by cache reads
+
+    Example:
+        >>> calculate_cost_with_cache(1000, 500, 5000, 10000, "claude-sonnet-4-5")
+        {
+            "base_cost": 0.0105,
+            "cache_write_cost": 0.01875,  # 5000 tokens * $3.75/M
+            "cache_read_cost": 0.003,     # 10000 tokens * $0.30/M
+            "total_cost": 0.03225,
+            "savings": 0.027,             # Saved vs. no cache
+        }
+
+    """
+    # Get pricing for model
+    try:
+        from attune.models.registry import get_pricing_for_model
+
+        pricing = get_pricing_for_model(model)
+        if not pricing:
+            raise ValueError(f"Unknown model: {model}")
+
+        input_price_per_million = pricing["input"]
+        output_price_per_million = pricing["output"]
+    except (ImportError, ValueError):
+        # Fallback to default Sonnet 4.5 pricing
+        input_price_per_million = 3.00
+        output_price_per_million = 15.00
+
+    # Base cost (non-cached tokens)
+    base_cost = (input_tokens / 1_000_000) * input_price_per_million
+    base_cost += (output_tokens / 1_000_000) * output_price_per_million
+
+    # Cache write cost (25% markup)
+    cache_write_price = input_price_per_million * 1.25
+    cache_write_cost = (cache_creation_tokens / 1_000_000) * cache_write_price
+
+    # Cache read cost (90% discount = 10% of input price)
+    cache_read_price = input_price_per_million * 0.1
+    cache_read_cost = (cache_read_tokens / 1_000_000) * cache_read_price
+
+    # Calculate what we would have paid without cache
+    full_price_for_cached = (cache_read_tokens / 1_000_000) * input_price_per_million
+    savings = full_price_for_cached - cache_read_cost
+
+    return {
+        "base_cost": round(base_cost, 6),
+        "cache_write_cost": round(cache_write_cost, 6),
+        "cache_read_cost": round(cache_read_cost, 6),
+        "total_cost": round(base_cost + cache_write_cost + cache_read_cost, 6),
+        "savings": round(savings, 6),
+    }

attune_software/SOFTWARE_PLUGIN_README.md

@@ -0,0 +1,57 @@
+# Software Development Plugin
+
+> **DEPRECATION NOTICE (January 2026):** The `empathy_software_plugin.wizards` module has been removed. Please use CLI workflows instead.
+
+Production-ready analysis tools for software development.
+
+**Copyright 2025-2026 Smart AI Memory, LLC**
+**Licensed under Fair Source 0.9**
+
+## Overview
+
+The Software Development Plugin provides analysis capabilities through CLI workflows.
+
+## Recommended Approach
+
+```bash
+# Security analysis
+empathy workflow run security-audit --path ./src
+
+# Bug prediction
+empathy workflow run bug-predict --path ./src
+
+# Test coverage analysis
+empathy workflow run test-coverage --path ./src
+```
+
+Or use the Python workflow API:
+
+```python
+from attune.workflows import BugPredictWorkflow
+
+workflow = BugPredictWorkflow()
+result = await workflow.execute(target_path="./src")
+```
+
+## Migration Guide
+
+| Old Wizard | New Approach |
+|------------|--------------|
+| `EnhancedTestingWizard` | `empathy workflow run test-coverage` |
+| `PerformanceProfilingWizard` | `empathy workflow run profile` |
+| `SecurityAnalysisWizard` | `empathy workflow run security-audit` |
+
+## Installation
+
+```bash
+pip install attune-ai
+```
+
+## Support
+
+- **Documentation:** [docs/](../docs/)
+- **Issues:** [GitHub Issues](https://github.com/deepstudyai/empathy/issues)
+
+## License
+
+Copyright 2025-2026 Smart AI Memory, LLC - Licensed under Fair Source 0.9

attune_software/__init__.py

@@ -0,0 +1,13 @@
+"""Empathy Framework - Software Development Plugin
+
+Primary domain plugin demonstrating Level 4 Anticipatory Empathy
+for software development teams.
+
+Copyright 2025 Smart AI Memory, LLC
+Licensed under Fair Source 0.9
+"""
+
+from .plugin import SoftwarePlugin
+
+__version__ = "1.0.0"
+__all__ = ["SoftwarePlugin"]