empathy-framework 3.7.0__py3-none-any.whl → 3.8.0__py3-none-any.whl

empathy_os/cache/storage.py

@@ -0,0 +1,282 @@
+"""Persistent disk storage for cache with TTL support.
+
+Provides hybrid in-memory + disk persistence for cache entries.
+
+Copyright 2025 Smart-AI-Memory
+Licensed under Fair Source License 0.9
+"""
+
+import json
+import logging
+import time
+from pathlib import Path
+from typing import Any
+
+from .base import CacheEntry
+
+logger = logging.getLogger(__name__)
+
+
+class CacheStorage:
+    """Hybrid in-memory + disk cache storage with TTL.
+
+    Provides:
+    - In-memory LRU cache for fast access
+    - Persistent disk storage for cache survival across restarts
+    - TTL-based expiration
+    - Automatic cleanup of expired entries
+
+    Example:
+        storage = CacheStorage()
+        storage.put(entry)
+        entry = storage.get(cache_key)
+
+    """
+
+    def __init__(
+        self,
+        cache_dir: Path | None = None,
+        max_disk_mb: int = 500,
+        auto_save: bool = True,
+    ):
+        """Initialize cache storage.
+
+        Args:
+            cache_dir: Directory for cache files (default: ~/.empathy/cache/).
+            max_disk_mb: Maximum disk cache size in MB.
+            auto_save: Automatically save to disk on put (default: True).
+
+        """
+        self.cache_dir = cache_dir or Path.home() / ".empathy" / "cache"
+        self.cache_file = self.cache_dir / "responses.json"
+        self.max_disk_mb = max_disk_mb
+        self.auto_save = auto_save
+
+        # Ensure cache directory exists
+        self.cache_dir.mkdir(parents=True, exist_ok=True)
+
+        # Load cache from disk
+        self._entries: dict[str, CacheEntry] = {}
+        self.load()
+
+        logger.debug(
+            f"CacheStorage initialized (dir: {self.cache_dir}, "
+            f"max: {max_disk_mb}MB, entries: {len(self._entries)})"
+        )
+
+    def load(self) -> int:
+        """Load cache from disk into memory.
+
+        Returns:
+            Number of entries loaded.
+
+        """
+        if not self.cache_file.exists():
+            logger.debug("No cache file found, starting fresh")
+            return 0
+
+        try:
+            with open(self.cache_file) as f:
+                data = json.load(f)
+
+            version = data.get("version", "unknown")
+            entries_data = data.get("entries", [])
+
+            # Load entries
+            loaded = 0
+            current_time = time.time()
+
+            for entry_data in entries_data:
+                entry = CacheEntry(
+                    key=entry_data["key"],
+                    response=entry_data["response"],
+                    workflow=entry_data["workflow"],
+                    stage=entry_data["stage"],
+                    model=entry_data["model"],
+                    prompt_hash=entry_data["prompt_hash"],
+                    timestamp=entry_data["timestamp"],
+                    ttl=entry_data.get("ttl"),
+                )
+
+                # Skip expired entries
+                if entry.is_expired(current_time):
+                    continue
+
+                self._entries[entry.key] = entry
+                loaded += 1
+
+            logger.info(
+                f"Loaded {loaded} cache entries from disk (version: {version}, "
+                f"skipped {len(entries_data) - loaded} expired)"
+            )
+            return loaded
+
+        except (json.JSONDecodeError, KeyError) as e:
+            logger.warning(f"Failed to load cache from disk: {e}")
+            return 0
+
+    def save(self) -> bool:
+        """Save cache to disk.
+
+        Returns:
+            True if saved successfully, False otherwise.
+
+        """
+        try:
+            # Prepare data
+            data = {
+                "version": "3.8.0",
+                "timestamp": time.time(),
+                "entries": [
+                    {
+                        "key": entry.key,
+                        "response": entry.response,
+                        "workflow": entry.workflow,
+                        "stage": entry.stage,
+                        "model": entry.model,
+                        "prompt_hash": entry.prompt_hash,
+                        "timestamp": entry.timestamp,
+                        "ttl": entry.ttl,
+                    }
+                    for entry in self._entries.values()
+                ],
+            }
+
+            # Write to disk
+            with open(self.cache_file, "w") as f:
+                json.dump(data, f, indent=2)
+
+            logger.debug(f"Saved {len(self._entries)} cache entries to disk")
+            return True
+
+        except (OSError, TypeError) as e:
+            logger.error(f"Failed to save cache to disk: {e}")
+            return False
+
+    def get(self, cache_key: str) -> CacheEntry | None:
+        """Get entry from storage.
+
+        Args:
+            cache_key: Cache key to lookup.
+
+        Returns:
+            CacheEntry if found and not expired, None otherwise.
+
+        """
+        if cache_key not in self._entries:
+            return None
+
+        entry = self._entries[cache_key]
+
+        # Check expiration
+        if entry.is_expired(time.time()):
+            del self._entries[cache_key]
+            return None
+
+        return entry
+
+    def put(self, entry: CacheEntry) -> None:
+        """Store entry in storage.
+
+        Args:
+            entry: CacheEntry to store.
+
+        """
+        self._entries[entry.key] = entry
+
+        # Auto-save to disk if enabled
+        if self.auto_save:
+            self.save()
+
+    def delete(self, cache_key: str) -> bool:
+        """Delete entry from storage.
+
+        Args:
+            cache_key: Key to delete.
+
+        Returns:
+            True if entry was deleted, False if not found.
+
+        """
+        if cache_key in self._entries:
+            del self._entries[cache_key]
+            if self.auto_save:
+                self.save()
+            return True
+        return False
+
+    def clear(self) -> int:
+        """Clear all entries.
+
+        Returns:
+            Number of entries cleared.
+
+        """
+        count = len(self._entries)
+        self._entries.clear()
+
+        if self.auto_save:
+            self.save()
+
+        return count
+
+    def evict_expired(self) -> int:
+        """Remove all expired entries.
+
+        Returns:
+            Number of entries evicted.
+
+        """
+        current_time = time.time()
+        expired_keys = [
+            key for key, entry in self._entries.items() if entry.is_expired(current_time)
+        ]
+
+        for key in expired_keys:
+            del self._entries[key]
+
+        if expired_keys and self.auto_save:
+            self.save()
+
+        return len(expired_keys)
+
+    def get_all(self) -> list[CacheEntry]:
+        """Get all non-expired entries.
+
+        Returns:
+            List of CacheEntry objects.
+
+        """
+        current_time = time.time()
+        return [entry for entry in self._entries.values() if not entry.is_expired(current_time)]
+
+    def size_mb(self) -> float:
+        """Estimate cache size in MB.
+
+        Returns:
+            Estimated size in megabytes.
+
+        """
+        if not self.cache_file.exists():
+            return 0.0
+
+        return self.cache_file.stat().st_size / (1024 * 1024)
+
+    def stats(self) -> dict[str, Any]:
+        """Get storage statistics.
+
+        Returns:
+            Dictionary with storage metrics.
+
+        """
+        current_time = time.time()
+        expired = sum(1 for entry in self._entries.values() if entry.is_expired(current_time))
+
+        return {
+            "total_entries": len(self._entries),
+            "expired_entries": expired,
+            "active_entries": len(self._entries) - expired,
+            "disk_size_mb": round(self.size_mb(), 2),
+            "max_disk_mb": self.max_disk_mb,
+            "cache_dir": str(self.cache_dir),
+        }

empathy_os/cli.py

@@ -26,6 +26,7 @@ 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,
@@ -284,7 +285,9 @@ def cmd_version(args):
     logger.info("Displaying version information")
     try:
         version = get_version("empathy")
-    except Exception:
+    except Exception as e:
+        # Package metadata not available or invalid (development install)
+        logger.debug(f"Version not available: {e}")
         version = "unknown"
     logger.info(f"Empathy v{version}")
     logger.info("Copyright 2025 Smart-AI-Memory")
@@ -640,10 +643,21 @@ def cmd_validate(args):
         logger.info(f"  Confidence Threshold: {config.confidence_threshold}")
         logger.info(f"  Persistence Backend: {config.persistence_backend}")
         logger.info(f"  Metrics Enabled: {config.metrics_enabled}")
-    except Exception as e:
+    except (OSError, FileNotFoundError) as e:
+        # Config file not found or cannot be read
+        logger.error(f"Configuration file error: {e}")
+        logger.error(f"✗ Cannot read configuration file: {e}")
+        sys.exit(1)
+    except ValueError as e:
+        # Invalid configuration values
         logger.error(f"Configuration validation failed: {e}")
         logger.error(f"✗ Configuration invalid: {e}")
         sys.exit(1)
+    except Exception as e:
+        # Unexpected errors during config validation
+        logger.exception(f"Unexpected error validating configuration: {e}")
+        logger.error(f"✗ Configuration invalid: {e}")
+        sys.exit(1)
 
 
 def cmd_info(args):
@@ -734,8 +748,19 @@ def cmd_patterns_export(args):
 
         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:
-        logger.error(f"Failed to load patterns: {e}")
+        # Unexpected errors loading patterns
+        logger.exception(f"Unexpected error loading patterns: {e}")
         logger.error(f"✗ Failed to load patterns: {e}")
         sys.exit(1)
 
@@ -748,8 +773,14 @@ def cmd_patterns_export(args):
 
         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:
-        logger.error(f"Failed to save patterns: {e}")
+        # Unexpected errors saving patterns
+        logger.exception(f"Unexpected error saving patterns: {e}")
         logger.error(f"✗ Failed to save patterns: {e}")
         sys.exit(1)
 
@@ -1041,8 +1072,19 @@ def cmd_metrics_show(args):
         logger.info(f"  Level 3: {stats.get('level_3_count', 0)} uses")
         logger.info(f"  Level 4: {stats.get('level_4_count', 0)} uses")
         logger.info(f"  Level 5: {stats.get('level_5_count', 0)} uses")
+    except (OSError, FileNotFoundError) as e:
+        # Database file not found
+        logger.error(f"Metrics database error: {e}")
+        logger.error(f"✗ Cannot read metrics database: {e}")
+        sys.exit(1)
+    except KeyError as e:
+        # User not found in database
+        logger.error(f"User not found in metrics: {e}")
+        logger.error(f"✗ User {user_id} not found: {e}")
+        sys.exit(1)
     except Exception as e:
-        logger.error(f"Failed to retrieve metrics for user {user_id}: {e}")
+        # Unexpected errors retrieving metrics
+        logger.exception(f"Unexpected error retrieving metrics for user {user_id}: {e}")
         logger.error(f"✗ Failed to retrieve metrics: {e}")
         sys.exit(1)
 
@@ -1096,7 +1138,17 @@ def cmd_run(args):
             persistence_enabled=config.persistence_enabled,
         )
         print("✓ Empathy OS initialized")
+    except ValueError as e:
+        # Invalid configuration parameters
+        print(f"✗ Configuration error: {e}")
+        sys.exit(1)
+    except (OSError, FileNotFoundError, PermissionError) as e:
+        # Cannot access required files/directories
+        print(f"✗ File system error: {e}")
+        sys.exit(1)
     except Exception as e:
+        # Unexpected initialization failure
+        logger.exception(f"Unexpected error initializing Empathy OS: {e}")
         print(f"✗ Failed to initialize Empathy OS: {e}")
         sys.exit(1)
 
@@ -1180,7 +1232,12 @@ def cmd_run(args):
         except KeyboardInterrupt:
             print("\n\n👋 Goodbye!")
             break
+        except (ValueError, KeyError) as e:
+            # Invalid input or response structure
+            print(f"\n✗ Input error: {e}\n")
         except Exception as e:
+            # Unexpected errors in interactive loop - log and continue
+            logger.exception(f"Unexpected error in interactive loop: {e}")
             print(f"\n✗ Error: {e}\n")
 
 
@@ -1223,7 +1280,13 @@ def cmd_inspect(args):
             print(f"✗ Pattern library not found: {db_path}")
             print("  Tip: Use 'empathy-framework wizard' to set up your first project")
             sys.exit(1)
+        except (ValueError, KeyError) as e:
+            # Invalid pattern data format
+            print(f"✗ Invalid pattern data: {e}")
+            sys.exit(1)
         except Exception as e:
+            # Unexpected errors loading patterns
+            logger.exception(f"Unexpected error loading patterns: {e}")
             print(f"✗ Failed to load patterns: {e}")
             sys.exit(1)
 
@@ -1245,7 +1308,17 @@ def cmd_inspect(args):
             for level in range(1, 6):
                 count = stats.get(f"level_{level}_count", 0)
                 print(f"    Level {level}: {count} times")
+        except (OSError, FileNotFoundError) as e:
+            # Database file not found
+            print(f"✗ Metrics database not found: {e}")
+            sys.exit(1)
+        except KeyError as e:
+            # User not found
+            print(f"✗ User {user_id} not found: {e}")
+            sys.exit(1)
         except Exception as e:
+            # Unexpected errors loading metrics
+            logger.exception(f"Unexpected error loading metrics: {e}")
             print(f"✗ Failed to load metrics: {e}")
             sys.exit(1)
 
@@ -1262,7 +1335,13 @@ def cmd_inspect(args):
                 print("\n  Users:")
                 for uid in users:
                     print(f"    • {uid}")
+        except (OSError, FileNotFoundError) as e:
+            # State directory not found
+            print(f"✗ State directory not found: {e}")
+            sys.exit(1)
         except Exception as e:
+            # Unexpected errors loading state
+            logger.exception(f"Unexpected error loading state: {e}")
             print(f"✗ Failed to load state: {e}")
             sys.exit(1)
 
@@ -1314,7 +1393,17 @@ def cmd_export(args):
         print(f"✗ Source file not found: {db_path}")
         print("  Tip: Patterns are saved automatically when using the framework")
         sys.exit(1)
+    except (OSError, PermissionError) as e:
+        # Cannot write output file
+        print(f"✗ Cannot write to file: {e}")
+        sys.exit(1)
+    except (ValueError, KeyError) as e:
+        # Invalid pattern data
+        print(f"✗ Invalid pattern data: {e}")
+        sys.exit(1)
     except Exception as e:
+        # Unexpected errors during export
+        logger.exception(f"Unexpected error exporting patterns: {e}")
         print(f"✗ Export failed: {e}")
         sys.exit(1)
 
@@ -1367,7 +1456,17 @@ def cmd_import(args):
     except FileNotFoundError:
         print(f"✗ Input file not found: {input_file}")
         sys.exit(1)
+    except (ValueError, KeyError) as e:
+        # Invalid pattern data format
+        print(f"✗ Invalid pattern data: {e}")
+        sys.exit(1)
+    except (OSError, PermissionError) as e:
+        # Cannot read input or write to database
+        print(f"✗ File access error: {e}")
+        sys.exit(1)
     except Exception as e:
+        # Unexpected errors during import
+        logger.exception(f"Unexpected error importing patterns: {e}")
         print(f"✗ Import failed: {e}")
         sys.exit(1)
 
@@ -1940,7 +2039,11 @@ def cmd_workflow(args):
                         else:
                             try:
                                 final_output_serializable[k] = str(v)
-                            except Exception:
+                            except Exception as e:  # noqa: BLE001
+                                # INTENTIONAL: Silently skip any non-serializable objects
+                                # This is a best-effort serialization for JSON output
+                                # We cannot predict all possible object types users might return
+                                logger.debug(f"Cannot serialize field {k}: {e}")
                                 pass
                 else:
                     final_output_serializable = None
@@ -2668,6 +2771,9 @@ def main():
     )
     parser_achievements.set_defaults(func=cmd_achievements)
 
+    # Wizard Factory commands (create wizards 12x faster)
+    add_wizard_factory_commands(subparsers)
+
     # Parse arguments
     args = parser.parse_args()
 
@@ -2679,8 +2785,12 @@ def main():
         if args.command and args.command not in ("dashboard", "run"):
             try:
                 show_tip_if_available(args.command)
-            except Exception:
-                pass  # Don't fail on discovery errors
+            except Exception as e:  # noqa: BLE001
+                # INTENTIONAL: Discovery tips are optional UX enhancements
+                # They should never cause command execution to fail
+                # Cannot predict all possible errors from discovery system
+                logger.debug(f"Discovery tip not available for {args.command}: {e}")
+                pass
 
         return result if result is not None else 0
     parser.print_help()

empathy_os/cli_unified.py

@@ -372,6 +372,78 @@ def wizard_run(
     subprocess.run(["empathy-scan", str(path), "--wizards", name], check=False)
 
 
+@wizard_app.command("create")
+def wizard_create(
+    name: str = typer.Argument(..., help="Wizard name (snake_case)"),
+    domain: str = typer.Option(
+        ..., "--domain", "-d", help="Domain (healthcare, finance, software)"
+    ),
+    wizard_type: str = typer.Option(
+        "domain", "--type", "-t", help="Wizard type (domain, coach, ai)"
+    ),
+    methodology: str = typer.Option(
+        "pattern", "--methodology", "-m", help="Methodology (pattern, tdd)"
+    ),
+    patterns: str | None = typer.Option(
+        None, "--patterns", "-p", help="Comma-separated pattern IDs"
+    ),
+    interactive: bool = typer.Option(
+        False, "--interactive", "-i", help="Interactive pattern selection"
+    ),
+):
+    """Create a new wizard using Wizard Factory (12x faster)."""
+    cmd = [
+        sys.executable,
+        "-m",
+        "scaffolding",
+        "create",
+        name,
+        "--domain",
+        domain,
+        "--type",
+        wizard_type,
+        "--methodology",
+        methodology,
+    ]
+    if patterns:
+        cmd.extend(["--patterns", patterns])
+    if interactive:
+        cmd.append("--interactive")
+    subprocess.run(cmd, check=False)
+
+
+@wizard_app.command("list-patterns")
+def wizard_list_patterns():
+    """List all available wizard patterns."""
+    subprocess.run([sys.executable, "-m", "scaffolding", "list-patterns"], check=False)
+
+
+@wizard_app.command("generate-tests")
+def wizard_generate_tests(
+    wizard_id: str = typer.Argument(..., help="Wizard ID"),
+    patterns: str = typer.Option(..., "--patterns", "-p", help="Comma-separated pattern IDs"),
+    output: Path | None = typer.Option(None, "--output", "-o", help="Output directory"),
+):
+    """Generate tests for a wizard."""
+    cmd = [sys.executable, "-m", "test_generator", "generate", wizard_id, "--patterns", patterns]
+    if output:
+        cmd.extend(["--output", str(output)])
+    subprocess.run(cmd, check=False)
+
+
+@wizard_app.command("analyze")
+def wizard_analyze(
+    wizard_id: str = typer.Argument(..., help="Wizard ID"),
+    patterns: str = typer.Option(..., "--patterns", "-p", help="Wizard ID"),
+    json_output: bool = typer.Option(False, "--json", help="Output JSON format"),
+):
+    """Analyze wizard risk and get coverage recommendations."""
+    cmd = [sys.executable, "-m", "test_generator", "analyze", wizard_id, "--patterns", patterns]
+    if json_output:
+        cmd.append("--json")
+    subprocess.run(cmd, check=False)
+
+
 # =============================================================================
 # WORKFLOW SUBCOMMAND GROUP
 # =============================================================================
@@ -397,6 +469,50 @@ def workflow_run(
     )
 
 
+@workflow_app.command("create")
+def workflow_create(
+    name: str = typer.Argument(..., help="Workflow name (kebab-case, e.g., bug-scanner)"),
+    description: str = typer.Option(None, "--description", "-d", help="Workflow description"),
+    patterns: str = typer.Option(None, "--patterns", "-p", help="Comma-separated pattern IDs"),
+    stages: str = typer.Option(None, "--stages", "-s", help="Comma-separated stage names"),
+    tier_map: str = typer.Option(
+        None, "--tier-map", "-t", help="Tier map (e.g., analyze:CHEAP,process:CAPABLE)"
+    ),
+    output: Path = typer.Option(None, "--output", "-o", help="Output directory"),
+):
+    """Create a new workflow using Workflow Factory (12x faster)."""
+    cmd = [sys.executable, "-m", "workflow_scaffolding", "create", name]
+    if description:
+        cmd.extend(["--description", description])
+    if patterns:
+        cmd.extend(["--patterns", patterns])
+    if stages:
+        cmd.extend(["--stages", stages])
+    if tier_map:
+        cmd.extend(["--tier-map", tier_map])
+    if output:
+        cmd.extend(["--output", str(output)])
+    subprocess.run(cmd, check=False)
+
+
+@workflow_app.command("list-patterns")
+def workflow_list_patterns():
+    """List available workflow patterns."""
+    subprocess.run([sys.executable, "-m", "workflow_scaffolding", "list-patterns"], check=False)
+
+
+@workflow_app.command("recommend")
+def workflow_recommend(
+    workflow_type: str = typer.Argument(
+        ..., help="Workflow type (code-analysis, simple, multi-agent, etc.)"
+    ),
+):
+    """Recommend patterns for a workflow type."""
+    subprocess.run(
+        [sys.executable, "-m", "workflow_scaffolding", "recommend", workflow_type], check=False
+    )
+
+
 # =============================================================================
 # UTILITY COMMANDS
 # =============================================================================
@@ -435,10 +551,14 @@ def cheatsheet():
 [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 run <name> Execute a wizard
+  empathy wizard create <name> -d <domain>  Create wizard (12x faster)
+  empathy wizard list-patterns              List available patterns""",
             title="[bold blue]Empathy Framework Cheatsheet[/bold blue]",
         ),
     )