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

empathy_os/memory/short_term.py

@@ -164,6 +164,14 @@ class RedisShortTermMemory:
         self._mock_streams: dict[str, list[tuple[str, dict]]] = {}
         self._mock_pubsub_handlers: dict[str, list[Callable[[dict], None]]] = {}
 
+        # Local LRU cache for two-tier caching (memory + Redis)
+        # Reduces network I/O from 37ms to <0.001ms for frequently accessed keys
+        self._local_cache_enabled = self._config.local_cache_enabled
+        self._local_cache_max_size = self._config.local_cache_size
+        self._local_cache: dict[str, tuple[str, float, float]] = {}  # key -> (value, timestamp, last_access)
+        self._local_cache_hits = 0
+        self._local_cache_misses = 0
+
         # Security: Initialize PII scrubber and secrets detector
         self._pii_scrubber: PIIScrubber | None = None
         self._secrets_detector: SecretsDetector | None = None
@@ -262,43 +270,105 @@ class RedisShortTermMemory:
         raise last_error if last_error else ConnectionError("Redis operation failed")
 
     def _get(self, key: str) -> str | None:
-        """Get value from Redis or mock"""
+        """Get value from Redis or mock with two-tier caching (local + Redis)"""
+        # Check local cache first (0.001ms vs 37ms for Redis/mock)
+        # This works for BOTH mock and real Redis modes
+        if self._local_cache_enabled and key in self._local_cache:
+            value, timestamp, last_access = self._local_cache[key]
+            now = time.time()
+
+            # Update last access time for LRU
+            self._local_cache[key] = (value, timestamp, now)
+            self._local_cache_hits += 1
+
+            return value
+
+        # Cache miss - fetch from storage (mock or Redis)
+        self._local_cache_misses += 1
+
+        # Mock mode path
         if self.use_mock:
             if key in self._mock_storage:
                 value, expires = self._mock_storage[key]
                 if expires is None or datetime.now().timestamp() < expires:
-                    return str(value) if value is not None else None
+                    result = str(value) if value is not None else None
+                    # Add to local cache for next access
+                    if result and self._local_cache_enabled:
+                        self._add_to_local_cache(key, result)
+                    return result
                 del self._mock_storage[key]
             return None
+
+        # Real Redis path
         if self._client is None:
             return None
+
         result = self._client.get(key)
+
+        # Add to local cache if successful
+        if result and self._local_cache_enabled:
+            self._add_to_local_cache(key, str(result))
+
         return str(result) if result else None
 
     def _set(self, key: str, value: str, ttl: int | None = None) -> bool:
-        """Set value in Redis or mock"""
+        """Set value in Redis or mock with two-tier caching"""
+        # Mock mode path
         if self.use_mock:
             expires = datetime.now().timestamp() + ttl if ttl else None
             self._mock_storage[key] = (value, expires)
+
+            # Update local cache in mock mode too
+            if self._local_cache_enabled:
+                self._add_to_local_cache(key, value)
+
             return True
+
+        # Real Redis path
         if self._client is None:
             return False
+
+        # Set in Redis
         if ttl:
             self._client.setex(key, ttl, value)
-            return True
-        result = self._client.set(key, value)
-        return bool(result)
+        else:
+            result = self._client.set(key, value)
+            if not result:
+                return False
+
+        # Update local cache if enabled
+        if self._local_cache_enabled:
+            self._add_to_local_cache(key, value)
+
+        return True
 
     def _delete(self, key: str) -> bool:
-        """Delete key from Redis or mock"""
+        """Delete key from Redis or mock and local cache"""
+        # Mock mode path
         if self.use_mock:
+            deleted = False
             if key in self._mock_storage:
                 del self._mock_storage[key]
-                return True
-            return False
+                deleted = True
+
+            # Remove from local cache if present
+            if self._local_cache_enabled and key in self._local_cache:
+                del self._local_cache[key]
+
+            return deleted
+
+        # Real Redis path
         if self._client is None:
             return False
-        return bool(self._client.delete(key) > 0)
+
+        # Delete from Redis
+        result = bool(self._client.delete(key) > 0)
+
+        # Also remove from local cache if present
+        if self._local_cache_enabled and key in self._local_cache:
+            del self._local_cache[key]
+
+        return result
 
     def _keys(self, pattern: str) -> list[str]:
         """Get keys matching pattern"""
@@ -313,6 +383,58 @@ class RedisShortTermMemory:
         # Convert bytes to strings - needed for API return type
         return [k.decode() if isinstance(k, bytes) else str(k) for k in keys]
 
+    # === Local LRU Cache Methods ===
+
+    def _add_to_local_cache(self, key: str, value: str) -> None:
+        """Add entry to local cache with LRU eviction.
+
+        Args:
+            key: Cache key
+            value: Value to cache
+        """
+        now = time.time()
+
+        # Evict oldest entry if cache is full
+        if len(self._local_cache) >= self._local_cache_max_size:
+            # Find key with oldest last_access time
+            oldest_key = min(self._local_cache, key=lambda k: self._local_cache[k][2])
+            del self._local_cache[oldest_key]
+
+        # Add new entry: (value, timestamp, last_access)
+        self._local_cache[key] = (value, now, now)
+
+    def clear_local_cache(self) -> int:
+        """Clear all entries from local cache.
+
+        Returns:
+            Number of entries cleared
+        """
+        count = len(self._local_cache)
+        self._local_cache.clear()
+        self._local_cache_hits = 0
+        self._local_cache_misses = 0
+        logger.info("local_cache_cleared", entries_cleared=count)
+        return count
+
+    def get_local_cache_stats(self) -> dict:
+        """Get local cache performance statistics.
+
+        Returns:
+            Dict with cache stats (hits, misses, hit_rate, size)
+        """
+        total = self._local_cache_hits + self._local_cache_misses
+        hit_rate = (self._local_cache_hits / total * 100) if total > 0 else 0.0
+
+        return {
+            "enabled": self._local_cache_enabled,
+            "size": len(self._local_cache),
+            "max_size": self._local_cache_max_size,
+            "hits": self._local_cache_hits,
+            "misses": self._local_cache_misses,
+            "hit_rate": hit_rate,
+            "total_requests": total,
+        }
+
     # === Security Methods ===
 
     def _sanitize_data(self, data: Any) -> tuple[Any, int]:

empathy_os/memory/types.py

@@ -96,6 +96,10 @@ class RedisConfig:
     retry_base_delay: float = 0.1  # seconds
     retry_max_delay: float = 2.0  # seconds
 
+    # Local LRU cache settings (two-tier caching)
+    local_cache_enabled: bool = True  # Enable local memory cache (reduces Redis network I/O)
+    local_cache_size: int = 500  # Maximum number of cached keys (~50KB memory)
+
     # Sentinel settings (for HA)
     sentinel_hosts: list[tuple[str, int]] | None = None
     sentinel_master_name: str | None = None

empathy_os/models/registry.py

@@ -209,11 +209,11 @@ class ModelRegistry:
         """Build tier and model ID caches for O(1) lookups."""
         # Cache for get_models_by_tier (tier -> list[ModelInfo])
         self._tier_cache: dict[str, list[ModelInfo]] = {}
-        for tier in ModelTier:
-            self._tier_cache[tier.value] = [
-                provider_models[tier.value]
+        for tier_value in [t.value for t in ModelTier]:
+            self._tier_cache[tier_value] = [
+                provider_models[tier_value]
                 for provider_models in self._registry.values()
-                if tier.value in provider_models
+                if tier_value in provider_models
             ]
 
         # Cache for get_model_by_id (model_id -> ModelInfo)

empathy_os/project_index/scanner.py

@@ -470,8 +470,9 @@ class ProjectScanner:
         try:
             content = path.read_text(encoding="utf-8", errors="ignore")
             lines = content.split("\n")
-            metrics["lines_of_code"] = len(
-                [line for line in lines if line.strip() and not line.strip().startswith("#")],
+            # Use generator expression for memory efficiency (no intermediate list)
+            metrics["lines_of_code"] = sum(
+                1 for line in lines if line.strip() and not line.strip().startswith("#")
             )
 
             # Optimization: Skip expensive AST analysis for test files

empathy_os/socratic/ab_testing.py

@@ -20,7 +20,7 @@ import hashlib
 import json
 import logging
 import math
-import random  # Security Note: For A/B test simulation data, not cryptographic use
+import random
 import time
 from dataclasses import dataclass, field
 from datetime import datetime

empathy_os/workflow_commands.py

@@ -137,7 +137,7 @@ def morning_workflow(
     print("-" * 40)
 
     total_bugs = len(patterns.get("debugging", []))
-    resolved_bugs = len([p for p in patterns.get("debugging", []) if p.get("status") == "resolved"])
+    resolved_bugs = sum(1 for p in patterns.get("debugging", []) if p.get("status") == "resolved")
     security_decisions = len(patterns.get("security", []))
 
     print(f"  Bug patterns:        {total_bugs} ({resolved_bugs} resolved)")
@@ -207,14 +207,14 @@ def morning_workflow(
         checks_passed += 1
         print("  Lint:     OK")
     else:
-        issues = len([line for line in output.split("\n") if line.strip()])
+        issues = sum(1 for line in output.split("\n") if line.strip())
         print(f"  Lint:     {issues} issues")
 
     # Check for uncommitted changes
     checks_total += 1
     success, output = _run_command(["git", "status", "--porcelain"])
     if success:
-        changes = len([line for line in output.split("\n") if line.strip()])
+        changes = sum(1 for line in output.split("\n") if line.strip())
         if changes == 0:
             checks_passed += 1
             print("  Git:      Clean")
@@ -312,7 +312,7 @@ def _run_security_only(project_root: str = ".", verbose: bool = False) -> int:
     if not success or not output.strip():
         print("   PASS - No obvious hardcoded secrets")
     else:
-        lines = len([line for line in output.split("\n") if line.strip()])
+        lines = sum(1 for line in output.split("\n") if line.strip())
         issues.append(f"Secrets: {lines} potential hardcoded secrets")
         print(f"   WARN - {lines} potential hardcoded values found")
 
@@ -322,7 +322,7 @@ def _run_security_only(project_root: str = ".", verbose: bool = False) -> int:
     if not output.strip():
         print("   PASS - No sensitive files tracked")
     else:
-        files = len([line for line in output.split("\n") if line.strip()])
+        files = sum(1 for line in output.split("\n") if line.strip())
         issues.append(f"Files: {files} sensitive files in git")
         print(f"   WARN - {files} sensitive files tracked in git")
 
@@ -427,10 +427,10 @@ def ship_workflow(
     print("4. Checking git status...")
     success, output = _run_command(["git", "status", "--porcelain"])
     if success:
-        staged = len(
-            [line for line in output.split("\n") if line.startswith(("A ", "M ", "D ", "R "))],
+        staged = sum(
+            1 for line in output.split("\n") if line.startswith(("A ", "M ", "D ", "R "))
         )
-        unstaged = len([line for line in output.split("\n") if line.startswith((" M", " D", "??"))])
+        unstaged = sum(1 for line in output.split("\n") if line.startswith((" M", " D", "??")))
         if staged > 0:
             print(f"   INFO - {staged} staged, {unstaged} unstaged")
         elif unstaged > 0:
@@ -523,7 +523,7 @@ def fix_all_workflow(project_root: str = ".", dry_run: bool = False, verbose: bo
         print(f"   Fixed {fixed} issues")
     else:
         # Some issues couldn't be auto-fixed
-        unfixable = len([line for line in output.split("\n") if "error" in line.lower()])
+        unfixable = sum(1 for line in output.split("\n") if "error" in line.lower())
         print(f"   {unfixable} issues require manual fix")
         if verbose:
             print(output)

empathy_os/workflows/__init__.py

@@ -80,11 +80,9 @@ from .base import (
     get_workflow_stats,
 )
 
-# Builder pattern for workflow construction
-from .builder import WorkflowBuilder, workflow_builder
-
 # Config is small and frequently needed
 from .config import DEFAULT_MODELS, ModelConfig, WorkflowConfig, create_example_config, get_model
+from .step_config import WorkflowStepConfig, steps_from_tier_map, validate_step_config
 
 # Routing strategies (small, frequently needed for builder pattern)
 from .routing import (
@@ -94,7 +92,9 @@ from .routing import (
     RoutingContext,
     TierRoutingStrategy,
 )
-from .step_config import WorkflowStepConfig, steps_from_tier_map, validate_step_config
+
+# Builder pattern for workflow construction
+from .builder import WorkflowBuilder, workflow_builder
 
 # Lazy import mapping for workflow classes
 _LAZY_WORKFLOW_IMPORTS: dict[str, tuple[str, str]] = {

empathy_os/workflows/base.py

@@ -17,7 +17,6 @@ from __future__ import annotations
 
 import json
 import logging
-import sys
 import time
 import uuid
 from abc import ABC, abstractmethod
@@ -58,12 +57,7 @@ from empathy_os.models import ModelTier as UnifiedModelTier
 from .caching import CachedResponse, CachingMixin
 
 # Import progress tracking
-from .progress import (
-    RICH_AVAILABLE,
-    ProgressCallback,
-    ProgressTracker,
-    RichProgressReporter,
-)
+from .progress import ProgressCallback, ProgressTracker
 from .telemetry_mixin import TelemetryMixin
 
 # Import telemetry tracking
@@ -550,7 +544,6 @@ class BaseWorkflow(CachingMixin, TelemetryMixin, ABC):
         enable_tier_tracking: bool = True,
         enable_tier_fallback: bool = False,
         routing_strategy: TierRoutingStrategy | None = None,
-        enable_rich_progress: bool = False,
     ):
         """Initialize workflow with optional cost tracker, provider, and config.
 
@@ -576,11 +569,6 @@ class BaseWorkflow(CachingMixin, TelemetryMixin, ABC):
                      When provided, overrides static tier_map for stage tier decisions.
                      Strategies: CostOptimizedRouting, PerformanceOptimizedRouting,
                      BalancedRouting, HybridRouting.
-            enable_rich_progress: Whether to enable Rich-based live progress display
-                     (default False). When enabled and output is a TTY, shows live
-                     progress bars with spinners. Default is False because most users
-                     run workflows from IDEs (VSCode, etc.) where TTY is not available.
-                     The console reporter works reliably in all environments.
 
         """
         from .config import WorkflowConfig
@@ -591,8 +579,6 @@ class BaseWorkflow(CachingMixin, TelemetryMixin, ABC):
         # Progress tracking
         self._progress_callback = progress_callback
         self._progress_tracker: ProgressTracker | None = None
-        self._enable_rich_progress = enable_rich_progress
-        self._rich_reporter: RichProgressReporter | None = None
 
         # New: LLMExecutor support
         self._executor = executor
@@ -1069,39 +1055,15 @@ class BaseWorkflow(CachingMixin, TelemetryMixin, ABC):
         current_data = kwargs
         error = None
 
-        # Initialize progress tracker
-        # Always show progress by default (IDE-friendly console output)
-        # Rich live display only when explicitly enabled AND in TTY
-        from .progress import ConsoleProgressReporter
-
-        self._progress_tracker = ProgressTracker(
-            workflow_name=self.name,
-            workflow_id=self._run_id,
-            stage_names=self.stages,
-        )
-
-        # Add user's callback if provided
+        # Initialize progress tracker if callback provided
         if self._progress_callback:
+            self._progress_tracker = ProgressTracker(
+                workflow_name=self.name,
+                workflow_id=self._run_id,
+                stage_names=self.stages,
+            )
             self._progress_tracker.add_callback(self._progress_callback)
-
-        # Rich progress: only when explicitly enabled AND in a TTY
-        if self._enable_rich_progress and RICH_AVAILABLE and sys.stdout.isatty():
-            try:
-                self._rich_reporter = RichProgressReporter(self.name, self.stages)
-                self._progress_tracker.add_callback(self._rich_reporter.report)
-                self._rich_reporter.start()
-            except Exception as e:
-                # Fall back to console reporter
-                logger.debug(f"Rich progress unavailable: {e}")
-                self._rich_reporter = None
-                console_reporter = ConsoleProgressReporter(verbose=False)
-                self._progress_tracker.add_callback(console_reporter.report)
-        else:
-            # Default: use console reporter (works in IDEs, terminals, everywhere)
-            console_reporter = ConsoleProgressReporter(verbose=False)
-            self._progress_tracker.add_callback(console_reporter.report)
-
-        self._progress_tracker.start_workflow()
+            self._progress_tracker.start_workflow()
 
         try:
             # Tier fallback mode: try CHEAP → CAPABLE → PREMIUM with validation
@@ -1431,14 +1393,6 @@ class BaseWorkflow(CachingMixin, TelemetryMixin, ABC):
         if self._progress_tracker and error is None:
             self._progress_tracker.complete_workflow()
 
-        # Stop Rich progress display if active
-        if self._rich_reporter:
-            try:
-                self._rich_reporter.stop()
-            except Exception:
-                pass  # Best effort cleanup
-            self._rich_reporter = None
-
         # Save to workflow history for dashboard
         try:
             _save_workflow_run(self.name, provider_str, result)

empathy_os/workflows/bug_predict.py

@@ -695,7 +695,7 @@ class BugPredictionWorkflow(BaseWorkflow):
             {
                 "correlations": correlations,
                 "correlation_count": len(correlations),
-                "high_confidence_count": len([c for c in correlations if c["confidence"] > 0.6]),
+                "high_confidence_count": sum(1 for c in correlations if c["confidence"] > 0.6),
                 **input_data,
             },
             input_tokens,
@@ -759,7 +759,7 @@ class BugPredictionWorkflow(BaseWorkflow):
             {
                 "predictions": predictions[:20],  # Top 20 risky files
                 "overall_risk_score": round(self._risk_score, 2),
-                "high_risk_files": len([p for p in predictions if float(p["risk_score"]) > 0.7]),
+                "high_risk_files": sum(1 for p in predictions if float(p["risk_score"]) > 0.7),
                 **input_data,
             },
             input_tokens,

empathy_os/workflows/history.py

@@ -459,6 +459,10 @@ class WorkflowHistoryStore:
         Returns:
             Number of runs deleted
         """
+        cutoff = datetime.now().replace(
+            hour=0, minute=0, second=0, microsecond=0
+        ).isoformat()
+
         cursor = self.conn.cursor()
 
         # Get run IDs to delete
@@ -476,14 +480,12 @@ class WorkflowHistoryStore:
             return 0
 
         # Delete stages for these runs
-        # Security Note: f-string builds placeholder list only ("?, ?, ?")
-        # Actual data (run_ids) passed as parameters - SQL injection safe
         placeholders = ",".join("?" * len(run_ids))
         cursor.execute(
             f"DELETE FROM workflow_stages WHERE run_id IN ({placeholders})", run_ids
         )
 
-        # Delete runs (same safe parameterization pattern)
+        # Delete runs
         cursor.execute(
             f"DELETE FROM workflow_runs WHERE run_id IN ({placeholders})", run_ids
         )

empathy_os/workflows/perf_audit.py

@@ -269,10 +269,10 @@ class PerformanceAuditWorkflow(BaseWorkflow):
         # Analyze each file
         analysis: list[dict] = []
         for file_path, file_findings in by_file.items():
-            # Calculate file complexity score
-            high_count = len([f for f in file_findings if f["impact"] == "high"])
-            medium_count = len([f for f in file_findings if f["impact"] == "medium"])
-            low_count = len([f for f in file_findings if f["impact"] == "low"])
+            # Calculate file complexity score (generator expressions for memory efficiency)
+            high_count = sum(1 for f in file_findings if f["impact"] == "high")
+            medium_count = sum(1 for f in file_findings if f["impact"] == "medium")
+            low_count = sum(1 for f in file_findings if f["impact"] == "low")
 
             complexity_score = high_count * 10 + medium_count * 5 + low_count * 1