attune-ai 2.0.0__py3-none-any.whl

attune/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 attune.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 attune.workflows.orchestrated_health_check import OrchestratedHealthCheckWorkflow
+    from attune.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

attune/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 attune.config import _validate_file_path
+from attune.logging_config import get_logger
+from attune.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 attune_llm.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)

attune/cli/commands/profiling.py

@@ -0,0 +1,202 @@
+"""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/attune     # 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}")
+        console.print("\nThe scanner script may have been moved or renamed.")
+        console.print("Check the scripts/ directory or reinstall the package.")
+        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}")
+        console.print("\nInstall memory_profiler with: pip install memory-profiler")
+        console.print("Or check that the benchmarks directory exists.")
+        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
+    """

attune/cli/commands/provider.py

@@ -0,0 +1,98 @@
+"""Provider configuration commands.
+
+Copyright 2025 Smart-AI-Memory
+Licensed under Fair Source License 0.9
+"""
+
+from pathlib import Path
+
+from attune.config import _validate_file_path
+from attune.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 attune.models import MODEL_REGISTRY
+    from attune.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 .attune/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(".attune/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}")