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

empathy_os/cli/commands/batch.py

@@ -1,264 +0,0 @@
-"""CLI commands for Anthropic Batch API operations (50% cost savings).
-
-Provides commands to submit, monitor, and retrieve results from batch processing jobs.
-
-Copyright 2025 Smart-AI-Memory
-Licensed under Fair Source License 0.9
-"""
-
-import asyncio
-import json
-import logging
-import os
-from pathlib import Path
-
-from empathy_os.config import _validate_file_path
-from empathy_os.workflows.batch_processing import BatchProcessingWorkflow
-
-logger = logging.getLogger(__name__)
-
-
-def cmd_batch_submit(args):
-    """Submit a batch processing job from JSON file.
-
-    Args:
-        args: Arguments with input_file path
-
-    File format:
-        [
-            {
-                "task_id": "task_1",
-                "task_type": "analyze_logs",
-                "input_data": {"logs": "ERROR: ..."},
-                "model_tier": "capable"
-            },
-            ...
-        ]
-    """
-    input_file = Path(args.input_file)
-    if not input_file.exists():
-        print(f"❌ Error: Input file not found: {input_file}")
-        return 1
-
-    print(f"📤 Submitting batch from {input_file}...")
-
-    try:
-        # Get API key from environment
-        api_key = os.getenv("ANTHROPIC_API_KEY")
-        if not api_key:
-            print("❌ Error: ANTHROPIC_API_KEY environment variable not set")
-            print("   Set it with: export ANTHROPIC_API_KEY='your-api-key-here'")
-            print("   Or get a key from: https://console.anthropic.com/")
-            return 1
-
-        # Load requests from file
-        workflow = BatchProcessingWorkflow(api_key=api_key)
-        requests = workflow.load_requests_from_file(str(input_file))
-
-        print(f"  Found {len(requests)} requests")
-
-        # Create batch (sync operation)
-        batch_id = workflow.batch_provider.create_batch(
-            [
-                {
-                    "custom_id": req.task_id,
-                    "params": {
-                        "model": "claude-sonnet-4-5-20250929",  # Default model
-                        "messages": workflow._format_messages(req),
-                        "max_tokens": 4096,
-                    },
-                }
-                for req in requests
-            ]
-        )
-
-        print("\n✅ Batch submitted successfully!")
-        print(f"   Batch ID: {batch_id}")
-        print(f"\nMonitor status with: empathy batch status {batch_id}")
-        print(f"Retrieve results with: empathy batch results {batch_id} output.json")
-        print(
-            f"Or wait for completion: empathy batch wait {batch_id} output.json --poll-interval 300"
-        )
-
-        return 0
-
-    except Exception as e:
-        logger.exception("Failed to submit batch")
-        print(f"❌ Error: {e}")
-        return 1
-
-
-def cmd_batch_status(args):
-    """Check status of a batch processing job.
-
-    Args:
-        args: Arguments with batch_id
-    """
-    batch_id = args.batch_id
-
-    print(f"🔍 Checking status for batch {batch_id}...")
-
-    try:
-        api_key = os.getenv("ANTHROPIC_API_KEY")
-        if not api_key:
-            print("❌ Error: ANTHROPIC_API_KEY environment variable not set")
-            print("   Set it with: export ANTHROPIC_API_KEY='your-api-key-here'")
-            print("   Or get a key from: https://console.anthropic.com/")
-            return 1
-
-        workflow = BatchProcessingWorkflow(api_key=api_key)
-        status = workflow.batch_provider.get_batch_status(batch_id)
-
-        print("\n📊 Batch Status:")
-        print(f"   ID: {status.id}")
-        print(f"   Processing Status: {status.processing_status}")
-        print(f"   Created: {status.created_at}")
-
-        if hasattr(status, "ended_at") and status.ended_at:
-            print(f"   Ended: {status.ended_at}")
-
-        print("\n📈 Request Counts:")
-        counts = status.request_counts
-        print(f"   Processing: {counts.processing}")
-        print(f"   Succeeded: {counts.succeeded}")
-        print(f"   Errored: {counts.errored}")
-        print(f"   Canceled: {counts.canceled}")
-        print(f"   Expired: {counts.expired}")
-
-        if status.processing_status == "ended":
-            print("\n✅ Batch processing completed!")
-            print(f"   Retrieve results with: empathy batch results {batch_id} output.json")
-        else:
-            print("\n⏳ Batch still processing...")
-
-        # Output JSON if requested
-        if args.json:
-            print("\n" + json.dumps(status.__dict__, indent=2, default=str))
-
-        return 0
-
-    except Exception as e:
-        logger.exception("Failed to get batch status")
-        print(f"❌ Error: {e}")
-        return 1
-
-
-def cmd_batch_results(args):
-    """Retrieve results from a completed batch.
-
-    Args:
-        args: Arguments with batch_id and output_file
-    """
-    batch_id = args.batch_id
-    output_file = args.output_file
-
-    print(f"📥 Retrieving results for batch {batch_id}...")
-
-    try:
-        api_key = os.getenv("ANTHROPIC_API_KEY")
-        if not api_key:
-            print("❌ Error: ANTHROPIC_API_KEY environment variable not set")
-            print("   Set it with: export ANTHROPIC_API_KEY='your-api-key-here'")
-            print("   Or get a key from: https://console.anthropic.com/")
-            return 1
-
-        workflow = BatchProcessingWorkflow(api_key=api_key)
-
-        # Check status first
-        status = workflow.batch_provider.get_batch_status(batch_id)
-
-        if status.processing_status != "ended":
-            print(f"❌ Error: Batch has not ended processing (status: {status.processing_status})")
-            print(f"   Wait for completion with: empathy batch wait {batch_id} {output_file}")
-            return 1
-
-        # Get results
-        results = workflow.batch_provider.get_batch_results(batch_id)
-
-        # Save to file
-        validated_path = _validate_file_path(output_file)
-        with open(validated_path, "w") as f:
-            json.dump([dict(r) for r in results], f, indent=2, default=str)
-
-        print(f"\n✅ Results saved to {validated_path}")
-        print(f"   Total: {len(results)} results")
-
-        # Summary
-        succeeded = sum(
-            1 for r in results if r.get("result", {}).get("type") == "succeeded"
-        )
-        errored = sum(
-            1 for r in results if r.get("result", {}).get("type") == "errored"
-        )
-
-        print(f"   Succeeded: {succeeded}")
-        print(f"   Errored: {errored}")
-
-        return 0
-
-    except Exception as e:
-        logger.exception("Failed to retrieve results")
-        print(f"❌ Error: {e}")
-        return 1
-
-
-def cmd_batch_wait(args):
-    """Wait for batch to complete and retrieve results.
-
-    Args:
-        args: Arguments with batch_id, output_file, poll_interval, timeout
-    """
-    batch_id = args.batch_id
-    output_file = args.output_file
-    poll_interval = args.poll_interval
-    timeout = args.timeout
-
-    print(f"⏳ Waiting for batch {batch_id} to complete...")
-    print(f"   Polling every {poll_interval}s (max {timeout}s)")
-
-    try:
-        api_key = os.getenv("ANTHROPIC_API_KEY")
-        if not api_key:
-            print("❌ Error: ANTHROPIC_API_KEY environment variable not set")
-            print("   Set it with: export ANTHROPIC_API_KEY='your-api-key-here'")
-            print("   Or get a key from: https://console.anthropic.com/")
-            return 1
-
-        workflow = BatchProcessingWorkflow(api_key=api_key)
-
-        # Wait for completion (async)
-        results = asyncio.run(
-            workflow.batch_provider.wait_for_batch(
-                batch_id, poll_interval=poll_interval, timeout=timeout
-            )
-        )
-
-        # Save results
-        validated_path = _validate_file_path(output_file)
-        with open(validated_path, "w") as f:
-            json.dump([dict(r) for r in results], f, indent=2, default=str)
-
-        print(f"\n✅ Batch completed! Results saved to {validated_path}")
-        print(f"   Total: {len(results)} results")
-
-        # Summary
-        succeeded = sum(
-            1 for r in results if r.get("result", {}).get("type") == "succeeded"
-        )
-        errored = sum(
-            1 for r in results if r.get("result", {}).get("type") == "errored"
-        )
-
-        print(f"   Succeeded: {succeeded}")
-        print(f"   Errored: {errored}")
-
-        return 0
-
-    except TimeoutError:
-        print(f"\n⏰ Timeout: Batch did not complete within {timeout}s")
-        print(f"   Check status with: empathy batch status {batch_id}")
-        return 1
-    except Exception as e:
-        logger.exception("Failed to wait for batch")
-        print(f"❌ Error: {e}")
-        return 1

empathy_os/cli/commands/cache.py

@@ -1,248 +0,0 @@
-"""Cache monitoring and statistics commands for the CLI.
-
-Copyright 2025 Smart-AI-Memory
-Licensed under Fair Source License 0.9
-"""
-
-import json
-import re
-from datetime import datetime, timedelta
-from pathlib import Path
-from typing import Any
-
-
-def cmd_cache_stats(args):
-    """Display prompt caching statistics and savings.
-
-    Analyzes logs and telemetry to show cache performance metrics:
-    - Cache hit rate
-    - Total cost savings
-    - Cache read/write tokens
-    - Recommendations for optimization
-
-    Args:
-        args: Namespace object from argparse with attributes:
-            - days (int): Number of days to analyze (default: 7)
-            - format (str): Output format ('table' or 'json')
-            - verbose (bool): Show detailed breakdown
-
-    Returns:
-        None: Prints cache statistics report or JSON output
-    """
-    print(f"\n🔍 Analyzing cache performance (last {args.days} days)...\n")
-
-    # Collect cache metrics from logs
-    stats = _collect_cache_stats(days=args.days)
-
-    if args.format == "json":
-        print(json.dumps(stats, indent=2))
-        return
-
-    # Display formatted report
-    _display_cache_report(stats, verbose=args.verbose)
-
-
-def _collect_cache_stats(days: int = 7) -> dict[str, Any]:
-    """Collect cache statistics from logs and telemetry.
-
-    Args:
-        days: Number of days to analyze
-
-    Returns:
-        Dictionary with cache statistics
-    """
-    # Try to find log files
-    log_paths = [
-        Path.cwd() / "empathy_os.log",
-        Path.home() / ".empathy" / "logs" / "empathy_os.log",
-        Path("/tmp/empathy_os.log"),
-    ]
-
-    log_file = None
-    for path in log_paths:
-        if path.exists():
-            log_file = path
-            break
-
-    if not log_file:
-        return {
-            "error": "No log file found",
-            "message": "Enable logging to track cache performance",
-            "total_requests": 0,
-            "cache_hits": 0,
-            "cache_writes": 0,
-            "total_savings": 0.0,
-        }
-
-    # Parse log file for cache metrics
-    cutoff_date = datetime.now() - timedelta(days=days)
-
-    cache_hits = 0
-    cache_writes = 0
-    total_cache_read_tokens = 0
-    total_cache_write_tokens = 0
-    total_savings = 0.0
-    total_requests = 0
-
-    # Regex patterns for log parsing
-    cache_hit_pattern = re.compile(r"Cache HIT: ([\d,]+) tokens read.*saved \$([\d.]+)")
-    cache_write_pattern = re.compile(r"Cache WRITE: ([\d,]+) tokens written.*cost \$([\d.]+)")
-
-    try:
-        with open(log_file) as f:
-            for line in f:
-                # Try to extract timestamp
-                # Common format: 2026-01-27 21:30:45,123
-                timestamp_match = re.match(
-                    r"(\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2})", line
-                )
-                if timestamp_match:
-                    try:
-                        log_time = datetime.strptime(
-                            timestamp_match.group(1), "%Y-%m-%d %H:%M:%S"
-                        )
-                        if log_time < cutoff_date:
-                            continue  # Skip old entries
-                    except ValueError:
-                        pass  # Continue if timestamp parsing fails
-
-                # Count API requests (approximate)
-                if "anthropic.AsyncAnthropic" in line or "messages.create" in line:
-                    total_requests += 1
-
-                # Parse cache hit
-                hit_match = cache_hit_pattern.search(line)
-                if hit_match:
-                    tokens_str = hit_match.group(1).replace(",", "")
-                    tokens = int(tokens_str)
-                    savings = float(hit_match.group(2))
-
-                    cache_hits += 1
-                    total_cache_read_tokens += tokens
-                    total_savings += savings
-
-                # Parse cache write
-                write_match = cache_write_pattern.search(line)
-                if write_match:
-                    tokens_str = write_match.group(1).replace(",", "")
-                    tokens = int(tokens_str)
-
-                    cache_writes += 1
-                    total_cache_write_tokens += tokens
-
-    except Exception as e:
-        return {
-            "error": f"Failed to parse log file: {e}",
-            "total_requests": 0,
-            "cache_hits": 0,
-            "cache_writes": 0,
-            "total_savings": 0.0,
-        }
-
-    # Calculate metrics
-    cache_hit_rate = (
-        (cache_hits / total_requests * 100) if total_requests > 0 else 0.0
-    )
-
-    return {
-        "days_analyzed": days,
-        "log_file": str(log_file),
-        "total_requests": total_requests,
-        "cache_hits": cache_hits,
-        "cache_writes": cache_writes,
-        "cache_hit_rate": round(cache_hit_rate, 1),
-        "total_cache_read_tokens": total_cache_read_tokens,
-        "total_cache_write_tokens": total_cache_write_tokens,
-        "total_savings": round(total_savings, 4),
-        "avg_savings_per_hit": (
-            round(total_savings / cache_hits, 4) if cache_hits > 0 else 0.0
-        ),
-    }
-
-
-def _display_cache_report(stats: dict[str, Any], verbose: bool = False):
-    """Display formatted cache statistics report.
-
-    Args:
-        stats: Cache statistics dictionary
-        verbose: Show detailed breakdown
-    """
-    # Handle error cases
-    if "error" in stats:
-        print(f"⚠️  {stats['error']}")
-        if "message" in stats:
-            print(f"   {stats['message']}")
-        return
-
-    # Summary section
-    print("=" * 60)
-    print("PROMPT CACHING PERFORMANCE SUMMARY")
-    print("=" * 60)
-    print(f"Analysis Period: Last {stats['days_analyzed']} days")
-    print(f"Log File: {stats['log_file']}")
-    print()
-
-    # Key metrics
-    print("📊 Key Metrics:")
-    print(f"  Total API Requests: {stats['total_requests']:,}")
-    print(f"  Cache Hits: {stats['cache_hits']:,}")
-    print(f"  Cache Writes: {stats['cache_writes']:,}")
-    print(f"  Cache Hit Rate: {stats['cache_hit_rate']}%")
-    print()
-
-    # Cost savings
-    print("💰 Cost Savings:")
-    print(f"  Total Saved: ${stats['total_savings']:.4f}")
-    if stats['cache_hits'] > 0:
-        print(f"  Avg Savings per Hit: ${stats['avg_savings_per_hit']:.4f}")
-    print()
-
-    # Token metrics (verbose mode)
-    if verbose:
-        print("🔢 Token Metrics:")
-        print(f"  Cache Read Tokens: {stats['total_cache_read_tokens']:,}")
-        print(f"  Cache Write Tokens: {stats['total_cache_write_tokens']:,}")
-        print()
-
-    # Performance assessment
-    hit_rate = stats['cache_hit_rate']
-    print("📈 Performance Assessment:")
-    if hit_rate >= 50:
-        print("  ✅ EXCELLENT - Cache is working effectively")
-        print("     Your workflows are benefiting from prompt caching")
-    elif hit_rate >= 30:
-        print("  ✓ GOOD - Cache is providing moderate benefits")
-        print("     Consider structuring prompts for better cache reuse")
-    elif hit_rate >= 10:
-        print("  ⚠️  LOW - Cache hit rate could be improved")
-        print("     Review your workflow patterns for optimization")
-    else:
-        print("  ❌ VERY LOW - Cache is not being utilized effectively")
-        print("     Consider enabling prompt caching or restructuring prompts")
-    print()
-
-    # Recommendations
-    if stats['total_requests'] < 10:
-        print("ℹ️  Note: Limited data available. Run more workflows for accurate stats.")
-    elif hit_rate < 30:
-        print("💡 Recommendations:")
-        print("  1. Reuse system prompts across workflow steps")
-        print("  2. Structure large context (docs, code) for caching")
-        print("  3. Cache TTL is 5 minutes - batch related requests")
-        print("  4. Enable use_prompt_caching=True in AnthropicProvider")
-
-    print("=" * 60)
-
-
-def cmd_cache_clear(args):
-    """Clear cached data (placeholder for future implementation).
-
-    Args:
-        args: Namespace object from argparse
-
-    Returns:
-        None: Prints status message
-    """
-    print("\n⚠️  Cache clearing not implemented.")
-    print("Anthropic's cache has a 5-minute TTL and is server-side.")
-    print("Wait 5 minutes for cache to expire naturally.\n")