empathy-framework 4.7.1__py3-none-any.whl → 4.8.0__py3-none-any.whl

empathy_os/cli/commands/orchestrate.py

@@ -0,0 +1,184 @@
+"""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

@@ -0,0 +1,207 @@
+"""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/provider.py

@@ -1,86 +1,98 @@
-"""Multi-model provider configuration commands.
-
-Commands for managing provider settings, registry, costs, and telemetry.
+"""Provider configuration commands.
 
 Copyright 2025 Smart-AI-Memory
 Licensed under Fair Source License 0.9
 """
 
-import subprocess
-import sys
-
-import typer
-
-# Create the provider Typer app
-provider_app = typer.Typer(help="Multi-model provider configuration")
-
-
-@provider_app.callback(invoke_without_command=True)
-def provider_show(
-    ctx: typer.Context,
-    set_provider: str | None = None,
-    interactive: bool = False,
-    format_out: str = "table",
-) -> None:
-    """Show or configure provider settings."""
-    if ctx.invoked_subcommand is not None:
-        return
-
-    args = [sys.executable, "-m", "empathy_os.models.cli", "provider"]
-    if set_provider:
-        args.extend(["--set", set_provider])
-    if interactive:
-        args.append("--interactive")
-    if format_out != "table":
-        args.extend(["-f", format_out])
-
-    subprocess.run(args, check=False)
-
-
-@provider_app.command("registry")
-def provider_registry(
-    provider_filter: str | None = None,
-) -> None:
-    """Show all available models in the registry."""
-    args = [sys.executable, "-m", "empathy_os.models.cli", "registry"]
-    if provider_filter:
-        args.extend(["--provider", provider_filter])
-    subprocess.run(args, check=False)
-
-
-@provider_app.command("costs")
-def provider_costs(
-    input_tokens: int = 10000,
-    output_tokens: int = 2000,
-) -> None:
-    """Estimate costs for token usage."""
-    subprocess.run(
-        [
-            sys.executable,
-            "-m",
-            "empathy_os.models.cli",
-            "costs",
-            "--input-tokens",
-            str(input_tokens),
-            "--output-tokens",
-            str(output_tokens),
-        ],
-        check=False,
-    )
-
-
-@provider_app.command("telemetry")
-def provider_telemetry(
-    summary: bool = False,
-    costs: bool = False,
-    providers: bool = False,
-) -> None:
-    """View telemetry and analytics."""
-    args = [sys.executable, "-m", "empathy_os.models.cli", "telemetry"]
-    if summary:
-        args.append("--summary")
-    if costs:
-        args.append("--costs")
-    if providers:
-        args.append("--providers")
-    subprocess.run(args, check=False)
+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}")

empathy_os/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 empathy_os.config import EmpathyConfig, _validate_file_path, load_config
+from empathy_os.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"empathy.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)