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

empathy_os/__init__.py

@@ -59,76 +59,208 @@ __version__ = "4.6.5"
 __author__ = "Patrick Roebuck"
 __email__ = "hello@deepstudy.ai"
 
-from .agent_monitoring import AgentMetrics, AgentMonitor, TeamMetrics
-from .config import EmpathyConfig, load_config
-from .coordination import (
-    AgentCoordinator,
-    AgentTask,
-    ConflictResolver,
-    ResolutionResult,
-    ResolutionStrategy,
-    TeamPriorities,
-    TeamSession,
-)
-from .core import EmpathyOS
-from .emergence import EmergenceDetector
-from .exceptions import (
-    CollaborationStateError,
-    ConfidenceThresholdError,
-    EmpathyFrameworkError,
-    EmpathyLevelError,
-    FeedbackLoopError,
-    LeveragePointError,
-    PatternNotFoundError,
-    TrustThresholdError,
-    ValidationError,
-)
-from .feedback_loops import FeedbackLoopDetector
-from .levels import Level1Reactive, Level2Guided, Level3Proactive, Level4Anticipatory, Level5Systems
-from .leverage_points import LeveragePointAnalyzer
-from .logging_config import LoggingConfig, get_logger
-
-# Memory module (unified short-term + long-term + security)
-from .memory import (
-    AccessTier,
-    AgentCredentials,  # Memory module imports
-    AuditEvent,
-    AuditLogger,
-    Classification,
-    ClassificationRules,
-    ClaudeMemoryConfig,
-    ClaudeMemoryLoader,
-    ConflictContext,
-    EncryptionManager,
-    Environment,
-    MemDocsStorage,
-    MemoryConfig,
-    MemoryPermissionError,
-    PatternMetadata,
-    PIIDetection,
-    PIIPattern,
-    PIIScrubber,
-    RedisShortTermMemory,
-    SecretDetection,
-    SecretsDetector,
-    SecretType,
-    SecureMemDocsIntegration,
-    SecurePattern,
-    SecurityError,
-    SecurityViolation,
-    Severity,
-    StagedPattern,
-    TTLStrategy,
-    UnifiedMemory,
-    check_redis_connection,
-    detect_secrets,
-    get_railway_redis,
-    get_redis_config,
-    get_redis_memory,
-)
-from .pattern_library import Pattern, PatternLibrary, PatternMatch
-from .persistence import MetricsCollector, PatternPersistence, StateManager
-from .trust_building import TrustBuildingBehaviors
+# =============================================================================
+# LAZY IMPORTS - Deferred loading for faster startup
+# =============================================================================
+# Instead of importing everything at module load, we use __getattr__ to load
+# modules only when they're actually accessed. This reduces import time from
+# ~1s to ~0.05s for simple use cases.
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    # Type hints for IDE support (not evaluated at runtime)
+    from .agent_monitoring import AgentMetrics, AgentMonitor, TeamMetrics
+    from .config import EmpathyConfig, load_config
+    from .coordination import (
+        AgentCoordinator,
+        AgentTask,
+        ConflictResolver,
+        ResolutionResult,
+        ResolutionStrategy,
+        TeamPriorities,
+        TeamSession,
+    )
+    from .core import EmpathyOS
+    from .emergence import EmergenceDetector
+    from .exceptions import (
+        CollaborationStateError,
+        ConfidenceThresholdError,
+        EmpathyFrameworkError,
+        EmpathyLevelError,
+        FeedbackLoopError,
+        LeveragePointError,
+        PatternNotFoundError,
+        TrustThresholdError,
+        ValidationError,
+    )
+    from .feedback_loops import FeedbackLoopDetector
+    from .levels import (
+        Level1Reactive,
+        Level2Guided,
+        Level3Proactive,
+        Level4Anticipatory,
+        Level5Systems,
+    )
+    from .leverage_points import LeveragePointAnalyzer
+    from .logging_config import LoggingConfig, get_logger
+    from .memory import (
+        AccessTier,
+        AgentCredentials,
+        AuditEvent,
+        AuditLogger,
+        Classification,
+        ClassificationRules,
+        ClaudeMemoryConfig,
+        ClaudeMemoryLoader,
+        ConflictContext,
+        EncryptionManager,
+        Environment,
+        MemDocsStorage,
+        MemoryConfig,
+        MemoryPermissionError,
+        PatternMetadata,
+        PIIDetection,
+        PIIPattern,
+        PIIScrubber,
+        RedisShortTermMemory,
+        SecretDetection,
+        SecretsDetector,
+        SecretType,
+        SecureMemDocsIntegration,
+        SecurePattern,
+        SecurityError,
+        SecurityViolation,
+        Severity,
+        StagedPattern,
+        TTLStrategy,
+        UnifiedMemory,
+        check_redis_connection,
+        detect_secrets,
+        get_railway_redis,
+        get_redis_config,
+        get_redis_memory,
+    )
+    from .pattern_library import Pattern, PatternLibrary, PatternMatch
+    from .persistence import MetricsCollector, PatternPersistence, StateManager
+    from .trust_building import TrustBuildingBehaviors
+
+# Mapping of attribute names to their module paths
+_LAZY_IMPORTS: dict[str, tuple[str, str]] = {
+    # agent_monitoring
+    "AgentMetrics": (".agent_monitoring", "AgentMetrics"),
+    "AgentMonitor": (".agent_monitoring", "AgentMonitor"),
+    "TeamMetrics": (".agent_monitoring", "TeamMetrics"),
+    # config
+    "EmpathyConfig": (".config", "EmpathyConfig"),
+    "load_config": (".config", "load_config"),
+    # coordination
+    "AgentCoordinator": (".coordination", "AgentCoordinator"),
+    "AgentTask": (".coordination", "AgentTask"),
+    "ConflictResolver": (".coordination", "ConflictResolver"),
+    "ResolutionResult": (".coordination", "ResolutionResult"),
+    "ResolutionStrategy": (".coordination", "ResolutionStrategy"),
+    "TeamPriorities": (".coordination", "TeamPriorities"),
+    "TeamSession": (".coordination", "TeamSession"),
+    # core
+    "EmpathyOS": (".core", "EmpathyOS"),
+    # emergence
+    "EmergenceDetector": (".emergence", "EmergenceDetector"),
+    # exceptions
+    "CollaborationStateError": (".exceptions", "CollaborationStateError"),
+    "ConfidenceThresholdError": (".exceptions", "ConfidenceThresholdError"),
+    "EmpathyFrameworkError": (".exceptions", "EmpathyFrameworkError"),
+    "EmpathyLevelError": (".exceptions", "EmpathyLevelError"),
+    "FeedbackLoopError": (".exceptions", "FeedbackLoopError"),
+    "LeveragePointError": (".exceptions", "LeveragePointError"),
+    "PatternNotFoundError": (".exceptions", "PatternNotFoundError"),
+    "TrustThresholdError": (".exceptions", "TrustThresholdError"),
+    "ValidationError": (".exceptions", "ValidationError"),
+    # feedback_loops
+    "FeedbackLoopDetector": (".feedback_loops", "FeedbackLoopDetector"),
+    # levels
+    "Level1Reactive": (".levels", "Level1Reactive"),
+    "Level2Guided": (".levels", "Level2Guided"),
+    "Level3Proactive": (".levels", "Level3Proactive"),
+    "Level4Anticipatory": (".levels", "Level4Anticipatory"),
+    "Level5Systems": (".levels", "Level5Systems"),
+    # leverage_points
+    "LeveragePointAnalyzer": (".leverage_points", "LeveragePointAnalyzer"),
+    # logging_config
+    "LoggingConfig": (".logging_config", "LoggingConfig"),
+    "get_logger": (".logging_config", "get_logger"),
+    # memory module
+    "AccessTier": (".memory", "AccessTier"),
+    "AgentCredentials": (".memory", "AgentCredentials"),
+    "AuditEvent": (".memory", "AuditEvent"),
+    "AuditLogger": (".memory", "AuditLogger"),
+    "Classification": (".memory", "Classification"),
+    "ClassificationRules": (".memory", "ClassificationRules"),
+    "ClaudeMemoryConfig": (".memory", "ClaudeMemoryConfig"),
+    "ClaudeMemoryLoader": (".memory", "ClaudeMemoryLoader"),
+    "ConflictContext": (".memory", "ConflictContext"),
+    "EncryptionManager": (".memory", "EncryptionManager"),
+    "Environment": (".memory", "Environment"),
+    "MemDocsStorage": (".memory", "MemDocsStorage"),
+    "MemoryConfig": (".memory", "MemoryConfig"),
+    "MemoryPermissionError": (".memory", "MemoryPermissionError"),
+    "PatternMetadata": (".memory", "PatternMetadata"),
+    "PIIDetection": (".memory", "PIIDetection"),
+    "PIIPattern": (".memory", "PIIPattern"),
+    "PIIScrubber": (".memory", "PIIScrubber"),
+    "RedisShortTermMemory": (".memory", "RedisShortTermMemory"),
+    "SecretDetection": (".memory", "SecretDetection"),
+    "SecretsDetector": (".memory", "SecretsDetector"),
+    "SecretType": (".memory", "SecretType"),
+    "SecureMemDocsIntegration": (".memory", "SecureMemDocsIntegration"),
+    "SecurePattern": (".memory", "SecurePattern"),
+    "SecurityError": (".memory", "SecurityError"),
+    "SecurityViolation": (".memory", "SecurityViolation"),
+    "Severity": (".memory", "Severity"),
+    "StagedPattern": (".memory", "StagedPattern"),
+    "TTLStrategy": (".memory", "TTLStrategy"),
+    "UnifiedMemory": (".memory", "UnifiedMemory"),
+    "check_redis_connection": (".memory", "check_redis_connection"),
+    "detect_secrets": (".memory", "detect_secrets"),
+    "get_railway_redis": (".memory", "get_railway_redis"),
+    "get_redis_config": (".memory", "get_redis_config"),
+    "get_redis_memory": (".memory", "get_redis_memory"),
+    # pattern_library
+    "Pattern": (".pattern_library", "Pattern"),
+    "PatternLibrary": (".pattern_library", "PatternLibrary"),
+    "PatternMatch": (".pattern_library", "PatternMatch"),
+    # persistence
+    "MetricsCollector": (".persistence", "MetricsCollector"),
+    "PatternPersistence": (".persistence", "PatternPersistence"),
+    "StateManager": (".persistence", "StateManager"),
+    # trust_building
+    "TrustBuildingBehaviors": (".trust_building", "TrustBuildingBehaviors"),
+}
+
+# Cache for loaded modules
+_loaded_modules: dict[str, object] = {}
+
+
+def __getattr__(name: str) -> object:
+    """Lazy import handler - loads modules only when accessed."""
+    if name in _LAZY_IMPORTS:
+        module_path, attr_name = _LAZY_IMPORTS[name]
+
+        # Check cache first
+        cache_key = f"{module_path}.{attr_name}"
+        if cache_key in _loaded_modules:
+            return _loaded_modules[cache_key]
+
+        # Import the module and get the attribute
+        import importlib
+        module = importlib.import_module(module_path, package="empathy_os")
+        attr = getattr(module, attr_name)
+
+        # Cache and return
+        _loaded_modules[cache_key] = attr
+        return attr
+
+    raise AttributeError(f"module 'empathy_os' has no attribute '{name}'")
 
 __all__ = [
     "AccessTier",

empathy_os/cache_monitor.py

@@ -303,8 +303,9 @@ class CacheMonitor:
         Returns:
             List of CacheStats with hit rate >= threshold, sorted by hit rate
         """
+        # Use generator expression for memory efficiency
         return sorted(
-            [s for s in self._caches.values() if s.hit_rate >= threshold],
+            (s for s in self._caches.values() if s.hit_rate >= threshold),
             key=lambda s: s.hit_rate,
             reverse=True,
         )
@@ -318,8 +319,9 @@ class CacheMonitor:
         Returns:
             List of CacheStats with hit rate <= threshold, sorted by hit rate
         """
+        # Use generator expression for memory efficiency
         return sorted(
-            [s for s in self._caches.values() if s.hit_rate <= threshold],
+            (s for s in self._caches.values() if s.hit_rate <= threshold),
             key=lambda s: s.hit_rate,
         )
 
@@ -345,7 +347,7 @@ class CacheMonitor:
         lines.append("=" * 70)
         if total_capacity > 0:
             lines.append(
-                f"{'TOTAL':<30} {total_used:>8,} / {total_capacity:>8,}  ({total_used/total_capacity*100:>5.1f}%)"
+                f"{'TOTAL':<30} {total_used:>8,} / {total_capacity:>8,}  ({total_used / total_capacity * 100:>5.1f}%)"
             )
         else:
             lines.append(f"{'TOTAL':<30} {total_used:>8,} / unlimited")

empathy_os/cli/__init__.py

@@ -47,7 +47,7 @@ try:
         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_workflow = _cli_legacy.cmd_workflow
         cmd_cheatsheet = _cli_legacy.cmd_cheatsheet
         cmd_frameworks = _cli_legacy.cmd_frameworks
         main_legacy = _cli_legacy.main
@@ -68,18 +68,20 @@ try:
             "cmd_inspect",
             "cmd_export",
             "cmd_import",
-            "cmd_wizard",
+            "cmd_workflow",
             "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
+except Exception:  # noqa: BLE001
+    # INTENTIONAL: If legacy import fails, functions won't be available.
+    # New CLI still works; legacy re-exports are for backward compatibility only.
     pass
 
-from empathy_os.cli.commands import inspection, utilities
+from empathy_os.cli.commands import inspection
 from empathy_os.cli.commands.memory import memory_app
+from empathy_os.cli.commands.profiling import profile_app
 from empathy_os.cli.commands.provider import provider_app
+from empathy_os.cli.commands.utilities import utilities_app
 from empathy_os.cli.core import console, get_empathy_version, version_callback
 
 # Create the main Typer app
@@ -92,7 +94,10 @@ app = typer.Typer(
 
 # Register command group apps
 app.add_typer(memory_app, name="memory")
+app.add_typer(profile_app, name="profile")
 app.add_typer(provider_app, name="provider")
+app.add_typer(utilities_app, name="utilities")
+app.add_typer(utilities_app, name="utility", hidden=True)  # Alias for common typo
 
 
 @app.callback()
@@ -154,59 +159,12 @@ def inspect_cmd(
     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,
@@ -273,11 +231,9 @@ try:
         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")

empathy_os/cli/__main__.py

@@ -1,26 +1,40 @@
 """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.
+Supports both the new Typer-based CLI and legacy CLI.
+New commands (profile, etc.) are in the Typer CLI.
+Legacy commands fall back to cli.py for compatibility.
 """
 
 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))
+# Commands that are only in the new Typer CLI
+NEW_CLI_COMMANDS = {"profile", "memory", "provider"}
 
-# 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)
+def main() -> None:
+    """Route to appropriate CLI based on command."""
+    # Check if we should use the new Typer CLI
+    if len(sys.argv) > 1 and sys.argv[1] in NEW_CLI_COMMANDS:
+        # Use the new Typer-based CLI
+        from empathy_os.cli import app
 
-if __name__ == "__main__":
+        app()
+        return
+
+    # Fall back to legacy CLI for backward compatibility
+    parent = Path(__file__).parent.parent
+    if str(parent) not in sys.path:
+        sys.path.insert(0, str(parent))
+
+    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)
     cli_module.main()
+
+
+if __name__ == "__main__":
+    main()

empathy_os/cli/commands/inspection.py

@@ -18,19 +18,28 @@ def scan(
     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")
+    """Scan codebase for issues using ruff and bandit."""
+    console.print(f"[bold blue]Scanning {path}...[/bold blue]\n")
 
-    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]")
+    # Run ruff for linting
+    console.print("[bold]Running ruff (linting)...[/bold]")
+    ruff_args = ["ruff", "check", str(path)]
+    if fix:
+        ruff_args.append("--fix")
+    subprocess.run(ruff_args, check=False)
+
+    # Run bandit for security (if available)
+    console.print("\n[bold]Running bandit (security)...[/bold]")
+    bandit_args = ["bandit", "-r", str(path), "-q"]
+    if format_out == "json":
+        bandit_args.extend(["-f", "json"])
+    result = subprocess.run(bandit_args, check=False, capture_output=True)
+    if result.returncode == 0:
+        console.print("[green]No security issues found[/green]")
+    elif result.stdout:
+        console.print(result.stdout.decode())
+
+    console.print("\n[bold green]Scan complete![/bold green]")
 
 
 def inspect_cmd(

empathy_os/cli/commands/memory.py

@@ -18,33 +18,25 @@ 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
-    )
+    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
-    )
+    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
-    )
+    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
-    )
+    subprocess.run([sys.executable, "-m", "empathy_os.memory.control_panel", "stats"], check=False)
 
 
 @memory_app.command("patterns")