empathy-framework 4.6.3__py3-none-any.whl → 4.6.5__py3-none-any.whl

empathy_os/cli/__init__.py

@@ -0,0 +1,306 @@
+"""Unified CLI for Empathy Framework.
+
+A single entry point for all Empathy Framework commands using Typer.
+
+Usage:
+    empathy --help                    # Show all commands
+    empathy memory status             # Memory control panel
+    empathy provider                  # Show provider config
+    empathy scan .                    # Scan codebase
+    empathy morning                   # Start-of-day briefing
+
+Copyright 2025 Smart-AI-Memory
+Licensed under Fair Source License 0.9
+"""
+
+import subprocess
+import sys
+from pathlib import Path
+
+import typer
+
+# Re-export legacy CLI functions for backward compatibility
+# These functions are defined in the sibling cli.py module (now cli_legacy)
+# Tests and other code may import them from empathy_os.cli
+try:
+    # Import from the legacy module using relative import workaround
+    # Since this package shadows cli.py, we need to import it explicitly
+    import importlib.util
+    import os
+
+    _legacy_cli_path = os.path.join(os.path.dirname(os.path.dirname(__file__)), "cli.py")
+    if os.path.exists(_legacy_cli_path):
+        _spec = importlib.util.spec_from_file_location("cli_legacy", _legacy_cli_path)
+        _cli_legacy = importlib.util.module_from_spec(_spec)
+        _spec.loader.exec_module(_cli_legacy)
+
+        # Re-export legacy functions
+        cmd_info = _cli_legacy.cmd_info
+        cmd_init = _cli_legacy.cmd_init
+        cmd_version = _cli_legacy.cmd_version
+        cmd_validate = _cli_legacy.cmd_validate
+        cmd_patterns_list = _cli_legacy.cmd_patterns_list
+        cmd_patterns_export = _cli_legacy.cmd_patterns_export
+        cmd_metrics_show = _cli_legacy.cmd_metrics_show
+        cmd_state_list = _cli_legacy.cmd_state_list
+        cmd_run = _cli_legacy.cmd_run
+        cmd_inspect = _cli_legacy.cmd_inspect
+        cmd_export = _cli_legacy.cmd_export
+        cmd_import = _cli_legacy.cmd_import
+        cmd_wizard = _cli_legacy.cmd_wizard
+        cmd_cheatsheet = _cli_legacy.cmd_cheatsheet
+        cmd_frameworks = _cli_legacy.cmd_frameworks
+        main_legacy = _cli_legacy.main
+
+        # Export for backward compatibility
+        __all__ = [
+            "app",
+            "main",
+            "cmd_info",
+            "cmd_init",
+            "cmd_version",
+            "cmd_validate",
+            "cmd_patterns_list",
+            "cmd_patterns_export",
+            "cmd_metrics_show",
+            "cmd_state_list",
+            "cmd_run",
+            "cmd_inspect",
+            "cmd_export",
+            "cmd_import",
+            "cmd_wizard",
+            "cmd_cheatsheet",
+            "cmd_frameworks",
+        ]
+except Exception:
+    # If legacy import fails, functions won't be available
+    # Tests will fail but the new CLI will still work
+    pass
+
+from empathy_os.cli.commands import inspection, utilities
+from empathy_os.cli.commands.memory import memory_app
+from empathy_os.cli.commands.provider import provider_app
+from empathy_os.cli.core import console, get_empathy_version, version_callback
+
+# Create the main Typer app
+app = typer.Typer(
+    name="empathy",
+    help="Empathy Framework - Predictive AI-Developer Collaboration",
+    no_args_is_help=True,
+    rich_markup_mode="rich",
+)
+
+# Register command group apps
+app.add_typer(memory_app, name="memory")
+app.add_typer(provider_app, name="provider")
+
+
+@app.callback()
+def callback(
+    version: bool = typer.Option(
+        None,
+        "--version",
+        "-v",
+        callback=version_callback,
+        is_eager=True,
+        help="Show version and exit",
+    ),
+) -> None:
+    """Empathy Framework - Predictive AI-Developer Collaboration
+
+    The AI collaboration framework that predicts problems before they happen.
+
+    [bold]Quick Start:[/bold]
+        empathy morning         Start-of-day briefing
+        empathy health          Quick health check
+        empathy ship            Pre-commit validation
+
+    [bold]Memory:[/bold]
+        empathy memory status   Check memory system status
+        empathy memory start    Start Redis server
+
+    [bold]Provider:[/bold]
+        empathy provider        Show current provider config
+        empathy provider --set hybrid   Configure provider
+
+    [bold]Inspection:[/bold]
+        empathy scan .          Scan codebase for issues
+        empathy inspect .       Deep inspection with SARIF output
+    """
+
+
+# =============================================================================
+# SCAN/INSPECT COMMANDS (top-level)
+# =============================================================================
+
+
+@app.command("scan")
+def scan(
+    path: Path = Path("."),
+    format_out: str = "text",
+    fix: bool = False,
+    staged: bool = False,
+) -> None:
+    """Scan codebase for issues."""
+    inspection.scan(path, format_out, fix, staged)
+
+
+@app.command("inspect")
+def inspect_cmd(
+    path: Path = Path("."),
+    format_out: str = "text",
+) -> None:
+    """Deep inspection with code analysis."""
+    inspection.inspect_cmd(path, format_out)
+
+
+# =============================================================================
+# UTILITY COMMANDS (top-level)
+# =============================================================================
+
+
+@app.command("sync-claude")
+def sync_claude(source: str = "patterns") -> None:
+    """Sync patterns to Claude Code memory."""
+    utilities.sync_claude(source)
+
+
+@app.command("cheatsheet")
+def cheatsheet() -> None:
+    """Show quick reference for all commands."""
+    utilities.cheatsheet()
+
+
+@app.command("dashboard")
+def dashboard() -> None:
+    """Launch visual dashboard."""
+    utilities.dashboard()
+
+
+@app.command("costs")
+def costs() -> None:
+    """View API cost tracking."""
+    utilities.costs()
+
+
+@app.command("init")
+def init() -> None:
+    """Create a new configuration file."""
+    utilities.init()
+
+
+@app.command("status")
+def status() -> None:
+    """What needs attention now."""
+    utilities.status()
+
+
+# =============================================================================
+# WORKFLOW COMMANDS (delegate to legacy CLI for now)
+# These will be extracted in Phase 2b
+# =============================================================================
+
+
+@app.command("morning")
+def morning() -> None:
+    """Start-of-day briefing with patterns, git context, and priorities."""
+    subprocess.run([sys.executable, "-m", "empathy_os.cli", "morning"], check=False)
+
+
+@app.command("ship")
+def ship(
+    tests_only: bool = False,
+    security_only: bool = False,
+    skip_sync: bool = False,
+) -> None:
+    """Pre-commit validation (lint, format, tests, security)."""
+    args = [sys.executable, "-m", "empathy_os.cli", "ship"]
+    if tests_only:
+        args.append("--tests-only")
+    if security_only:
+        args.append("--security-only")
+    if skip_sync:
+        args.append("--skip-sync")
+    subprocess.run(args, check=False)
+
+
+@app.command("health")
+def health(
+    deep: bool = False,
+    fix: bool = False,
+) -> None:
+    """Quick health check (lint, types, tests)."""
+    args = [sys.executable, "-m", "empathy_os.cli", "health"]
+    if deep:
+        args.append("--deep")
+    if fix:
+        args.append("--fix")
+    subprocess.run(args, check=False)
+
+
+@app.command("fix-all")
+def fix_all() -> None:
+    """Fix all lint and format issues."""
+    subprocess.run([sys.executable, "-m", "empathy_os.cli", "fix-all"], check=False)
+
+
+@app.command("learn")
+def learn(analyze: int = 20) -> None:
+    """Learn patterns from commit history."""
+    subprocess.run(
+        [sys.executable, "-m", "empathy_os.cli", "learn", "--analyze", str(analyze)],
+        check=False,
+    )
+
+
+@app.command("run")
+def run_repl() -> None:
+    """Start interactive REPL mode."""
+    subprocess.run([sys.executable, "-m", "empathy_os.cli", "run"], check=False)
+
+
+# =============================================================================
+# REMAINING COMMAND GROUPS
+# Import directly from cli_unified.py for now - will be extracted later
+# =============================================================================
+
+# Import and register remaining command groups from cli_unified.py
+# These are imported here to keep the transition incremental
+try:
+    from empathy_os.cli_unified import (
+        orchestrate_app,
+        progressive_app,
+        service_app,
+        telemetry_app,
+        tier_app,
+        wizard_app,
+        workflow_app,
+    )
+
+    app.add_typer(wizard_app, name="wizard")
+    app.add_typer(workflow_app, name="workflow")
+    app.add_typer(orchestrate_app, name="orchestrate")
+    app.add_typer(telemetry_app, name="telemetry")
+    app.add_typer(service_app, name="service")
+    app.add_typer(progressive_app, name="progressive")
+    app.add_typer(tier_app, name="tier")
+except ImportError:
+    # cli_unified.py may not have these exports yet
+    pass
+
+# Register meta-workflow if available
+try:
+    from empathy_os.meta_workflows.cli_meta_workflows import meta_workflow_app
+
+    app.add_typer(meta_workflow_app, name="meta-workflow")
+except ImportError:
+    pass
+
+
+def main() -> None:
+    """Entry point for the unified CLI."""
+    app()
+
+
+if __name__ == "__main__":
+    main()

empathy_os/cli/__main__.py

@@ -0,0 +1,26 @@
+"""Entry point for python -m empathy_os.cli.
+
+This redirects to the legacy cli.py module for backward compatibility.
+The cli/ package coexists with cli.py, but Python finds packages first.
+"""
+
+import sys
+from pathlib import Path
+
+# Add the parent directory to find the cli.py module
+parent = Path(__file__).parent.parent
+if str(parent) not in sys.path:
+    sys.path.insert(0, str(parent))
+
+# Import and run the legacy CLI
+# We can't import cli directly because of the package name conflict
+# So we use importlib to load cli.py as a module
+import importlib.util
+
+cli_py_path = parent / "cli.py"
+spec = importlib.util.spec_from_file_location("cli_legacy", cli_py_path)
+cli_module = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(cli_module)
+
+if __name__ == "__main__":
+    cli_module.main()

empathy_os/cli/commands/__init__.py

@@ -0,0 +1,8 @@
+"""CLI command modules for Empathy Framework.
+
+Each module contains a Typer app that can be registered with the main app.
+"""
+
+from empathy_os.cli.commands import inspection, memory, provider, utilities
+
+__all__ = ["memory", "provider", "inspection", "utilities"]

empathy_os/cli/commands/inspection.py

@@ -0,0 +1,48 @@
+"""Code inspection commands.
+
+Commands for scanning and inspecting codebases for issues.
+
+Copyright 2025 Smart-AI-Memory
+Licensed under Fair Source License 0.9
+"""
+
+import subprocess
+from pathlib import Path
+
+from empathy_os.cli.core import console
+
+
+def scan(
+    path: Path = Path("."),
+    format_out: str = "text",
+    fix: bool = False,
+    staged: bool = False,
+) -> None:
+    """Scan codebase for issues."""
+    args = ["empathy-scan", str(path)]
+    if format_out != "text":
+        args.extend(["--format", format_out])
+    if fix:
+        args.append("--fix")
+    if staged:
+        args.append("--staged")
+
+    result = subprocess.run(args, check=False, capture_output=False)
+    if result.returncode != 0:
+        console.print("[yellow]Note: empathy-scan may not be installed[/yellow]")
+        console.print("Install with: pip install empathy-framework[software]")
+
+
+def inspect_cmd(
+    path: Path = Path("."),
+    format_out: str = "text",
+) -> None:
+    """Deep inspection with code analysis."""
+    args = ["empathy-inspect", str(path)]
+    if format_out != "text":
+        args.extend(["--format", format_out])
+
+    result = subprocess.run(args, check=False, capture_output=False)
+    if result.returncode != 0:
+        console.print("[yellow]Note: empathy-inspect may not be installed[/yellow]")
+        console.print("Install with: pip install empathy-framework[software]")

empathy_os/cli/commands/memory.py

@@ -0,0 +1,56 @@
+"""Memory system control panel commands.
+
+Commands for managing Redis-backed short-term memory system.
+
+Copyright 2025 Smart-AI-Memory
+Licensed under Fair Source License 0.9
+"""
+
+import subprocess
+import sys
+
+import typer
+
+# Create the memory Typer app
+memory_app = typer.Typer(help="Memory system control panel")
+
+
+@memory_app.command("status")
+def memory_status() -> None:
+    """Check memory system status (Redis, patterns, stats)."""
+    subprocess.run(
+        [sys.executable, "-m", "empathy_os.memory.control_panel", "status"], check=False
+    )
+
+
+@memory_app.command("start")
+def memory_start() -> None:
+    """Start Redis server for short-term memory."""
+    subprocess.run(
+        [sys.executable, "-m", "empathy_os.memory.control_panel", "start"], check=False
+    )
+
+
+@memory_app.command("stop")
+def memory_stop() -> None:
+    """Stop Redis server."""
+    subprocess.run(
+        [sys.executable, "-m", "empathy_os.memory.control_panel", "stop"], check=False
+    )
+
+
+@memory_app.command("stats")
+def memory_stats() -> None:
+    """Show memory statistics."""
+    subprocess.run(
+        [sys.executable, "-m", "empathy_os.memory.control_panel", "stats"], check=False
+    )
+
+
+@memory_app.command("patterns")
+def memory_patterns() -> None:
+    """List stored patterns."""
+    subprocess.run(
+        [sys.executable, "-m", "empathy_os.memory.control_panel", "patterns", "--list"],
+        check=False,
+    )

empathy_os/cli/commands/provider.py

@@ -0,0 +1,86 @@
+"""Multi-model provider configuration commands.
+
+Commands for managing provider settings, registry, costs, and telemetry.
+
+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)

empathy_os/cli/commands/utilities.py

@@ -0,0 +1,94 @@
+"""Utility commands for Empathy Framework CLI.
+
+General-purpose utility commands (sync, cheatsheet, dashboard, etc.).
+
+Copyright 2025 Smart-AI-Memory
+Licensed under Fair Source License 0.9
+"""
+
+import subprocess
+import sys
+
+from rich.panel import Panel
+
+from empathy_os.cli.core import console
+
+
+def sync_claude(source: str = "patterns") -> None:
+    """Sync patterns to Claude Code memory."""
+    subprocess.run(["empathy-sync-claude", "--source", source], check=False)
+
+
+def cheatsheet() -> None:
+    """Show quick reference for all commands."""
+    console.print(
+        Panel.fit(
+            """[bold]Getting Started[/bold]
+  empathy morning           Start-of-day briefing
+  empathy health            Quick health check
+  empathy ship              Pre-commit validation
+  empathy run               Interactive REPL
+
+[bold]Memory System[/bold]
+  empathy memory status     Check Redis & patterns
+  empathy memory start      Start Redis server
+  empathy memory patterns   List stored patterns
+
+[bold]Cross-Session Service[/bold]
+  empathy service start     Start coordination service
+  empathy service status    Show service & sessions
+  empathy service sessions  List active agents
+
+[bold]Provider Config[/bold]
+  empathy provider          Show current config
+  empathy provider --set hybrid    Use best-of-breed
+  empathy provider registry        List all models
+
+[bold]Code Inspection[/bold]
+  empathy scan .            Scan for issues
+  empathy inspect .         Deep analysis (SARIF)
+  empathy fix-all           Auto-fix everything
+
+[bold]Pattern Learning[/bold]
+  empathy learn --analyze 20    Learn from commits
+  empathy sync-claude           Sync to Claude Code
+
+[bold]Workflows[/bold]
+  empathy workflow list     Show available workflows
+  empathy workflow run <name>   Execute a workflow
+  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]Usage Telemetry[/bold]
+  empathy telemetry show    View recent LLM calls & costs
+  empathy telemetry savings Calculate cost savings (tier routing)
+  empathy telemetry export  Export usage data (JSON/CSV)""",
+            title="[bold blue]Empathy Framework Cheatsheet[/bold blue]",
+        )
+    )
+
+
+def dashboard() -> None:
+    """Launch visual dashboard."""
+    subprocess.run([sys.executable, "-m", "empathy_os.cli", "dashboard"], check=False)
+
+
+def costs() -> None:
+    """View API cost tracking."""
+    subprocess.run([sys.executable, "-m", "empathy_os.cli", "costs"], check=False)
+
+
+def init() -> None:
+    """Create a new configuration file."""
+    subprocess.run([sys.executable, "-m", "empathy_os.cli", "init"], check=False)
+
+
+def status() -> None:
+    """What needs attention now."""
+    subprocess.run([sys.executable, "-m", "empathy_os.cli", "status"], check=False)

empathy_os/cli/core.py

@@ -0,0 +1,32 @@
+"""Core utilities for Empathy Framework CLI.
+
+Shared utilities, console configuration, and helper functions used across
+all CLI command modules.
+
+Copyright 2025 Smart-AI-Memory
+Licensed under Fair Source License 0.9
+"""
+
+from importlib.metadata import version as get_version
+
+import typer
+from rich.console import Console
+
+# Shared Rich console instance for all CLI commands
+console = Console()
+
+
+def get_empathy_version() -> str:
+    """Get the installed version of empathy-framework."""
+    try:
+        return get_version("empathy-framework")
+    except Exception:  # noqa: BLE001
+        # INTENTIONAL: Version detection fallback for dev installs
+        return "dev"
+
+
+def version_callback(value: bool) -> None:
+    """Show version and exit."""
+    if value:
+        console.print(f"[bold blue]Empathy Framework[/bold blue] v{get_empathy_version()}")
+        raise typer.Exit()

empathy_os/cli.py

@@ -2600,15 +2600,27 @@ def cmd_workflow(args):
                 wf_config = WorkflowConfig.load()
                 provider = wf_config.default_provider
 
-            # Initialize workflow with tier fallback if requested
+            # 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)
-            workflow_kwargs = {
-                "provider": provider,
-                "enable_tier_fallback": use_tier_fallback,
-            }
+
+            # Get the workflow's __init__ signature to know what params it accepts
+            init_sig = inspect.signature(workflow_cls.__init__)
+            init_params = set(init_sig.parameters.keys())
+
+            workflow_kwargs = {}
+
+            # Add provider if supported
+            if "provider" in init_params:
+                workflow_kwargs["provider"] = provider
+
+            # Add enable_tier_fallback only if the workflow supports it
+            if "enable_tier_fallback" in init_params and use_tier_fallback:
+                workflow_kwargs["enable_tier_fallback"] = use_tier_fallback
 
             # Add health-check specific parameters
-            if name == "health-check":
+            if name == "health-check" and "health_score_threshold" in init_params:
                 health_score_threshold = getattr(args, "health_score_threshold", 100)
                 workflow_kwargs["health_score_threshold"] = health_score_threshold