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

empathy_os/cli/commands/orchestrate.py

@@ -1,184 +0,0 @@
-"""Orchestration commands for meta-workflows.
-
-Copyright 2025 Smart-AI-Memory
-Licensed under Fair Source License 0.9
-"""
-
-import asyncio
-import json
-
-from empathy_os.logging_config import get_logger
-
-logger = get_logger(__name__)
-
-
-def cmd_orchestrate(args):
-    """Run meta-orchestration workflows.
-
-    Orchestrates teams of agents to accomplish complex tasks through
-    intelligent composition patterns.
-
-    Args:
-        args: Namespace object from argparse with attributes:
-            - workflow (str): Orchestration workflow name.
-            - path (str): Target path for orchestration.
-            - mode (str | None): Execution mode (e.g., 'daily', 'weekly', 'release').
-            - json (bool): If True, output as JSON format.
-            - dry_run (bool): If True, show plan without executing.
-            - verbose (bool): If True, show detailed output.
-
-    Returns:
-        int: 0 on success, 1 on failure.
-    """
-    from empathy_os.workflows.orchestrated_health_check import OrchestratedHealthCheckWorkflow
-    from empathy_os.workflows.orchestrated_release_prep import OrchestratedReleasePrepWorkflow
-
-    # Get workflow type
-    workflow_type = args.workflow
-
-    # Only print header in non-JSON mode
-    if not (hasattr(args, "json") and args.json):
-        print()
-        print("=" * 60)
-        print(f"  META-ORCHESTRATION: {workflow_type.upper()}")
-        print("=" * 60)
-        print()
-
-    if workflow_type == "release-prep":
-        # Release Preparation workflow
-        path = args.path or "."
-        quality_gates = {}
-
-        # Collect custom quality gates
-        if hasattr(args, "min_coverage") and args.min_coverage is not None:
-            quality_gates["min_coverage"] = args.min_coverage
-        if hasattr(args, "min_quality") and args.min_quality is not None:
-            quality_gates["min_quality_score"] = args.min_quality
-        if hasattr(args, "max_critical") and args.max_critical is not None:
-            quality_gates["max_critical_issues"] = args.max_critical
-
-        # Only print details in non-JSON mode
-        if not (hasattr(args, "json") and args.json):
-            print(f"  Project Path: {path}")
-            if quality_gates:
-                print(f"  Quality Gates: {quality_gates}")
-            print()
-            print("  🔍 Parallel Validation Agents:")
-            print("    • Security Auditor (vulnerability scan)")
-            print("    • Test Coverage Analyzer (gap analysis)")
-            print("    • Code Quality Reviewer (best practices)")
-            print("    • Documentation Writer (completeness)")
-            print()
-
-        # Create workflow
-        workflow = OrchestratedReleasePrepWorkflow(
-            quality_gates=quality_gates if quality_gates else None
-        )
-
-        try:
-            # Execute workflow
-            report = asyncio.run(workflow.execute(path=path))
-
-            # Display results
-            if hasattr(args, "json") and args.json:
-                print(json.dumps(report.to_dict(), indent=2))
-            else:
-                print(report.format_console_output())
-
-            # Return appropriate exit code
-            return 0 if report.approved else 1
-
-        except Exception as e:
-            print(f"  ❌ Error executing release prep workflow: {e}")
-            print()
-            logger.exception("Release prep workflow failed")
-            return 1
-
-    elif workflow_type == "test-coverage":
-        # Test Coverage Boost workflow - DISABLED in v4.0.0
-        print("  ⚠️  FEATURE DISABLED")
-        print("  " + "-" * 56)
-        print()
-        print("  The test-coverage workflow has been disabled in v4.0.0")
-        print("  due to poor quality (0% test pass rate).")
-        print()
-        print("  This feature is being redesigned and will return in a")
-        print("  future release with improved test generation quality.")
-        print()
-        print("  Available v4.0 workflows:")
-        print("    • health-check - Real-time codebase health analysis")
-        print("    • release-prep - Quality gate validation")
-        print()
-        return 1
-
-    elif workflow_type == "health-check":
-        # Health Check workflow
-        mode = args.mode or "daily"
-        project_root = args.project_root or "."
-        focus_area = getattr(args, "focus", None)
-
-        # Only print details in non-JSON mode
-        if not (hasattr(args, "json") and args.json):
-            print(f"  Mode: {mode.upper()}")
-            print(f"  Project Root: {project_root}")
-            if focus_area:
-                print(f"  Focus Area: {focus_area}")
-            print()
-
-            # Show agents for mode
-            mode_agents = {
-                "daily": ["Security", "Coverage", "Quality"],
-                "weekly": ["Security", "Coverage", "Quality", "Performance", "Documentation"],
-                "release": [
-                    "Security",
-                    "Coverage",
-                    "Quality",
-                    "Performance",
-                    "Documentation",
-                    "Architecture",
-                ],
-            }
-
-            print(f"  🔍 {mode.capitalize()} Check Agents:")
-            for agent in mode_agents.get(mode, []):
-                print(f"    • {agent}")
-            print()
-
-        # Create workflow
-        workflow = OrchestratedHealthCheckWorkflow(mode=mode, project_root=project_root)
-
-        try:
-            # Execute workflow
-            report = asyncio.run(workflow.execute())
-
-            # Display results
-            if hasattr(args, "json") and args.json:
-                print(json.dumps(report.to_dict(), indent=2))
-            else:
-                print(report.format_console_output())
-
-            # Return appropriate exit code (70+ is passing)
-            return 0 if report.overall_health_score >= 70 else 1
-
-        except Exception as e:
-            print(f"  ❌ Error executing health check workflow: {e}")
-            print()
-            logger.exception("Health check workflow failed")
-            return 1
-
-    else:
-        print(f"  ❌ Unknown workflow type: {workflow_type}")
-        print()
-        print("  Available workflows:")
-        print("    - release-prep: Release readiness validation (parallel agents)")
-        print("    - health-check: Project health assessment (daily/weekly/release modes)")
-        print()
-        print("  Note: test-coverage workflow disabled in v4.0.0 (being redesigned)")
-        print()
-        return 1
-
-    print()
-    print("=" * 60)
-    print()
-
-    return 0

empathy_os/cli/commands/patterns.py

@@ -1,207 +0,0 @@
-"""Pattern management commands for the CLI.
-
-Copyright 2025 Smart-AI-Memory
-Licensed under Fair Source License 0.9
-"""
-
-import sys
-
-from empathy_os.config import _validate_file_path
-from empathy_os.logging_config import get_logger
-from empathy_os.persistence import PatternPersistence
-
-logger = get_logger(__name__)
-
-
-def cmd_patterns_list(args):
-    """List patterns in a pattern library.
-
-    Args:
-        args: Namespace object from argparse with attributes:
-            - library (str): Path to pattern library file.
-            - format (str): Library format ('json' or 'sqlite').
-
-    Returns:
-        None: Prints pattern list to stdout. Exits with code 1 on failure.
-    """
-    filepath = args.library
-    format_type = args.format
-    logger.info(f"Listing patterns from library: {filepath} (format: {format_type})")
-
-    try:
-        if format_type == "json":
-            library = PatternPersistence.load_from_json(filepath)
-        elif format_type == "sqlite":
-            library = PatternPersistence.load_from_sqlite(filepath)
-        else:
-            logger.error(f"Unknown pattern library format: {format_type}")
-            logger.error(f"✗ Unknown format: {format_type}")
-            sys.exit(1)
-
-        logger.info(f"Loaded {len(library.patterns)} patterns from {filepath}")
-        logger.info(f"=== Pattern Library: {filepath} ===\n")
-        logger.info(f"Total patterns: {len(library.patterns)}")
-        logger.info(f"Total agents: {len(library.agent_contributions)}")
-
-        if library.patterns:
-            logger.info("\nPatterns:")
-            for pattern_id, pattern in library.patterns.items():
-                logger.info(f"\n  [{pattern_id}] {pattern.name}")
-                logger.info(f"    Agent: {pattern.agent_id}")
-                logger.info(f"    Type: {pattern.pattern_type}")
-                logger.info(f"    Confidence: {pattern.confidence:.2f}")
-                logger.info(f"    Usage: {pattern.usage_count}")
-                logger.info(f"    Success Rate: {pattern.success_rate:.2f}")
-    except FileNotFoundError:
-        logger.error(f"Pattern library not found: {filepath}")
-        logger.error(f"✗ Pattern library not found: {filepath}")
-        sys.exit(1)
-
-
-def cmd_patterns_export(args):
-    """Export patterns from one format to another.
-
-    Args:
-        args: Namespace object from argparse with attributes:
-            - input (str): Input file path.
-            - output (str): Output file path.
-            - input_format (str): Input format ('json' or 'sqlite').
-            - output_format (str): Output format ('json' or 'sqlite').
-
-    Returns:
-        None: Exports patterns to output file. Exits with code 1 on failure.
-
-    Raises:
-        ValueError: If output path is invalid or unsafe.
-    """
-    input_file = args.input
-    input_format = args.input_format
-    output_file = args.output
-    output_format = args.output_format
-
-    logger.info(f"Exporting patterns from {input_format} to {output_format}")
-
-    # Load from input format
-    try:
-        if input_format == "json":
-            library = PatternPersistence.load_from_json(input_file)
-        elif input_format == "sqlite":
-            library = PatternPersistence.load_from_sqlite(input_file)
-        else:
-            logger.error(f"Unknown input format: {input_format}")
-            logger.error(f"✗ Unknown input format: {input_format}")
-            sys.exit(1)
-
-        logger.info(f"Loaded {len(library.patterns)} patterns from {input_file}")
-        logger.info(f"✓ Loaded {len(library.patterns)} patterns from {input_file}")
-    except (OSError, FileNotFoundError) as e:
-        # Input file not found or cannot be read
-        logger.error(f"Pattern file error: {e}")
-        logger.error(f"✗ Cannot read pattern file: {e}")
-        sys.exit(1)
-    except (ValueError, KeyError) as e:
-        # Invalid pattern data format
-        logger.error(f"Pattern data error: {e}")
-        logger.error(f"✗ Invalid pattern data: {e}")
-        sys.exit(1)
-    except Exception as e:
-        # Unexpected errors loading patterns
-        logger.exception(f"Unexpected error loading patterns: {e}")
-        logger.error(f"✗ Failed to load patterns: {e}")
-        sys.exit(1)
-
-    # Validate output path
-    validated_output = _validate_file_path(output_file)
-
-    # Save to output format
-    try:
-        if output_format == "json":
-            PatternPersistence.save_to_json(library, str(validated_output))
-        elif output_format == "sqlite":
-            PatternPersistence.save_to_sqlite(library, str(validated_output))
-
-        logger.info(f"Saved {len(library.patterns)} patterns to {output_file}")
-        logger.info(f"✓ Saved {len(library.patterns)} patterns to {output_file}")
-    except (OSError, FileNotFoundError, PermissionError) as e:
-        # Cannot write output file
-        logger.error(f"Pattern file write error: {e}")
-        logger.error(f"✗ Cannot write pattern file: {e}")
-        sys.exit(1)
-    except Exception as e:
-        # Unexpected errors saving patterns
-        logger.exception(f"Unexpected error saving patterns: {e}")
-        logger.error(f"✗ Failed to save patterns: {e}")
-        sys.exit(1)
-
-
-def cmd_patterns_resolve(args):
-    """Resolve investigating bug patterns with root cause and fix.
-
-    Updates pattern status and adds resolution information.
-
-    Args:
-        args: Namespace object from argparse with attributes:
-            - pattern_id (str | None): Pattern ID to resolve.
-            - root_cause (str | None): Root cause description.
-            - fix (str | None): Fix description.
-            - fix_code (str | None): Code snippet of the fix.
-            - time (int | None): Resolution time in minutes.
-            - status (str): New status ('resolved', 'wont_fix', etc.).
-            - patterns_dir (str): Patterns directory path.
-            - commit (str | None): Related commit hash.
-
-    Returns:
-        None: Updates pattern and prints result. Exits with code 1 on failure.
-    """
-    from empathy_llm_toolkit.pattern_resolver import PatternResolver
-
-    resolver = PatternResolver(args.patterns_dir)
-
-    # If no bug_id, list investigating bugs
-    if not args.bug_id:
-        investigating = resolver.list_investigating()
-        if not investigating:
-            print("No bugs with 'investigating' status found.")
-            return
-
-        print(f"\nBugs needing resolution ({len(investigating)}):\n")
-        for bug in investigating:
-            print(f"  {bug.get('bug_id', 'unknown')}")
-            print(f"    Type: {bug.get('error_type', 'unknown')}")
-            print(f"    File: {bug.get('file_path', 'unknown')}")
-            msg = bug.get("error_message", "N/A")
-            print(f"    Message: {msg[:60]}..." if len(msg) > 60 else f"    Message: {msg}")
-            print()
-        return
-
-    # Validate required args
-    if not args.root_cause or not args.fix:
-        print("✗ --root-cause and --fix are required when resolving a bug")
-        print(
-            "  Example: empathy patterns resolve bug_123 --root-cause 'Null check' --fix 'Added ?.'",
-        )
-        sys.exit(1)
-
-    # Resolve the specified bug
-    success = resolver.resolve_bug(
-        bug_id=args.bug_id,
-        root_cause=args.root_cause,
-        fix_applied=args.fix,
-        fix_code=args.fix_code,
-        resolution_time_minutes=args.time or 0,
-        resolved_by=args.resolved_by or "@developer",
-    )
-
-    if success:
-        print(f"✓ Resolved: {args.bug_id}")
-
-        # Regenerate summary if requested
-        if not args.no_regenerate:
-            if resolver.regenerate_summary():
-                print("✓ Regenerated patterns_summary.md")
-            else:
-                print("⚠ Failed to regenerate summary")
-    else:
-        print(f"✗ Failed to resolve: {args.bug_id}")
-        print("  Use 'empathy patterns resolve' (no args) to list investigating bugs")
-        sys.exit(1)

empathy_os/cli/commands/profiling.py

@@ -1,198 +0,0 @@
-"""Profiling commands for Empathy Framework CLI.
-
-Performance profiling and memory analysis commands.
-
-Usage:
-    empathy profile memory-scan         # Scan for memory leaks
-    empathy profile memory-scan --json  # JSON output for CI
-    empathy profile memory-test         # Profile memory module
-
-Copyright 2025 Smart-AI-Memory
-Licensed under Fair Source License 0.9
-"""
-
-import subprocess
-import sys
-from pathlib import Path
-
-import typer
-from rich.console import Console
-
-console = Console()
-
-# Create the profile command group
-profile_app = typer.Typer(
-    name="profile",
-    help="Performance profiling and memory analysis",
-    no_args_is_help=True,
-)
-
-
-@profile_app.command("memory-scan")
-def memory_scan(
-    path: Path = typer.Argument(
-        Path("src"),
-        help="Directory to scan for memory issues",
-    ),
-    feature: str = typer.Option(
-        None,
-        "--feature",
-        "-f",
-        help="Scan files related to a specific feature",
-    ),
-    min_severity: str = typer.Option(
-        "MEDIUM",
-        "--min-severity",
-        "-s",
-        help="Minimum severity to report (HIGH, MEDIUM, LOW)",
-    ),
-    top: int = typer.Option(
-        10,
-        "--top",
-        "-t",
-        help="Number of hot files to show",
-    ),
-    json_output: bool = typer.Option(
-        False,
-        "--json",
-        "-j",
-        help="Output in JSON format",
-    ),
-    run_profile: bool = typer.Option(
-        False,
-        "--profile",
-        "-p",
-        help="Run dynamic memory profiling on hot files",
-    ),
-) -> None:
-    """Scan codebase for memory leak patterns.
-
-    Detects common memory issues like:
-    - sorted()[:N] patterns (should use heapq)
-    - get_all_* methods that load entire datasets
-    - Unbounded caches without eviction
-    - Large list comprehensions that could be generators
-
-    Examples:
-        empathy profile memory-scan                    # Scan src/
-        empathy profile memory-scan src/empathy_os     # Scan specific dir
-        empathy profile memory-scan --feature "cache"  # Scan cache-related files
-        empathy profile memory-scan --json > report.json  # CI integration
-    """
-    scanner_path = (
-        Path(__file__).parent.parent.parent.parent.parent / "benchmarks" / "memory_leak_scanner.py"
-    )
-
-    if not scanner_path.exists():
-        console.print("[red]Error:[/red] Memory leak scanner not found at expected path")
-        console.print(f"Expected: {scanner_path}")
-        raise typer.Exit(1)
-
-    args = [sys.executable, str(scanner_path), "--path", str(path)]
-
-    if feature:
-        args.extend(["--feature", feature])
-    if min_severity:
-        args.extend(["--min-severity", min_severity])
-    if top:
-        args.extend(["--top", str(top)])
-    if json_output:
-        args.append("--json")
-    if run_profile:
-        args.append("--profile")
-
-    subprocess.run(args, check=False)
-
-
-@profile_app.command("memory-test")
-def memory_test(
-    module: str = typer.Argument(
-        "unified",
-        help="Memory module to profile (unified, short_term, graph)",
-    ),
-) -> None:
-    """Run memory profiling tests on memory modules.
-
-    Profiles the specified memory module and reports memory usage
-    for key operations like search, store, and retrieve.
-
-    Examples:
-        empathy profile memory-test          # Profile unified memory
-        empathy profile memory-test unified  # Same as above
-    """
-    try:
-        import memory_profiler  # noqa: F401 - check if installed
-    except ImportError:
-        console.print("[yellow]Installing memory_profiler...[/yellow]")
-        subprocess.run([sys.executable, "-m", "pip", "install", "memory_profiler"], check=True)
-
-    profile_script = (
-        Path(__file__).parent.parent.parent.parent.parent
-        / "benchmarks"
-        / "profile_unified_memory.py"
-    )
-
-    if not profile_script.exists():
-        console.print("[red]Error:[/red] Memory profiling script not found")
-        console.print(f"Expected: {profile_script}")
-        raise typer.Exit(1)
-
-    console.print(f"[bold]Profiling memory module: {module}[/bold]\n")
-    subprocess.run([sys.executable, "-m", "memory_profiler", str(profile_script)], check=False)
-
-
-@profile_app.command("hot-files")
-def hot_files(
-    path: Path = typer.Argument(
-        Path("src"),
-        help="Directory to analyze",
-    ),
-    top: int = typer.Option(
-        15,
-        "--top",
-        "-t",
-        help="Number of files to show",
-    ),
-) -> None:
-    """Show files most likely to have memory issues.
-
-    Quick scan that ranks files by risk score based on
-    detected memory leak patterns.
-
-    Examples:
-        empathy profile hot-files             # Scan src/
-        empathy profile hot-files --top 20    # Show top 20
-    """
-    scanner_path = (
-        Path(__file__).parent.parent.parent.parent.parent / "benchmarks" / "memory_leak_scanner.py"
-    )
-
-    if not scanner_path.exists():
-        console.print("[red]Error:[/red] Memory leak scanner not found")
-        raise typer.Exit(1)
-
-    args = [
-        sys.executable,
-        str(scanner_path),
-        "--path",
-        str(path),
-        "--min-severity",
-        "MEDIUM",
-        "--top",
-        str(top),
-    ]
-    subprocess.run(args, check=False)
-
-
-@profile_app.callback()
-def callback() -> None:
-    """Performance profiling and memory analysis tools.
-
-    Use these commands to identify memory leaks, inefficient patterns,
-    and performance bottlenecks in your codebase.
-
-    [bold]Quick Start:[/bold]
-        empathy profile memory-scan      Scan for memory issues
-        empathy profile hot-files        Show riskiest files
-        empathy profile memory-test      Profile memory module
-    """

empathy_os/cli/commands/provider.py

@@ -1,98 +0,0 @@
-"""Provider configuration commands.
-
-Copyright 2025 Smart-AI-Memory
-Licensed under Fair Source License 0.9
-"""
-
-from pathlib import Path
-
-from empathy_os.config import _validate_file_path
-from empathy_os.logging_config import get_logger
-
-logger = get_logger(__name__)
-
-
-def cmd_provider_show(args):
-    """Show current provider configuration (Anthropic-only as of v5.0.0).
-
-    Args:
-        args: Namespace object from argparse (no additional attributes used).
-
-    Returns:
-        None: Prints Anthropic provider configuration and model mappings.
-    """
-    from empathy_os.models import MODEL_REGISTRY
-    from empathy_os.models.provider_config import ProviderConfig
-
-    print("\n" + "=" * 60)
-    print("Provider Configuration (Claude-Native v5.0.0)")
-    print("=" * 60)
-
-    # Check for Anthropic API key
-    config = ProviderConfig.auto_detect()
-    if config.available_providers:
-        print("\n✓ ANTHROPIC_API_KEY detected")
-    else:
-        print("\n⚠️  ANTHROPIC_API_KEY not detected")
-        print("   Set your API key: export ANTHROPIC_API_KEY='your-key-here'")
-        print("   Get key at: https://console.anthropic.com/settings/keys")
-
-    print("\nProvider: anthropic")
-
-    # Show Anthropic models
-    print("\nModel mapping:")
-    anthropic_models = MODEL_REGISTRY.get("anthropic", {})
-    for tier in ["cheap", "capable", "premium"]:
-        model_info = anthropic_models.get(tier)
-        if model_info:
-            cost = f"${model_info.input_cost_per_million:.2f}/${model_info.output_cost_per_million:.2f} per M tokens"
-            print(f"  {tier:8} → {model_info.id:40} {cost}")
-
-    print()
-
-
-def cmd_provider_set(args):
-    """Set default provider (Anthropic-only as of v5.0.0).
-
-    Args:
-        args: Namespace object from argparse with attributes:
-            - name (str): Provider name to set as default (must be 'anthropic').
-
-    Returns:
-        None: Saves provider to .empathy/workflows.yaml.
-
-    Raises:
-        SystemExit: If provider is not 'anthropic'.
-    """
-    import sys
-
-    import yaml
-
-    provider = args.name
-
-    # Validate provider is Anthropic
-    if provider.lower() != "anthropic":
-        print(f"❌ Error: Provider '{provider}' is not supported.")
-        print("   Empathy Framework is now Claude-native (v5.0.0).")
-        print("   Only 'anthropic' provider is available.")
-        print("   See docs/CLAUDE_NATIVE.md for migration guide.")
-        sys.exit(1)
-
-    workflows_path = Path(".empathy/workflows.yaml")
-
-    # Load existing config or create new
-    if workflows_path.exists():
-        with open(workflows_path) as f:
-            config = yaml.safe_load(f) or {}
-    else:
-        config = {}
-        workflows_path.parent.mkdir(parents=True, exist_ok=True)
-
-    config["default_provider"] = provider
-
-    validated_workflows_path = _validate_file_path(str(workflows_path))
-    with open(validated_workflows_path, "w") as f:
-        yaml.dump(config, f, default_flow_style=False, sort_keys=False)
-
-    print(f"✓ Default provider set to: {provider}")
-    print(f"  Saved to: {validated_workflows_path}")