empathy-framework 4.6.6__py3-none-any.whl → 4.7.0__py3-none-any.whl

empathy_os/cli/commands/profiling.py

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

@@ -9,16 +9,27 @@ Licensed under Fair Source License 0.9
 import subprocess
 import sys
 
+import typer
 from rich.panel import Panel
 
 from empathy_os.cli.core import console
 
+# Create the utilities Typer app
+utilities_app = typer.Typer(
+    help="Utility tools - project init, cheatsheet, dashboard, costs",
+    no_args_is_help=True,
+)
 
-def sync_claude(source: str = "patterns") -> None:
+
+@utilities_app.command("sync-claude")
+def sync_claude(
+    source: str = typer.Option("patterns", "--source", "-s", help="Source to sync"),
+) -> None:
     """Sync patterns to Claude Code memory."""
     subprocess.run(["empathy-sync-claude", "--source", source], check=False)
 
 
+@utilities_app.command("cheatsheet")
 def cheatsheet() -> None:
     """Show quick reference for all commands."""
     console.print(
@@ -49,9 +60,14 @@ def cheatsheet() -> None:
   empathy inspect .         Deep analysis (SARIF)
   empathy fix-all           Auto-fix everything
 
+[bold]Profiling[/bold]
+  empathy profile memory-scan   Scan for memory leaks
+  empathy profile hot-files     Show riskiest files
+  empathy profile memory-test   Profile memory module
+
 [bold]Pattern Learning[/bold]
   empathy learn --analyze 20    Learn from commits
-  empathy sync-claude           Sync to Claude Code
+  empathy utilities sync-claude Sync to Claude Code
 
 [bold]Workflows[/bold]
   empathy workflow list     Show available workflows
@@ -59,11 +75,11 @@ def cheatsheet() -> None:
   empathy workflow create <name> -p <patterns>  Create workflow (12x faster)
   empathy workflow list-patterns                List available patterns
 
-[bold]Wizards[/bold]
-  empathy wizard list       Show available wizards
-  empathy wizard run <name> Execute a wizard
-  empathy wizard create <name> -d <domain>  Create wizard (12x faster)
-  empathy wizard list-patterns              List available patterns
+[bold]Workflows[/bold]
+  empathy workflow list       Show available workflows
+  empathy workflow run <name> Execute a workflow
+  empathy workflow create <name> -d <domain>  Create workflow (12x faster)
+  empathy workflow list-patterns              List available patterns
 
 [bold]Usage Telemetry[/bold]
   empathy telemetry show    View recent LLM calls & costs
@@ -74,21 +90,25 @@ def cheatsheet() -> None:
     )
 
 
+@utilities_app.command("dashboard")
 def dashboard() -> None:
     """Launch visual dashboard."""
     subprocess.run([sys.executable, "-m", "empathy_os.cli", "dashboard"], check=False)
 
 
+@utilities_app.command("costs")
 def costs() -> None:
     """View API cost tracking."""
     subprocess.run([sys.executable, "-m", "empathy_os.cli", "costs"], check=False)
 
 
+@utilities_app.command("init")
 def init() -> None:
     """Create a new configuration file."""
     subprocess.run([sys.executable, "-m", "empathy_os.cli", "init"], check=False)
 
 
+@utilities_app.command("status")
 def status() -> None:
     """What needs attention now."""
     subprocess.run([sys.executable, "-m", "empathy_os.cli", "status"], check=False)

empathy_os/cli.py

@@ -4,7 +4,7 @@ Provides CLI commands for:
 - Running interactive REPL (empathy run)
 - Inspecting patterns, metrics, state (empathy inspect)
 - Exporting/importing patterns (empathy export/import)
-- Interactive setup wizard (empathy wizard)
+- Interactive setup workflow (empathy workflow)
 - Configuration management
 - Power user workflows: morning, ship, fix-all, learn (v2.4+)
 
@@ -29,7 +29,6 @@ from empathy_os.pattern_library import PatternLibrary
 from empathy_os.persistence import MetricsCollector, PatternPersistence, StateManager
 from empathy_os.platform_utils import setup_asyncio_policy
 from empathy_os.templates import cmd_new
-from empathy_os.wizard_factory_cli import add_wizard_factory_commands
 from empathy_os.workflows import (
     cmd_fix_all,
     cmd_learn,
@@ -84,7 +83,7 @@ logger = get_logger(__name__)
 CHEATSHEET = {
     "Getting Started": [
         ("empathy init", "Create a new config file"),
-        ("empathy wizard", "Interactive setup wizard"),
+        ("empathy workflow", "Interactive setup workflow"),
         ("empathy run", "Interactive REPL mode"),
     ],
     "Daily Workflow": [
@@ -443,7 +442,7 @@ First, let's create a configuration file for your project.
 Run: empathy init
 
 This creates empathy.config.yaml with sensible defaults.
-Alternatively, use 'empathy wizard' for an interactive setup.
+Alternatively, use 'empathy workflow' for an interactive setup.
 """,
             "check": lambda: _file_exists("empathy.config.yaml")
             or _file_exists("empathy.config.yml"),
@@ -822,8 +821,8 @@ def cmd_orchestrate(args):
 
     from empathy_os.workflows.orchestrated_health_check import OrchestratedHealthCheckWorkflow
     from empathy_os.workflows.orchestrated_release_prep import OrchestratedReleasePrepWorkflow
-    # test_coverage_boost removed - feature disabled in v4.0.0 (being redesigned)
 
+    # test_coverage_boost removed - feature disabled in v4.0.0 (being redesigned)
     # Get workflow type
     workflow_type = args.workflow
 
@@ -1356,50 +1355,24 @@ def cmd_status(args):
 def cmd_review(args):
     """Pattern-based code review against historical bugs.
 
-    Analyzes code changes against learned patterns to identify potential issues.
+    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 with attributes:
-            - files (list[str]): Files to review (default: recent changes).
-            - staged (bool): If True, review staged changes only.
-            - severity (str): Minimum severity threshold for findings.
-            - patterns_dir (str): Path to patterns directory.
-            - json (bool): If True, output as JSON format.
+        args: Namespace object from argparse.
 
     Returns:
-        None: Prints review findings and recommendations.
+        None: Prints deprecation message.
     """
-    import asyncio
-
-    from empathy_software_plugin.wizards.code_review_wizard import CodeReviewWizard
-
-    wizard = CodeReviewWizard(patterns_dir=args.patterns_dir)
-
-    # Run the async analysis
-    result = asyncio.run(
-        wizard.analyze(
-            {
-                "files": args.files,
-                "staged_only": args.staged,
-                "severity_threshold": args.severity,
-            },
-        ),
-    )
-
-    # Output results
-    if args.json:
-        import json
-
-        print(json.dumps(result, indent=2, default=str))
-    else:
-        print(wizard.format_terminal_output(result))
-
-        # Show recommendations
-        recommendations = result.get("recommendations", [])
-        if recommendations and result.get("findings"):
-            print("\nRecommendations:")
-            for rec in recommendations:
-                print(f"  • {rec}")
+    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):
@@ -1823,7 +1796,7 @@ def cmd_inspect(args):
                     print(f"     Success rate: {pattern.success_rate:.0%}")
         except FileNotFoundError:
             print(f"✗ Pattern library not found: {db_path}")
-            print("  Tip: Use 'empathy-framework wizard' to set up your first project")
+            print("  Tip: Use 'empathy-framework workflow' to set up your first project")
             sys.exit(1)
         except (ValueError, KeyError) as e:
             # Invalid pattern data format
@@ -2046,8 +2019,8 @@ def cmd_import(args):
     print()
 
 
-def cmd_wizard(args):
-    """Interactive setup wizard.
+def cmd_workflow(args):
+    """Interactive setup workflow.
 
     Guides user through initial framework configuration step by step.
 
@@ -2057,7 +2030,7 @@ def cmd_wizard(args):
     Returns:
         None: Creates empathy.config.yml with user's choices.
     """
-    print("🧙 Empathy Framework Setup Wizard")
+    print("🧙 Empathy Framework Setup Workflow")
     print("=" * 50)
     print("\nI'll help you set up your Empathy Framework configuration.\n")
 
@@ -2140,7 +2113,7 @@ def cmd_wizard(args):
 
     # Write YAML config
     yaml_content = f"""# Empathy Framework Configuration
-# Generated by setup wizard
+# Generated by setup workflow
 
 # Core settings
 user_id: "{config["user_id"]}"
@@ -2605,6 +2578,7 @@ def cmd_workflow(args):
             # Initialize workflow with provider and optional tier fallback
             # Note: Not all workflows support enable_tier_fallback, so we check first
             import inspect
+
             use_tier_fallback = getattr(args, "use_recommended_tier", False)
 
             # Get the workflow's __init__ signature to know what params it accepts
@@ -3203,12 +3177,12 @@ def main():
     parser_import.add_argument("--db", help="Database path (default: .empathy/patterns.db)")
     parser_import.set_defaults(func=cmd_import)
 
-    # Wizard command (Interactive setup)
-    parser_wizard = subparsers.add_parser(
-        "wizard",
-        help="Interactive setup wizard for creating configuration",
+    # Workflow command (Interactive setup)
+    parser_workflow = subparsers.add_parser(
+        "workflow",
+        help="Interactive setup workflow for creating configuration",
     )
-    parser_wizard.set_defaults(func=cmd_wizard)
+    parser_workflow.set_defaults(func=cmd_workflow)
 
     # Provider command (Model provider configuration)
     parser_provider = subparsers.add_parser(
@@ -3956,9 +3930,6 @@ def main():
     )
     parser_orchestrate.set_defaults(func=cmd_orchestrate)
 
-    # Wizard Factory commands (create wizards 12x faster)
-    add_wizard_factory_commands(subparsers)
-
     # Parse arguments
     args = parser.parse_args()