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

empathy_os/vscode_bridge 2.py

@@ -1,173 +0,0 @@
-"""VS Code Extension Bridge
-
-Provides functions to write data that the VS Code extension can pick up.
-Enables Claude Code CLI output to appear in VS Code webview panels.
-
-Copyright 2026 Smart-AI-Memory
-Licensed under Fair Source License 0.9
-"""
-
-import json
-from dataclasses import asdict, dataclass
-from datetime import datetime
-from pathlib import Path
-from typing import Any
-
-
-@dataclass
-class ReviewFinding:
-    """A code review finding."""
-
-    id: str
-    file: str
-    line: int
-    severity: str  # 'critical' | 'high' | 'medium' | 'low' | 'info'
-    category: str  # 'security' | 'performance' | 'maintainability' | 'style' | 'correctness'
-    message: str
-    column: int = 1
-    details: str | None = None
-    recommendation: str | None = None
-
-
-@dataclass
-class CodeReviewResult:
-    """Code review results for VS Code bridge."""
-
-    findings: list[dict[str, Any]]
-    summary: dict[str, Any]
-    verdict: str  # 'approve' | 'approve_with_suggestions' | 'request_changes' | 'reject'
-    security_score: int
-    formatted_report: str
-    model_tier_used: str
-    timestamp: str
-
-
-def get_empathy_dir() -> Path:
-    """Get the .empathy directory, creating if needed."""
-    empathy_dir = Path(".empathy")
-    empathy_dir.mkdir(exist_ok=True)
-    return empathy_dir
-
-
-def write_code_review_results(
-    findings: list[dict[str, Any]] | None = None,
-    summary: dict[str, Any] | None = None,
-    verdict: str = "approve_with_suggestions",
-    security_score: int = 85,
-    formatted_report: str = "",
-    model_tier_used: str = "capable",
-) -> Path:
-    """Write code review results for VS Code extension to pick up.
-
-    Args:
-        findings: List of finding dicts with keys: id, file, line, severity, category, message
-        summary: Summary dict with keys: total_findings, by_severity, by_category, files_affected
-        verdict: One of 'approve', 'approve_with_suggestions', 'request_changes', 'reject'
-        security_score: 0-100 score
-        formatted_report: Markdown formatted report
-        model_tier_used: 'cheap', 'capable', or 'premium'
-
-    Returns:
-        Path to the written file
-    """
-    findings = findings or []
-
-    # Build summary if not provided
-    if summary is None:
-        by_severity: dict[str, int] = {}
-        by_category: dict[str, int] = {}
-        files_affected: set[str] = set()
-
-        for f in findings:
-            sev = f.get("severity", "info")
-            cat = f.get("category", "correctness")
-            by_severity[sev] = by_severity.get(sev, 0) + 1
-            by_category[cat] = by_category.get(cat, 0) + 1
-            if f.get("file"):
-                files_affected.add(f["file"])
-
-        summary = {
-            "total_findings": len(findings),
-            "by_severity": by_severity,
-            "by_category": by_category,
-            "files_affected": list(files_affected),
-        }
-
-    result = CodeReviewResult(
-        findings=findings,
-        summary=summary,
-        verdict=verdict,
-        security_score=security_score,
-        formatted_report=formatted_report,
-        model_tier_used=model_tier_used,
-        timestamp=datetime.now().isoformat(),
-    )
-
-    output_path = get_empathy_dir() / "code-review-results.json"
-
-    with open(output_path, "w") as f:
-        json.dump(asdict(result), f, indent=2)
-
-    return output_path
-
-
-def write_pr_review_results(
-    pr_number: int | str,
-    title: str,
-    findings: list[dict[str, Any]],
-    verdict: str = "approve_with_suggestions",
-    summary_text: str = "",
-) -> Path:
-    """Write PR review results for VS Code extension.
-
-    Convenience wrapper for PR reviews from GitHub.
-
-    Args:
-        pr_number: The PR number
-        title: PR title
-        findings: List of review findings
-        verdict: Review verdict
-        summary_text: Summary of the review
-
-    Returns:
-        Path to the written file
-    """
-    formatted_report = f"""## PR #{pr_number}: {title}
-
-{summary_text}
-
-### Findings ({len(findings)})
-
-"""
-    for f in findings:
-        formatted_report += f"- **{f.get('severity', 'info').upper()}** [{f.get('file', 'unknown')}:{f.get('line', 0)}]: {f.get('message', '')}\n"
-
-    return write_code_review_results(
-        findings=findings,
-        verdict=verdict,
-        formatted_report=formatted_report,
-        model_tier_used="capable",
-    )
-
-
-# Quick helper for Claude Code to call
-def send_to_vscode(
-    message: str,
-    findings: list[dict[str, Any]] | None = None,
-    verdict: str = "approve_with_suggestions",
-) -> str:
-    """Quick helper to send review results to VS Code.
-
-    Usage in Claude Code:
-        from empathy_os.vscode_bridge import send_to_vscode
-        send_to_vscode("Review complete", findings=[...])
-
-    Returns:
-        Confirmation message
-    """
-    path = write_code_review_results(
-        findings=findings or [],
-        formatted_report=message,
-        verdict=verdict,
-    )
-    return f"Results written to {path} - VS Code will update automatically"

empathy_os/workflows/progressive/__init__ 2.py

@@ -1,92 +0,0 @@
-"""Progressive tier escalation system for cost-efficient, quality-driven workflows.
-
-This module implements automatic model tier escalation (cheap → capable → premium)
-based on failure analysis and quality metrics. Key features:
-
-- Multi-signal failure detection (syntax, execution, coverage, confidence)
-- Composite Quality Score (CQS) for objective quality measurement
-- LLM-guided retry logic with stagnation detection
-- Meta-orchestration with dynamic agent team creation
-- Cost management with budget controls and approval prompts
-- Comprehensive observability and reporting
-
-Usage:
-    from empathy_os.workflows.progressive import (
-        ProgressiveWorkflow,
-        EscalationConfig,
-        Tier,
-        FailureAnalysis
-    )
-
-    # Configure escalation
-    config = EscalationConfig(
-        enabled=True,
-        max_cost=10.00,
-        auto_approve_under=5.00
-    )
-
-    # Create workflow
-    workflow = ProgressiveTestGenWorkflow(config)
-    result = workflow.execute(target_file="app.py")
-
-    # View report
-    print(result.generate_report())
-
-Version: 4.1.0
-Author: Empathy Framework Team
-"""
-
-from empathy_os.workflows.progressive.core import (
-    EscalationConfig,
-    FailureAnalysis,
-    ProgressiveWorkflowResult,
-    Tier,
-    TierResult,
-)
-from empathy_os.workflows.progressive.orchestrator import (
-    MetaOrchestrator,
-)
-from empathy_os.workflows.progressive.telemetry import (
-    ProgressiveTelemetry,
-)
-from empathy_os.workflows.progressive.test_gen import (
-    ProgressiveTestGenWorkflow,
-    calculate_coverage,
-    execute_test_file,
-)
-from empathy_os.workflows.progressive.workflow import (
-    BudgetExceededError,
-    ProgressiveWorkflow,
-    UserCancelledError,
-)
-
-__all__ = [
-    # Enums
-    "Tier",
-
-    # Core data structures
-    "FailureAnalysis",
-    "TierResult",
-    "ProgressiveWorkflowResult",
-    "EscalationConfig",
-
-    # Base classes
-    "ProgressiveWorkflow",
-    "MetaOrchestrator",
-
-    # Telemetry
-    "ProgressiveTelemetry",
-
-    # Exceptions
-    "BudgetExceededError",
-    "UserCancelledError",
-
-    # Workflows
-    "ProgressiveTestGenWorkflow",
-
-    # Utilities
-    "execute_test_file",
-    "calculate_coverage",
-]
-
-__version__ = "4.1.1"

empathy_os/workflows/progressive/cli 2.py

@@ -1,242 +0,0 @@
-"""CLI commands for progressive workflow management.
-
-Provides commands for:
-- Listing saved results
-- Viewing detailed reports
-- Generating analytics
-- Cleaning up old results
-"""
-
-import argparse
-import sys
-
-from empathy_os.workflows.progressive.reports import (
-    cleanup_old_results,
-    format_cost_analytics_report,
-    generate_cost_analytics,
-    list_saved_results,
-    load_result_from_disk,
-)
-
-
-def cmd_list_results(args: argparse.Namespace) -> int:
-    """List all saved progressive workflow results.
-
-    Args:
-        args: Parsed command line arguments
-
-    Returns:
-        Exit code (0 for success)
-    """
-    storage_path = args.storage_path or ".empathy/progressive_runs"
-    results = list_saved_results(storage_path)
-
-    if not results:
-        print(f"No results found in {storage_path}")
-        return 0
-
-    print(f"\n📋 Found {len(results)} progressive workflow results:\n")
-    print(f"{'Task ID':<40} {'Workflow':<15} {'Cost':<10} {'Savings':<12} {'Success'}")
-    print("─" * 90)
-
-    for result in results:
-        task_id = result.get("task_id", "unknown")
-        workflow = result.get("workflow", "unknown")[:14]
-        cost = result.get("total_cost", 0.0)
-        savings = result.get("cost_savings_percent", 0.0)
-        success = "✅" if result.get("success", False) else "❌"
-
-        print(f"{task_id:<40} {workflow:<15} ${cost:<9.2f} {savings:>6.1f}%      {success}")
-
-    print()
-    return 0
-
-
-def cmd_show_report(args: argparse.Namespace) -> int:
-    """Show detailed report for a specific task.
-
-    Args:
-        args: Parsed command line arguments
-
-    Returns:
-        Exit code (0 for success, 1 for error)
-    """
-    task_id = args.task_id
-    storage_path = args.storage_path or ".empathy/progressive_runs"
-
-    try:
-        result_data = load_result_from_disk(task_id, storage_path)
-
-        if args.json:
-            import json
-            print(json.dumps(result_data, indent=2))
-        else:
-            # Show human-readable report
-            report = result_data.get("report", "")
-            if report:
-                print(report)
-            else:
-                print("No report found for this task")
-
-        return 0
-
-    except FileNotFoundError as e:
-        print(f"Error: {e}", file=sys.stderr)
-        return 1
-
-
-def cmd_analytics(args: argparse.Namespace) -> int:
-    """Show cost optimization analytics.
-
-    Args:
-        args: Parsed command line arguments
-
-    Returns:
-        Exit code (0 for success)
-    """
-    storage_path = args.storage_path or ".empathy/progressive_runs"
-    analytics = generate_cost_analytics(storage_path)
-
-    if analytics["total_runs"] == 0:
-        print(f"No results found in {storage_path}")
-        return 0
-
-    if args.json:
-        import json
-        print(json.dumps(analytics, indent=2))
-    else:
-        report = format_cost_analytics_report(analytics)
-        print(report)
-
-    return 0
-
-
-def cmd_cleanup(args: argparse.Namespace) -> int:
-    """Clean up old progressive workflow results.
-
-    Args:
-        args: Parsed command line arguments
-
-    Returns:
-        Exit code (0 for success)
-    """
-    storage_path = args.storage_path or ".empathy/progressive_runs"
-    retention_days = args.retention_days
-    dry_run = args.dry_run
-
-    deleted, retained = cleanup_old_results(
-        storage_path=storage_path,
-        retention_days=retention_days,
-        dry_run=dry_run
-    )
-
-    if dry_run:
-        print("\n🔍 Dry run mode - no files deleted\n")
-        print(f"Would delete: {deleted} results older than {retention_days} days")
-        print(f"Would retain: {retained} recent results")
-    else:
-        print("\n🗑️  Cleanup complete\n")
-        print(f"Deleted: {deleted} results older than {retention_days} days")
-        print(f"Retained: {retained} recent results")
-
-    return 0
-
-
-def create_parser() -> argparse.ArgumentParser:
-    """Create argument parser for progressive CLI.
-
-    Returns:
-        Configured argument parser
-    """
-    parser = argparse.ArgumentParser(
-        prog="empathy progressive",
-        description="Manage progressive tier escalation workflows"
-    )
-
-    parser.add_argument(
-        "--storage-path",
-        type=str,
-        default=None,
-        help="Custom storage path (default: .empathy/progressive_runs)"
-    )
-
-    subparsers = parser.add_subparsers(dest="command", help="Available commands")
-
-    # List command
-    list_parser = subparsers.add_parser(
-        "list",
-        help="List all saved progressive workflow results"
-    )
-    list_parser.set_defaults(func=cmd_list_results)
-
-    # Show command
-    show_parser = subparsers.add_parser(
-        "show",
-        help="Show detailed report for a specific task"
-    )
-    show_parser.add_argument(
-        "task_id",
-        type=str,
-        help="Task ID to display"
-    )
-    show_parser.add_argument(
-        "--json",
-        action="store_true",
-        help="Output in JSON format"
-    )
-    show_parser.set_defaults(func=cmd_show_report)
-
-    # Analytics command
-    analytics_parser = subparsers.add_parser(
-        "analytics",
-        help="Show cost optimization analytics"
-    )
-    analytics_parser.add_argument(
-        "--json",
-        action="store_true",
-        help="Output in JSON format"
-    )
-    analytics_parser.set_defaults(func=cmd_analytics)
-
-    # Cleanup command
-    cleanup_parser = subparsers.add_parser(
-        "cleanup",
-        help="Clean up old progressive workflow results"
-    )
-    cleanup_parser.add_argument(
-        "--retention-days",
-        type=int,
-        default=30,
-        help="Number of days to retain results (default: 30)"
-    )
-    cleanup_parser.add_argument(
-        "--dry-run",
-        action="store_true",
-        help="Show what would be deleted without actually deleting"
-    )
-    cleanup_parser.set_defaults(func=cmd_cleanup)
-
-    return parser
-
-
-def main(argv: list[str] | None = None) -> int:
-    """Main entry point for progressive CLI.
-
-    Args:
-        argv: Command line arguments (defaults to sys.argv[1:])
-
-    Returns:
-        Exit code
-    """
-    parser = create_parser()
-    args = parser.parse_args(argv)
-
-    if not hasattr(args, "func"):
-        parser.print_help()
-        return 1
-
-    return args.func(args)
-
-
-if __name__ == "__main__":
-    sys.exit(main())