attune-ai 2.0.0__py3-none-any.whl

attune/cli/commands/routing.py

@@ -0,0 +1,285 @@
+"""CLI commands for adaptive model routing statistics.
+
+Provides commands to analyze model routing performance and get tier upgrade
+recommendations based on historical telemetry data.
+
+Copyright 2025 Smart-AI-Memory
+Licensed under Fair Source License 0.9
+"""
+
+import logging
+from typing import Any
+
+from attune.models import AdaptiveModelRouter
+from attune.telemetry import UsageTracker
+
+logger = logging.getLogger(__name__)
+
+
+def cmd_routing_stats(args: Any) -> int:
+    """Show routing statistics for a workflow.
+
+    Args:
+        args: Arguments with workflow, stage (optional), days
+
+    Returns:
+        0 on success, 1 on error
+    """
+    try:
+        # Get telemetry and router
+        tracker = UsageTracker.get_instance()
+        router = AdaptiveModelRouter(telemetry=tracker)
+
+        # Get routing stats
+        stats = router.get_routing_stats(
+            workflow=args.workflow,
+            stage=args.stage if hasattr(args, "stage") and args.stage else None,
+            days=args.days,
+        )
+
+        if stats["total_calls"] == 0:
+            print(f"❌ No data found for workflow '{args.workflow}'")
+            print(f"   (searched last {args.days} days)")
+            return 1
+
+        # Display stats
+        print("\n" + "=" * 70)
+        print(f"ADAPTIVE ROUTING STATISTICS - {stats['workflow']}")
+        if stats["stage"] != "all":
+            print(f"Stage: {stats['stage']}")
+        print("=" * 70)
+
+        print(f"\n📊 Overview (Last {stats['days_analyzed']} days)")
+        print(f"  Total calls: {stats['total_calls']:,}")
+        print(f"  Average cost: ${stats['avg_cost']:.4f}")
+        print(f"  Average success rate: {stats['avg_success_rate']:.1%}")
+        print(f"  Models used: {len(stats['models_used'])}")
+
+        # Per-model performance
+        print("\n📈 Per-Model Performance")
+        print("-" * 70)
+
+        for model in stats["models_used"]:
+            perf = stats["performance_by_model"][model]
+            print(f"\n  {model}:")
+            print(f"    Calls: {perf['calls']:,}")
+            print(f"    Success rate: {perf['success_rate']:.1%}")
+            print(f"    Avg cost: ${perf['avg_cost']:.4f}")
+            print(f"    Avg latency: {perf['avg_latency_ms']:.0f}ms")
+
+            # Quality score calculation (from AdaptiveModelRouter)
+            quality_score = (perf["success_rate"] * 100) - (perf["avg_cost"] * 10)
+            print(f"    Quality score: {quality_score:.2f}")
+
+        # Recommendations
+        print("\n💡 Recommendations")
+        print("-" * 70)
+
+        # Find best model
+        best_model = max(
+            stats["performance_by_model"].items(),
+            key=lambda x: (x[1]["success_rate"] * 100) - (x[1]["avg_cost"] * 10),
+        )
+
+        print(f"  Best model: {best_model[0]}")
+        print(f"    ({best_model[1]['success_rate']:.1%} success, ${best_model[1]['avg_cost']:.4f}/call)")
+
+        # Cost savings potential
+        if len(stats["models_used"]) > 1:
+            cheapest = min(
+                stats["performance_by_model"].items(),
+                key=lambda x: x[1]["avg_cost"],
+            )
+            most_expensive = max(
+                stats["performance_by_model"].items(),
+                key=lambda x: x[1]["avg_cost"],
+            )
+
+            if cheapest[0] != most_expensive[0]:
+                savings_per_call = most_expensive[1]["avg_cost"] - cheapest[1]["avg_cost"]
+                print("\n  💰 Potential savings:")
+                print(f"    Using {cheapest[0]} instead of {most_expensive[0]}")
+                print(f"    ${savings_per_call:.4f} per call")
+                if stats["total_calls"] > 0:
+                    weekly_calls = (stats["total_calls"] / stats["days_analyzed"]) * 7
+                    weekly_savings = savings_per_call * weekly_calls
+                    print(f"    ~${weekly_savings:.2f}/week potential")
+
+        return 0
+
+    except Exception as e:
+        logger.exception("Failed to get routing stats")
+        print(f"❌ Error: {e}")
+        return 1
+
+
+def cmd_routing_check(args: Any) -> int:
+    """Check if tier upgrades are recommended for workflows.
+
+    Args:
+        args: Arguments with workflow (or --all), stage (optional)
+
+    Returns:
+        0 on success, 1 on error
+    """
+    try:
+        # Get telemetry and router
+        tracker = UsageTracker.get_instance()
+        router = AdaptiveModelRouter(telemetry=tracker)
+
+        print("\n" + "=" * 70)
+        print("ADAPTIVE ROUTING - TIER UPGRADE RECOMMENDATIONS")
+        print("=" * 70)
+
+        if hasattr(args, "all") and args.all:
+            # Check all workflows
+            stats = tracker.get_stats(days=args.days)
+            workflows = list(stats["by_workflow"].keys())
+
+            if not workflows:
+                print("\n❌ No workflow data found")
+                return 1
+
+            print(f"\nChecking {len(workflows)} workflows (last {args.days} days)...\n")
+
+            upgrades_needed = []
+            upgrades_ok = []
+
+            for workflow_name in workflows:
+                should_upgrade, reason = router.recommend_tier_upgrade(
+                    workflow=workflow_name, stage=None
+                )
+
+                if should_upgrade:
+                    upgrades_needed.append((workflow_name, reason))
+                else:
+                    upgrades_ok.append((workflow_name, reason))
+
+            # Show workflows needing upgrades
+            if upgrades_needed:
+                print(f"⚠️  {len(upgrades_needed)} workflow(s) need tier upgrade:")
+                print("-" * 70)
+                for workflow_name, reason in upgrades_needed:
+                    print(f"  • {workflow_name}")
+                    print(f"    {reason}")
+                print()
+
+            # Show workflows performing well
+            if upgrades_ok:
+                print(f"✓ {len(upgrades_ok)} workflow(s) performing well:")
+                print("-" * 70)
+                for workflow_name, reason in upgrades_ok:
+                    print(f"  • {workflow_name}: {reason}")
+                print()
+
+            # Summary
+            if upgrades_needed:
+                print("💡 Recommendation:")
+                print("   Enable adaptive routing to automatically upgrade tiers:")
+                print("   workflow = MyWorkflow(enable_adaptive_routing=True)")
+                return 0
+            else:
+                print("✓ All workflows performing well - no upgrades needed")
+                return 0
+
+        else:
+            # Check specific workflow
+            workflow_name = args.workflow
+
+            should_upgrade, reason = router.recommend_tier_upgrade(
+                workflow=workflow_name,
+                stage=args.stage if hasattr(args, "stage") and args.stage else None,
+            )
+
+            print(f"\nWorkflow: {workflow_name}")
+            if hasattr(args, "stage") and args.stage:
+                print(f"Stage: {args.stage}")
+            print(f"Analysis period: Last {args.days} days")
+            print()
+
+            if should_upgrade:
+                print("⚠️  TIER UPGRADE RECOMMENDED")
+                print(f"   {reason}")
+                print()
+                print("💡 Action:")
+                print("   1. Enable adaptive routing:")
+                print("      workflow = MyWorkflow(enable_adaptive_routing=True)")
+                print("   2. Or manually upgrade tier in workflow config")
+                return 0
+            else:
+                print("✓ NO UPGRADE NEEDED")
+                print(f"   {reason}")
+                return 0
+
+    except Exception as e:
+        logger.exception("Failed to check routing recommendations")
+        print(f"❌ Error: {e}")
+        return 1
+
+
+def cmd_routing_models(args: Any) -> int:
+    """Show model performance comparison.
+
+    Args:
+        args: Arguments with provider, days
+
+    Returns:
+        0 on success, 1 on error
+    """
+    try:
+        # Get telemetry
+        tracker = UsageTracker.get_instance()
+
+        # Get recent entries
+        entries = tracker.get_recent_entries(limit=100000, days=args.days)
+
+        if args.provider:
+            entries = [e for e in entries if e.get("provider") == args.provider]
+
+        if not entries:
+            print(f"❌ No data found for provider '{args.provider}'")
+            return 1
+
+        # Group by model
+        by_model: dict[str, list] = {}
+        for entry in entries:
+            model = entry["model"]
+            if model not in by_model:
+                by_model[model] = []
+            by_model[model].append(entry)
+
+        print("\n" + "=" * 70)
+        print(f"MODEL PERFORMANCE COMPARISON - {args.provider.upper()}")
+        print(f"Last {args.days} days")
+        print("=" * 70)
+
+        # Sort by total calls
+        models_sorted = sorted(by_model.items(), key=lambda x: len(x[1]), reverse=True)
+
+        print(f"\n📊 {len(models_sorted)} model(s) used\n")
+
+        for model, model_entries in models_sorted:
+            total = len(model_entries)
+            successes = sum(1 for e in model_entries if e.get("success", True))
+            success_rate = successes / total
+
+            avg_cost = sum(e.get("cost", 0.0) for e in model_entries) / total
+            avg_latency = sum(e.get("duration_ms", 0) for e in model_entries) / total
+
+            # Quality score
+            quality_score = (success_rate * 100) - (avg_cost * 10)
+
+            print(f"  {model}")
+            print(f"    Calls: {total:,}")
+            print(f"    Success rate: {success_rate:.1%}")
+            print(f"    Avg cost: ${avg_cost:.4f}")
+            print(f"    Avg latency: {avg_latency:.0f}ms")
+            print(f"    Quality score: {quality_score:.2f}")
+            print()
+
+        return 0
+
+    except Exception as e:
+        logger.exception("Failed to get model performance")
+        print(f"❌ Error: {e}")
+        return 1

attune/cli/commands/setup.py

@@ -0,0 +1,96 @@
+"""Setup commands for initialization and validation.
+
+Copyright 2025 Smart-AI-Memory
+Licensed under Fair Source License 0.9
+"""
+
+import sys
+
+from attune.config import EmpathyConfig, _validate_file_path, load_config
+from attune.logging_config import get_logger
+
+logger = get_logger(__name__)
+
+
+def cmd_init(args):
+    """Initialize a new Empathy Framework project.
+
+    Creates a configuration file with sensible defaults.
+
+    Args:
+        args: Namespace object from argparse with attributes:
+            - format (str): Output format ('yaml' or 'json').
+            - output (str | None): Output file path.
+
+    Returns:
+        None: Creates configuration file at specified path.
+
+    Raises:
+        ValueError: If output path is invalid or unsafe.
+    """
+    config_format = args.format
+    output_path = args.output or f"attune.config.{config_format}"
+
+    # Validate output path to prevent path traversal attacks
+    validated_path = _validate_file_path(output_path)
+
+    logger.info(f"Initializing new Empathy Framework project with format: {config_format}")
+
+    # Create default config
+    config = EmpathyConfig()
+
+    # Save to file
+    if config_format == "yaml":
+        config.to_yaml(str(validated_path))
+        logger.info(f"Created YAML configuration file: {output_path}")
+        logger.info(f"✓ Created YAML configuration: {output_path}")
+    elif config_format == "json":
+        config.to_json(str(validated_path))
+        logger.info(f"Created JSON configuration file: {validated_path}")
+        logger.info(f"✓ Created JSON configuration: {validated_path}")
+
+    logger.info("\nNext steps:")
+    logger.info(f"  1. Edit {output_path} to customize settings")
+    logger.info("  2. Use 'empathy run' to start using the framework")
+
+
+def cmd_validate(args):
+    """Validate a configuration file.
+
+    Loads and validates the specified configuration file.
+
+    Args:
+        args: Namespace object from argparse with attributes:
+            - config (str): Path to configuration file to validate.
+
+    Returns:
+        None: Prints validation result. Exits with code 1 on failure.
+    """
+    filepath = args.config
+    logger.info(f"Validating configuration file: {filepath}")
+
+    try:
+        config = load_config(filepath=filepath, use_env=False)
+        config.validate()
+        logger.info(f"Configuration validation successful: {filepath}")
+        logger.info(f"✓ Configuration valid: {filepath}")
+        logger.info(f"\n  User ID: {config.user_id}")
+        logger.info(f"  Target Level: {config.target_level}")
+        logger.info(f"  Confidence Threshold: {config.confidence_threshold}")
+        logger.info(f"  Persistence Backend: {config.persistence_backend}")
+        logger.info(f"  Metrics Enabled: {config.metrics_enabled}")
+    except (OSError, FileNotFoundError) as e:
+        # Config file not found or cannot be read
+        logger.error(f"Configuration file error: {e}")
+        logger.error(f"✗ Cannot read configuration file: {e}")
+        sys.exit(1)
+    except ValueError as e:
+        # Invalid configuration values
+        logger.error(f"Configuration validation failed: {e}")
+        logger.error(f"✗ Configuration invalid: {e}")
+        sys.exit(1)
+    except Exception as e:
+        # Unexpected errors during config validation
+        logger.exception(f"Unexpected error validating configuration: {e}")
+        logger.error(f"✗ Configuration invalid: {e}")
+        sys.exit(1)

attune/cli/commands/status.py

@@ -0,0 +1,235 @@
+"""Status and health check commands for the CLI.
+
+Copyright 2025 Smart-AI-Memory
+Licensed under Fair Source License 0.9
+"""
+
+import asyncio
+
+
+def cmd_status(args):
+    """Session status assistant - prioritized project status report.
+
+    Collects and displays project status including patterns, git context,
+    and health metrics with priority scoring.
+
+    Args:
+        args: Namespace object from argparse with attributes:
+            - patterns_dir (str): Path to patterns directory (default: ./patterns).
+            - project_root (str): Project root directory (default: .).
+            - inactivity (int): Minutes of inactivity before showing status.
+            - full (bool): If True, show all items without limit.
+            - json (bool): If True, output as JSON format.
+            - select (int | None): Select specific item for action prompt.
+            - force (bool): If True, show status even with recent activity.
+
+    Returns:
+        None: Prints prioritized status report or JSON output.
+    """
+    from attune_llm.session_status import SessionStatusCollector
+
+    config = {"inactivity_minutes": args.inactivity}
+    collector = SessionStatusCollector(
+        patterns_dir=args.patterns_dir,
+        project_root=args.project_root,
+        config=config,
+    )
+
+    # Check if should show (unless forced)
+    if not args.force and not collector.should_show():
+        print("No status update needed (recent activity detected).")
+        print("Use --force to show status anyway.")
+        return
+
+    # Collect status
+    status = collector.collect()
+
+    # Handle selection
+    if args.select:
+        prompt = collector.get_action_prompt(status, args.select)
+        if prompt:
+            print(f"\nAction prompt for selection {args.select}:\n")
+            print(prompt)
+        else:
+            print(f"Invalid selection: {args.select}")
+        return
+
+    # Output
+    if args.json:
+        print(collector.format_json(status))
+    else:
+        max_items = None if args.full else 5
+        print()
+        print(collector.format_output(status, max_items=max_items))
+        print()
+
+    # Record interaction
+    collector.record_interaction()
+
+
+def cmd_review(args):
+    """Pattern-based code review against historical bugs.
+
+    Note: This command has been deprecated. The underlying workflow module
+    has been removed. Use 'empathy workflow run bug-predict' instead.
+
+    Args:
+        args: Namespace object from argparse.
+
+    Returns:
+        None: Prints deprecation message.
+    """
+    print("⚠️  The 'review' command has been deprecated.")
+    print()
+    print("The CodeReviewWorkflow module has been removed.")
+    print("Please use one of these alternatives:")
+    print()
+    print("  empathy workflow run bug-predict    # Scan for risky patterns")
+    print("  ruff check <files>                  # Fast linting")
+    print("  bandit -r <path>                    # Security scanning")
+    print()
+
+
+def cmd_health(args):
+    """Code health assistant - run health checks and auto-fix issues.
+
+    Runs comprehensive health checks including linting, type checking,
+    and formatting with optional auto-fix capability.
+
+    Args:
+        args: Namespace object from argparse with attributes:
+            - check (str | None): Specific check to run (lint/type/format/test).
+            - deep (bool): If True, run comprehensive checks.
+            - fix (bool): If True, auto-fix issues where possible.
+            - threshold (str): Severity threshold for issues.
+            - project_root (str): Project root directory.
+            - patterns_dir (str): Path to patterns directory.
+            - details (bool): If True, show detailed issue list.
+            - compare (str | None): Compare against historical baseline.
+            - export (str | None): Export results to file.
+            - json (bool): If True, output as JSON format.
+
+    Returns:
+        None: Prints health check results and optionally fixes issues.
+    """
+    from attune_llm.code_health import (
+        AutoFixer,
+        CheckCategory,
+        HealthCheckRunner,
+        HealthTrendTracker,
+        format_health_output,
+    )
+
+    runner = HealthCheckRunner(
+        project_root=args.project_root,
+    )
+
+    # Determine what checks to run
+    if args.check:
+        # Run specific check
+        try:
+            category = CheckCategory(args.check)
+            report_future = runner.run_check(category)
+            result = asyncio.run(report_future)
+            # Create a minimal report with just this result
+            from attune_llm.code_health import HealthReport
+
+            report = HealthReport(project_root=args.project_root)
+            report.add_result(result)
+        except ValueError:
+            print(f"Unknown check category: {args.check}")
+            print(f"Available: {', '.join(c.value for c in CheckCategory)}")
+            return
+    elif args.deep:
+        # Run all checks
+        print("Running comprehensive health check...\n")
+        report = asyncio.run(runner.run_all())
+    else:
+        # Run quick checks (default)
+        report = asyncio.run(runner.run_quick())
+
+    # Handle fix mode
+    if args.fix:
+        fixer = AutoFixer()
+
+        if args.dry_run:
+            # Preview only
+            fixes = fixer.preview_fixes(report)
+            if fixes:
+                print("Would fix the following issues:\n")
+                for fix in fixes:
+                    safe_indicator = " (safe)" if fix["safe"] else " (needs confirmation)"
+                    print(f"  [{fix['category']}] {fix['file']}")
+                    print(f"    {fix['issue']}")
+                    print(f"    Command: {fix['fix_command']}{safe_indicator}")
+                    print()
+            else:
+                print("No auto-fixable issues found.")
+            return
+
+        # Apply fixes
+        if args.check:
+            try:
+                category = CheckCategory(args.check)
+                result = asyncio.run(fixer.fix_category(report, category))
+            except ValueError:
+                result = {"fixed": [], "skipped": [], "failed": []}
+        else:
+            result = asyncio.run(fixer.fix_all(report, interactive=args.interactive))
+
+        # Report fix results
+        if result["fixed"]:
+            print(f"✓ Fixed {len(result['fixed'])} issue(s)")
+            for fix in result["fixed"][:5]:
+                print(f"  - {fix['file_path']}: {fix['message']}")
+            if len(result["fixed"]) > 5:
+                print(f"  ... and {len(result['fixed']) - 5} more")
+
+        if result["skipped"]:
+            if args.interactive:
+                print(f"\n⚠ Skipped {len(result['skipped'])} issue(s) (could not auto-fix)")
+            else:
+                print(
+                    f"\n⚠ Skipped {len(result['skipped'])} issue(s) (use --interactive to review)",
+                )
+
+        if result["failed"]:
+            print(f"\n✗ Failed to fix {len(result['failed'])} issue(s)")
+
+        return
+
+    # Handle trends
+    if args.trends:
+        tracker = HealthTrendTracker(project_root=args.project_root)
+        trends = tracker.get_trends(days=args.trends)
+
+        print(f"📈 Health Trends ({trends['period_days']} days)\n")
+        print(f"Average Score: {trends['average_score']}/100")
+        print(f"Trend: {trends['trend_direction']} ({trends['score_change']:+d})")
+
+        if trends["data_points"]:
+            print("\nRecent scores:")
+            for point in trends["data_points"][:7]:
+                print(f"  {point['date']}: {point['score']}/100")
+
+        hotspots = tracker.identify_hotspots()
+        if hotspots:
+            print("\n🔥 Hotspots (files with recurring issues):")
+            for spot in hotspots[:5]:
+                print(f"  {spot['file']}: {spot['issue_count']} issues")
+
+        return
+
+    # Output report
+    if args.json:
+        import json
+
+        print(json.dumps(report.to_dict(), indent=2, default=str))
+    else:
+        level = 3 if args.full else (2 if args.details else 1)
+        print(format_health_output(report, level=level))
+
+    # Record to trend history
+    if not args.check:  # Only record full runs
+        tracker = HealthTrendTracker(project_root=args.project_root)
+        tracker.record_check(report)