empathy-framework 3.5.3__py3-none-any.whl → 3.5.6__py3-none-any.whl

{empathy_framework-3.5.3.dist-info → empathy_framework-3.5.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: empathy-framework
-Version: 3.5.3
+Version: 3.5.6
 Summary: AI collaboration framework with persistent memory, anticipatory intelligence, code inspection, and multi-agent orchestration
 Author-email: Patrick Roebuck <patrick.roebuck@smartAImemory.com>
 Maintainer-email: Smart-AI-Memory <patrick.roebuck@smartAImemory.com>
@@ -225,6 +225,8 @@ Requires-Dist: ruff<1.0,>=0.1; extra == "dev"
 Requires-Dist: coverage<8.0,>=7.0; extra == "dev"
 Requires-Dist: bandit<2.0,>=1.7; extra == "dev"
 Requires-Dist: pre-commit<4.0,>=3.0; extra == "dev"
+Requires-Dist: httpx<1.0.0,>=0.27.0; extra == "dev"
+Requires-Dist: fastapi<1.0.0,>=0.109.1; extra == "dev"
 Provides-Extra: full
 Requires-Dist: anthropic<1.0.0,>=0.8.0; extra == "full"
 Requires-Dist: openai<2.0.0,>=1.6.0; extra == "full"
@@ -276,8 +278,8 @@ Dynamic: license-file
 **The AI collaboration framework that predicts problems before they happen.**
 
 [![PyPI](https://img.shields.io/pypi/v/empathy-framework)](https://pypi.org/project/empathy-framework/)
-[![Tests](https://img.shields.io/badge/tests-3%2C564%20passing-brightgreen)](https://github.com/Smart-AI-Memory/empathy-framework/actions)
-[![Coverage](https://img.shields.io/badge/coverage-55%25-yellow)](https://github.com/Smart-AI-Memory/empathy-framework)
+[![Tests](https://img.shields.io/badge/tests-5%2C603%20passing-brightgreen)](https://github.com/Smart-AI-Memory/empathy-framework/actions)
+[![Coverage](https://img.shields.io/badge/coverage-64%25-yellow)](https://github.com/Smart-AI-Memory/empathy-framework)
 [![License](https://img.shields.io/badge/license-Fair%20Source%200.9-blue)](LICENSE)
 [![Python](https://img.shields.io/badge/python-3.10+-blue)](https://www.python.org)
 
@@ -287,6 +289,12 @@ pip install empathy-framework[full]
 
 ## What's New in v3.5.x
 
+### Project Indexing & Test Suite Expansion (v3.5.4)
+
+- **Project Indexing System** — JSON-based file tracking with automatic structure scanning, metadata tracking, and CrewAI integration
+- **5,603 Tests** — Comprehensive test coverage at 64% with 30+ new test modules
+- **BaselineManager Fix** — Resolved test isolation bug affecting suppression system
+
 ### Memory API Security Hardening (v3.5.0)
 
 - **Input Validation** — Pattern IDs, agent IDs, and classifications validated to prevent path traversal and injection attacks

{empathy_framework-3.5.3.dist-info → empathy_framework-3.5.6.dist-info}/RECORD

@@ -32,29 +32,29 @@ coach_wizards/refactoring_wizard.py,sha256=1AuRyX45KI63n_-fvvbRXamqvPbrB-O1B7TPP
 coach_wizards/scaling_wizard.py,sha256=yLULCkflLoBKS4hOSBPQuKKGBGHgKExnuEp5WLTIY-8,2596
 coach_wizards/security_wizard.py,sha256=tr1iq0egAMLCM-wOFhTDN5dHQRFuhSshXSkv17Jm7eM,2603
 coach_wizards/testing_wizard.py,sha256=M2RtaTa1WHsk42svJAEZpLySU3PXJJZn2jigouMJrG0,2561
-empathy_framework-3.5.3.dist-info/licenses/LICENSE,sha256=IJ9eeI5KSrD5P7alsn7sI_6_1bDihxBA5S4Sen4jf2k,4937
+empathy_framework-3.5.6.dist-info/licenses/LICENSE,sha256=IJ9eeI5KSrD5P7alsn7sI_6_1bDihxBA5S4Sen4jf2k,4937
 empathy_healthcare_plugin/__init__.py,sha256=FvVcD7WQTlmCCLgSPfM-FPT2l-ma1oAACBZWhtYFAUA,296
 empathy_healthcare_plugin/protocols/cardiac.json,sha256=uShOvI2RQJYLZacLT2R_aHfsjvJdyCu_gYfpMfK3N74,2088
 empathy_healthcare_plugin/protocols/post_operative.json,sha256=nqh3ydPY8FNSLv-Q3QmH8Dsyc1c4LvQxUSP84B8W6xk,2021
 empathy_healthcare_plugin/protocols/respiratory.json,sha256=wNDprggFDGRxxHNwchC19N8aoyaN74RnhYN7lNookDI,2136
 empathy_healthcare_plugin/protocols/sepsis.json,sha256=yXKt8QmDaAeTgHitqJJ-N9J9pkHRqGxZM_jJl_wDG6A,3631
 empathy_llm_toolkit/README.md,sha256=wKfp80nOvQkyU2qkBMAdF9cPPR3iaHuia_2AfiXVaFM,12273
-empathy_llm_toolkit/__init__.py,sha256=f-03NR50lLHZ1gYwOUm8crn-bsrJZq2WQs9ZG3gTyaY,667
+empathy_llm_toolkit/__init__.py,sha256=hpDQmnshhXdcTyvdGRDNv6hqLSzj0RBPGixFHvmAjcQ,705
 empathy_llm_toolkit/claude_memory.py,sha256=L4XaIDR_5yugYz4ITJw3ofWBxYQWeI3W3Cfs09TB2_Y,14872
 empathy_llm_toolkit/code_health.py,sha256=hc0dRN00xb4An3KPXAbNp3Tp076a2GnJ1MlPGH7HHM0,42438
 empathy_llm_toolkit/contextual_patterns.py,sha256=pC2LU4z8dNRcCj0TWZB_LSyXeAdt7me5WKmdt2dfXFk,12056
-empathy_llm_toolkit/core.py,sha256=8HZ0NlddDuI4Cx4-tMB-eCdCF2Jdt6NtjbBFWLemADY,34317
+empathy_llm_toolkit/core.py,sha256=Ts8OUASBLjNxiRvDbkvCiXo5aN-lmYRXUVQO_OW4b7w,34499
 empathy_llm_toolkit/git_pattern_extractor.py,sha256=L_BFi5ZLOhKbXZqLon4bJpHRrZk4dt-ICQ_R3YQftZg,14756
 empathy_llm_toolkit/levels.py,sha256=8iH_mPRh72yFZ0wJgSB6K20XZTdfnw4gBanX6_4P6n8,7178
 empathy_llm_toolkit/pattern_confidence.py,sha256=M9w37N621c7gA21U0cI0ApaV9TFKoQtP4dhUfjmzf7I,14207
 empathy_llm_toolkit/pattern_resolver.py,sha256=uvrRZfROMQkaghTLHr7b6OtB6MlW-mgAV3_Il0LWBMk,9330
 empathy_llm_toolkit/pattern_summary.py,sha256=q3gPMZtk5TIG9hs61mEZzaBtpry0qVfbu2lXryunhQs,12265
-empathy_llm_toolkit/providers.py,sha256=M_DrZr7Yq5c2edEoUGH20LUI9nmi9KOkqDvTku2dhBw,13958
+empathy_llm_toolkit/providers.py,sha256=vfN5u_9e4BVUj8hR4HSZTGOLPfiH4k7ffk_Q7Zqf57o,19811
 empathy_llm_toolkit/session_status.py,sha256=pJwqHwbVwR2Q6coRkB_34CWRCMoF-r4-YBtQWEO1Mj8,25724
 empathy_llm_toolkit/state.py,sha256=oi8bPqUHkmfgkfT4_4eD1ndIGH_THyLQDYlIWZLUx5s,8051
 empathy_os/__init__.py,sha256=pvaca4oCfdL4MG5WO-RKJeXBOk0oj02Mhh_E0h7zSyY,5896
-empathy_os/cli.py,sha256=k3r_0as7mtOPnLyp3cNKRQiLSKYJqFlmYuRuhdiRrwM,87001
-empathy_os/cli_unified.py,sha256=TvfsheONim8ETegZo3KJA2vBtFD0fn0rRikUz83w1Dg,14021
+empathy_os/cli.py,sha256=BKZHQeOLcocO6FIHn5wgnEK84KY4APlGulWwL2tpKOE,93218
+empathy_os/cli_unified.py,sha256=YLNjgZRaeaJn72_4vUpkDK9g70as0upfyDQTmcC7aeY,14029
 empathy_os/config.py,sha256=itgEYHR3QOxtjObHqnYGoQ48863Mf16UoGPyc_l8gNE,14803
 empathy_os/coordination.py,sha256=0jKt2DzzJmFjpXJs4pMXBcUktCFHsa9i3rkXzXxykGk,28656
 empathy_os/core.py,sha256=kL_37DajqIV1_b0ldee8rGG0xUTrSzAqYuQ4dowSxuw,53229
@@ -70,11 +70,11 @@ empathy_os/monitoring.py,sha256=76Fiwqd8prqi6H_mMX79_yEPbfbPdx58E9ZfLld6fvw,1343
 empathy_os/pattern_library.py,sha256=jUeWRnRHbhB05Rm9kL-OFdMajRCOqOzOb9ow_23JdY0,14040
 empathy_os/persistence.py,sha256=2jNqPmW6TrCH2quYph2SVMQnAnhBDDVk9DqNuEhLhGE,17637
 empathy_os/platform_utils.py,sha256=8R35nql5f1cuMwWz9JKM_Nx_Gf9rGhCiAleEmIk8WVY,7343
-empathy_os/redis_config.py,sha256=L8KoHFwhl-_twSswMfELUgOmANOTPRB9Yj8VXuxfSb4,5947
+empathy_os/redis_config.py,sha256=sX7EAXxRd8pL3r1E-Oa5yke_j-wYIQ1PI9jzaNZjlrs,9778
 empathy_os/redis_memory.py,sha256=lWS_F4FeDkmEI-jIgkPTzs3D8TTDB0627WsOxYMT-XM,23276
 empathy_os/templates.py,sha256=ap4u9i5O9KA83wWLfoUCS7phDHKb6wj8M1Zcm218lN0,17069
 empathy_os/trust_building.py,sha256=8ZvNwJmeDyKeUIkk_331M9jwKcqrsn6K43gnGtnIXbM,18790
-empathy_os/workflow_commands.py,sha256=ZfACBQKjaAfEZER4yRRsFVw9IfGhhPVGwQyBjD1HUAk,21904
+empathy_os/workflow_commands.py,sha256=Kqyr8ICTsx4S-_ThXB52SYzH1mYFsHGVDYiG2KgkQGo,21904
 empathy_software_plugin/SOFTWARE_PLUGIN_README.md,sha256=RXIOB9Mt-8JrfGAA3ZUuRPT34sThubrwUgg5iNcSKIc,22591
 empathy_software_plugin/__init__.py,sha256=Ylyj95pSsoN9Zasam96DH61uBHoMJh3kbhO7k_VaCWo,310
 empathy_software_plugin/cli.py,sha256=GrZWpnFJ9allM9sYrh8rSxSlVDU6RZVnEy4FYg-dSG8,22366
@@ -96,8 +96,8 @@ wizards/sbar_wizard.py,sha256=CJ63JAXwcfBf6C3aYyxY2LODbARP9GPl0ZGJWLbx88E,21790
 wizards/shift_handoff_wizard.py,sha256=SkoNB0nLQGg92yz4j1j3NBR2mGVe_rw1pTjOFDy-JH0,19092
 wizards/soap_note_wizard.py,sha256=DBzuuuOvIONhwdfn8jaE4PCuGeKsFwM65XTb6gKFIy4,23572
 wizards/treatment_plan.py,sha256=t2Qk5eCa1gobEUaBztnwem_p9OuJK5BKqJ-Po8vXuns,512
-empathy_framework-3.5.3.dist-info/METADATA,sha256=uPh-xQ7AhdkP5Qt6NPFuqEF8DXsqXYGU9828SOWfQ8E,29770
-empathy_framework-3.5.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-empathy_framework-3.5.3.dist-info/entry_points.txt,sha256=zMu7sKCiLndbEEXjTecltS-1P_JZoEUKrifuRBBbroc,1268
-empathy_framework-3.5.3.dist-info/top_level.txt,sha256=8zHB-_f0MI2K55LIEjCeaFNcog3_KgLBa_dDfzE8ESI,110
-empathy_framework-3.5.3.dist-info/RECORD,,
+empathy_framework-3.5.6.dist-info/METADATA,sha256=Ay9yi3cPZaMwrSBVgh8V8syC3YzRy8mF76AEQcEBrVw,30238
+empathy_framework-3.5.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+empathy_framework-3.5.6.dist-info/entry_points.txt,sha256=zMu7sKCiLndbEEXjTecltS-1P_JZoEUKrifuRBBbroc,1268
+empathy_framework-3.5.6.dist-info/top_level.txt,sha256=8zHB-_f0MI2K55LIEjCeaFNcog3_KgLBa_dDfzE8ESI,110
+empathy_framework-3.5.6.dist-info/RECORD,,

empathy_llm_toolkit/__init__.py

@@ -12,7 +12,7 @@ Licensed under Fair Source 0.9
 
 from .core import EmpathyLLM
 from .levels import EmpathyLevel
-from .providers import AnthropicProvider, LocalProvider, OpenAIProvider
+from .providers import AnthropicProvider, GeminiProvider, LocalProvider, OpenAIProvider
 from .state import CollaborationState, UserPattern
 
 __version__ = "1.9.5"
@@ -21,6 +21,7 @@ __all__ = [
     "EmpathyLLM",
     "OpenAIProvider",
     "AnthropicProvider",
+    "GeminiProvider",
     "LocalProvider",
     "CollaborationState",
     "UserPattern",

empathy_llm_toolkit/core.py

@@ -23,7 +23,13 @@ from empathy_os.memory import (
 )
 
 from .levels import EmpathyLevel
-from .providers import AnthropicProvider, BaseLLMProvider, LocalProvider, OpenAIProvider
+from .providers import (
+    AnthropicProvider,
+    BaseLLMProvider,
+    GeminiProvider,
+    LocalProvider,
+    OpenAIProvider,
+)
 from .routing import ModelRouter
 from .state import CollaborationState, PatternType, UserPattern
 
@@ -218,6 +224,8 @@ class EmpathyLLM:
             )
         elif provider == "openai":
             return OpenAIProvider(api_key=api_key, model=model or "gpt-4-turbo-preview", **kwargs)
+        elif provider in ("google", "gemini"):
+            return GeminiProvider(api_key=api_key, model=model or "gemini-1.5-pro", **kwargs)
         elif provider == "local":
             return LocalProvider(
                 endpoint=kwargs.get("endpoint", "http://localhost:11434"),

empathy_llm_toolkit/providers.py

@@ -372,6 +372,183 @@ class OpenAIProvider(BaseLLMProvider):
         )
 
 
+class GeminiProvider(BaseLLMProvider):
+    """
+    Google Gemini provider with cost tracking integration.
+
+    Supports Gemini models:
+    - gemini-2.0-flash-exp: Fast, cheap tier (1M context)
+    - gemini-1.5-pro: Balanced, capable tier (2M context)
+    - gemini-2.5-pro: Premium reasoning tier
+    """
+
+    def __init__(
+        self,
+        api_key: str | None = None,
+        model: str = "gemini-1.5-pro",
+        **kwargs,
+    ):
+        super().__init__(api_key, **kwargs)
+        self.model = model
+
+        # Validate API key is provided
+        if not api_key or not api_key.strip():
+            raise ValueError(
+                "API key is required for Gemini provider. "
+                "Provide via api_key parameter or GOOGLE_API_KEY environment variable"
+            )
+
+        # Lazy import to avoid requiring google-generativeai if not used
+        try:
+            import google.generativeai as genai
+
+            genai.configure(api_key=api_key)
+            self.genai = genai
+            self.client = genai.GenerativeModel(model)
+        except ImportError as e:
+            raise ImportError(
+                "google-generativeai package required. Install with: pip install google-generativeai"
+            ) from e
+
+    async def generate(
+        self,
+        messages: list[dict[str, str]],
+        system_prompt: str | None = None,
+        temperature: float = 0.7,
+        max_tokens: int = 1024,
+        **kwargs,
+    ) -> LLMResponse:
+        """
+        Generate response using Google Gemini API.
+
+        Gemini-specific features:
+        - Large context windows (1M-2M tokens)
+        - Multimodal support
+        - Grounding with Google Search
+        """
+        import asyncio
+
+        # Convert messages to Gemini format
+        gemini_messages = []
+        for msg in messages:
+            role = "user" if msg["role"] == "user" else "model"
+            gemini_messages.append({"role": role, "parts": [msg["content"]]})
+
+        # Build generation config
+        generation_config = self.genai.GenerationConfig(
+            temperature=temperature,
+            max_output_tokens=max_tokens,
+        )
+
+        # Create model with system instruction if provided
+        if system_prompt:
+            model = self.genai.GenerativeModel(
+                self.model,
+                system_instruction=system_prompt,
+            )
+        else:
+            model = self.client
+
+        # Call Gemini API (run sync in thread pool for async compatibility)
+        loop = asyncio.get_event_loop()
+        response = await loop.run_in_executor(
+            None,
+            lambda: model.generate_content(
+                gemini_messages,
+                generation_config=generation_config,
+            ),
+        )
+
+        # Extract token counts from usage metadata
+        input_tokens = 0
+        output_tokens = 0
+        if hasattr(response, "usage_metadata"):
+            input_tokens = getattr(response.usage_metadata, "prompt_token_count", 0)
+            output_tokens = getattr(response.usage_metadata, "candidates_token_count", 0)
+
+        # Log to cost tracker
+        try:
+            from empathy_os.cost_tracker import log_request
+
+            tier = self._get_tier()
+            log_request(
+                model=self.model,
+                input_tokens=input_tokens,
+                output_tokens=output_tokens,
+                task_type=kwargs.get("task_type", "gemini_generate"),
+                tier=tier,
+            )
+        except ImportError:
+            pass  # Cost tracking not available
+
+        # Convert to standardized format
+        content = ""
+        if response.candidates:
+            content = response.candidates[0].content.parts[0].text
+
+        finish_reason = "stop"
+        if response.candidates and hasattr(response.candidates[0], "finish_reason"):
+            finish_reason = str(response.candidates[0].finish_reason.name).lower()
+
+        return LLMResponse(
+            content=content,
+            model=self.model,
+            tokens_used=input_tokens + output_tokens,
+            finish_reason=finish_reason,
+            metadata={
+                "input_tokens": input_tokens,
+                "output_tokens": output_tokens,
+                "provider": "google",
+                "model_family": "gemini",
+            },
+        )
+
+    def _get_tier(self) -> str:
+        """Determine tier from model name."""
+        if "flash" in self.model.lower():
+            return "cheap"
+        elif "2.5" in self.model or "ultra" in self.model.lower():
+            return "premium"
+        else:
+            return "capable"
+
+    def get_model_info(self) -> dict[str, Any]:
+        """Get Gemini model information"""
+        model_info = {
+            "gemini-2.0-flash-exp": {
+                "max_tokens": 1000000,
+                "cost_per_1m_input": 0.075,
+                "cost_per_1m_output": 0.30,
+                "supports_vision": True,
+                "ideal_for": "Fast responses, simple tasks, large context",
+            },
+            "gemini-1.5-pro": {
+                "max_tokens": 2000000,
+                "cost_per_1m_input": 1.25,
+                "cost_per_1m_output": 5.00,
+                "supports_vision": True,
+                "ideal_for": "Complex reasoning, large codebases",
+            },
+            "gemini-2.5-pro": {
+                "max_tokens": 1000000,
+                "cost_per_1m_input": 2.50,
+                "cost_per_1m_output": 10.00,
+                "supports_vision": True,
+                "ideal_for": "Advanced reasoning, complex tasks",
+            },
+        }
+
+        return model_info.get(
+            self.model,
+            {
+                "max_tokens": 1000000,
+                "cost_per_1m_input": 1.25,
+                "cost_per_1m_output": 5.00,
+                "supports_vision": True,
+            },
+        )
+
+
 class LocalProvider(BaseLLMProvider):
     """
     Local model provider (Ollama, LM Studio, etc.).

empathy_os/cli.py

@@ -28,7 +28,6 @@ from empathy_os.persistence import MetricsCollector, PatternPersistence, StateMa
 from empathy_os.platform_utils import setup_asyncio_policy
 from empathy_os.templates import cmd_new
 from empathy_os.workflows import (
-    WorkflowConfig,
     cmd_fix_all,
     cmd_learn,
     cmd_morning,
@@ -1414,13 +1413,29 @@ def cmd_wizard(args):
     print("\n3. Which LLM provider will you use?")
     print("   [1] Anthropic Claude ⭐ Recommended")
     print("   [2] OpenAI GPT-4")
-    print("   [3] Local (Ollama)")
-    print("   [4] Skip (configure later)")
-
-    llm_choice = input("\nYour choice (1-4) [1]: ").strip() or "1"
-    llm_map = {"1": "anthropic", "2": "openai", "3": "ollama", "4": None}
+    print("   [3] Google Gemini (2M context)")
+    print("   [4] Local (Ollama)")
+    print("   [5] Hybrid (mix best models from each provider)")
+    print("   [6] Skip (configure later)")
+
+    llm_choice = input("\nYour choice (1-6) [1]: ").strip() or "1"
+    llm_map = {
+        "1": "anthropic",
+        "2": "openai",
+        "3": "google",
+        "4": "ollama",
+        "5": "hybrid",
+        "6": None,
+    }
     llm_provider = llm_map.get(llm_choice, "anthropic")
 
+    # If hybrid selected, launch interactive tier selection
+    if llm_provider == "hybrid":
+        from empathy_os.models.provider_config import configure_hybrid_interactive
+
+        configure_hybrid_interactive()
+        llm_provider = None  # Already saved by hybrid config
+
     # Step 4: User ID
     print("\n4. What user ID should we use?")
     user_id = input("User ID [default_user]: ").strip() or "default_user"
@@ -1481,14 +1496,94 @@ llm_provider: "{llm_provider}"
     print("\nNext steps:")
     print(f"  1. Edit {output_file} to customize settings")
 
-    if llm_provider in ["anthropic", "openai"]:
-        env_var = "ANTHROPIC_API_KEY" if llm_provider == "anthropic" else "OPENAI_API_KEY"
+    if llm_provider in ["anthropic", "openai", "google"]:
+        env_var_map = {
+            "anthropic": "ANTHROPIC_API_KEY",
+            "openai": "OPENAI_API_KEY",
+            "google": "GOOGLE_API_KEY",
+        }
+        env_var = env_var_map.get(llm_provider, "API_KEY")
         print(f"  2. Set {env_var} environment variable")
 
     print("  3. Run: empathy-framework run --config empathy.config.yml")
     print("\nHappy empathizing! 🧠✨\n")
 
 
+def cmd_provider_hybrid(args):
+    """Configure hybrid mode - pick best models for each tier."""
+    from empathy_os.models.provider_config import configure_hybrid_interactive
+
+    configure_hybrid_interactive()
+
+
+def cmd_provider_show(args):
+    """Show current provider configuration."""
+    from empathy_os.models.provider_config import ProviderConfig
+    from empathy_os.workflows.config import WorkflowConfig
+
+    print("\n" + "=" * 60)
+    print("Provider Configuration")
+    print("=" * 60)
+
+    # Detect available providers
+    config = ProviderConfig.auto_detect()
+    print(
+        f"\nDetected API keys for: {', '.join(config.available_providers) if config.available_providers else 'None'}"
+    )
+
+    # Load workflow config
+    wf_config = WorkflowConfig.load()
+    print(f"\nDefault provider: {wf_config.default_provider}")
+
+    # Show effective models
+    print("\nEffective model mapping:")
+    if wf_config.custom_models and "hybrid" in wf_config.custom_models:
+        hybrid = wf_config.custom_models["hybrid"]
+        for tier in ["cheap", "capable", "premium"]:
+            model = hybrid.get(tier, "not configured")
+            print(f"  {tier:8} → {model}")
+    else:
+        from empathy_os.models import MODEL_REGISTRY
+
+        provider = wf_config.default_provider
+        if provider in MODEL_REGISTRY:
+            for tier in ["cheap", "capable", "premium"]:
+                model_info = MODEL_REGISTRY[provider].get(tier)
+                if model_info:
+                    print(f"  {tier:8} → {model_info.id} ({provider})")
+
+    print()
+
+
+def cmd_provider_set(args):
+    """Set default provider."""
+    from pathlib import Path
+
+    import yaml
+
+    provider = args.name
+    workflows_path = Path(".empathy/workflows.yaml")
+
+    # Load existing config or create new
+    if workflows_path.exists():
+        with open(workflows_path) as f:
+            config = yaml.safe_load(f) or {}
+    else:
+        config = {}
+        workflows_path.parent.mkdir(parents=True, exist_ok=True)
+
+    config["default_provider"] = provider
+
+    with open(workflows_path, "w") as f:
+        yaml.dump(config, f, default_flow_style=False, sort_keys=False)
+
+    print(f"✓ Default provider set to: {provider}")
+    print(f"  Saved to: {workflows_path}")
+
+    if provider == "hybrid":
+        print("\n  Tip: Run 'empathy provider hybrid' to customize tier models")
+
+
 def cmd_sync_claude(args):
     """Sync patterns to Claude Code rules directory."""
     import json as json_mod
@@ -1764,8 +1859,14 @@ def cmd_workflow(args):
         try:
             workflow_cls = get_workflow(name)
 
-            # Get provider (default to anthropic if not specified)
-            provider = args.provider if args.provider else "anthropic"
+            # Get provider from CLI arg, or fall back to config's default_provider
+            if args.provider:
+                provider = args.provider
+            else:
+                from empathy_os.workflows.config import WorkflowConfig
+
+                wf_config = WorkflowConfig.load()
+                provider = wf_config.default_provider
             workflow = workflow_cls(provider=provider)
 
             # Parse input
@@ -1773,8 +1874,17 @@ def cmd_workflow(args):
             if args.input:
                 input_data = json_mod.loads(args.input)
 
-            print(f"\n Running workflow: {name} (provider: {provider})")
-            print("=" * 50)
+            # Add test-gen specific flags to input_data (only for test-gen workflow)
+            if name == "test-gen":
+                if getattr(args, "write_tests", False):
+                    input_data["write_tests"] = True
+                if getattr(args, "output_dir", None):
+                    input_data["output_dir"] = args.output_dir
+
+            # Only print header when not in JSON mode
+            if not args.json:
+                print(f"\n Running workflow: {name} (provider: {provider})")
+                print("=" * 50)
 
             # Execute workflow
             result = asyncio.run(workflow.execute(**input_data))
@@ -1819,9 +1929,29 @@ def cmd_workflow(args):
                         error = metadata.get("error") if isinstance(metadata, dict) else None
 
                 # JSON output includes both content and metadata
+                # Include final_output for programmatic access (VSCode panels, etc.)
+                raw_final_output = getattr(result, "final_output", None)
+                if raw_final_output and isinstance(raw_final_output, dict):
+                    # Make a copy to avoid modifying the original
+                    final_output_serializable = {}
+                    for k, v in raw_final_output.items():
+                        # Skip non-serializable items
+                        if isinstance(v, set):
+                            final_output_serializable[k] = list(v)
+                        elif v is None or isinstance(v, str | int | float | bool | list | dict):
+                            final_output_serializable[k] = v
+                        else:
+                            try:
+                                final_output_serializable[k] = str(v)
+                            except Exception:
+                                pass
+                else:
+                    final_output_serializable = None
+
                 output = {
                     "success": result.success,
                     "output": output_content,
+                    "final_output": final_output_serializable,
                     "cost": total_cost,
                     "savings": savings,
                     "duration_ms": duration_ms or 0,
@@ -2135,6 +2265,33 @@ def main():
     )
     parser_wizard.set_defaults(func=cmd_wizard)
 
+    # Provider command (Model provider configuration)
+    parser_provider = subparsers.add_parser(
+        "provider", help="Configure model providers and hybrid mode"
+    )
+    provider_subparsers = parser_provider.add_subparsers(dest="provider_cmd")
+
+    # provider hybrid - Interactive hybrid configuration
+    parser_provider_hybrid = provider_subparsers.add_parser(
+        "hybrid", help="Configure hybrid mode - pick best models for each tier"
+    )
+    parser_provider_hybrid.set_defaults(func=cmd_provider_hybrid)
+
+    # provider show - Show current configuration
+    parser_provider_show = provider_subparsers.add_parser(
+        "show", help="Show current provider configuration"
+    )
+    parser_provider_show.set_defaults(func=cmd_provider_show)
+
+    # provider set - Quick set single provider
+    parser_provider_set = provider_subparsers.add_parser(
+        "set", help="Set default provider (anthropic, openai, google, ollama)"
+    )
+    parser_provider_set.add_argument(
+        "name", choices=["anthropic", "openai", "google", "ollama", "hybrid"], help="Provider name"
+    )
+    parser_provider_set.set_defaults(func=cmd_provider_set)
+
     # Status command (Session status assistant)
     parser_status = subparsers.add_parser(
         "status", help="Session status - prioritized project status report"
@@ -2338,9 +2495,9 @@ def main():
     parser_workflow.add_argument(
         "--provider",
         "-p",
-        choices=["anthropic", "openai", "ollama", "hybrid"],
+        choices=["anthropic", "openai", "google", "ollama", "hybrid"],
         default=None,  # None means use config
-        help="Model provider: anthropic, openai, ollama, or hybrid (mix of best models)",
+        help="Model provider: anthropic, openai, google, ollama, or hybrid (mix of best models)",
     )
     parser_workflow.add_argument(
         "--force",
@@ -2348,6 +2505,16 @@ def main():
         help="Force overwrite existing config file",
     )
     parser_workflow.add_argument("--json", action="store_true", help="Output as JSON")
+    parser_workflow.add_argument(
+        "--write-tests",
+        action="store_true",
+        help="(test-gen workflow) Write generated tests to disk",
+    )
+    parser_workflow.add_argument(
+        "--output-dir",
+        default="tests/generated",
+        help="(test-gen workflow) Output directory for generated tests",
+    )
     parser_workflow.set_defaults(func=cmd_workflow)
 
     # Sync-claude command (sync patterns to Claude Code)

empathy_os/cli_unified.py

@@ -136,7 +136,7 @@ app.add_typer(provider_app, name="provider")
 def provider_show(
     ctx: typer.Context,
     set_provider: str | None = typer.Option(
-        None, "--set", "-s", help="Set provider (anthropic, openai, ollama, hybrid)"
+        None, "--set", "-s", help="Set provider (anthropic, openai, google, ollama, hybrid)"
     ),
     interactive: bool = typer.Option(False, "--interactive", "-i", help="Interactive setup wizard"),
     format_out: str = typer.Option("table", "--format", "-f", help="Output format (table, json)"),

empathy_os/redis_config.py

@@ -2,7 +2,7 @@
 Redis Configuration for Empathy Framework
 
 Handles connection to Redis from environment variables.
-Supports Railway, redis.com, local Docker, or mock mode.
+Supports Railway, redis.com, local Docker, managed Redis, or mock mode.
 
 Environment Variables:
     REDIS_URL: Full Redis URL (redis://user:pass@host:port)
@@ -12,8 +12,29 @@ Environment Variables:
     REDIS_DB: Redis database number (default: 0)
     EMPATHY_REDIS_MOCK: Set to "true" to use mock mode
 
+    # SSL/TLS (for managed Redis services)
+    REDIS_SSL: Set to "true" to enable SSL
+    REDIS_SSL_CERT_REQS: Certificate requirement ("required", "optional", "none")
+    REDIS_SSL_CA_CERTS: Path to CA certificate file
+    REDIS_SSL_CERTFILE: Path to client certificate
+    REDIS_SSL_KEYFILE: Path to client key
+
+    # Connection settings
+    REDIS_SOCKET_TIMEOUT: Socket timeout in seconds (default: 5.0)
+    REDIS_MAX_CONNECTIONS: Connection pool size (default: 10)
+
+    # Retry settings
+    REDIS_RETRY_MAX_ATTEMPTS: Max retry attempts (default: 3)
+    REDIS_RETRY_BASE_DELAY: Base retry delay in seconds (default: 0.1)
+    REDIS_RETRY_MAX_DELAY: Max retry delay in seconds (default: 2.0)
+
+    # Sentinel (for high availability)
+    REDIS_SENTINEL_HOSTS: Comma-separated host:port pairs
+    REDIS_SENTINEL_MASTER: Sentinel master name
+
 Railway Auto-Detection:
     When deployed on Railway, REDIS_URL is automatically set.
+    For Railway Redis with SSL, the URL starts with "rediss://"
 
 Usage:
     from empathy_os.redis_config import get_redis_memory
@@ -21,8 +42,13 @@ Usage:
     # Automatically uses environment variables
     memory = get_redis_memory()
 
-    # Or with explicit URL
-    memory = get_redis_memory(url="redis://localhost:6379")
+    # Or with explicit URL (SSL auto-detected from rediss://)
+    memory = get_redis_memory(url="rediss://user:pass@managed-redis.com:6379")
+
+    # Or with explicit config
+    from empathy_os.memory.short_term import RedisConfig
+    config = RedisConfig(host="localhost", ssl=True)
+    memory = get_redis_memory(config=config)
 
 Copyright 2025 Smart AI Memory, LLC
 Licensed under Fair Source 0.9
@@ -31,65 +57,119 @@ Licensed under Fair Source 0.9
 import os
 from urllib.parse import urlparse
 
-from .redis_memory import RedisShortTermMemory
+from .memory.short_term import RedisConfig, RedisShortTermMemory
 
 
 def parse_redis_url(url: str) -> dict:
     """
     Parse Redis URL into connection parameters.
 
+    Supports:
+    - redis://user:pass@host:port/db (standard)
+    - rediss://user:pass@host:port/db (SSL enabled)
+
     Args:
-        url: Redis URL (redis://user:pass@host:port/db)
+        url: Redis URL (redis:// or rediss://)
 
     Returns:
-        Dict with host, port, password, db
+        Dict with host, port, password, db, ssl
     """
     parsed = urlparse(url)
 
+    # Detect SSL from scheme
+    ssl = parsed.scheme == "rediss"
+
     return {
         "host": parsed.hostname or "localhost",
         "port": parsed.port or 6379,
         "password": parsed.password,
         "db": int(parsed.path.lstrip("/") or 0) if parsed.path else 0,
+        "ssl": ssl,
     }
 
 
-def get_redis_config() -> dict:
+def get_redis_config() -> RedisConfig:
     """
     Get Redis configuration from environment variables.
 
     Priority:
-    1. REDIS_URL (full URL, used by Railway)
+    1. REDIS_URL (full URL, used by Railway/Heroku/managed services)
     2. Individual env vars (REDIS_HOST, REDIS_PORT, etc.)
     3. Defaults (localhost:6379)
 
     Returns:
-        Dict with connection parameters or {"use_mock": True}
+        RedisConfig with all connection parameters
     """
     # Check for mock mode
     if os.getenv("EMPATHY_REDIS_MOCK", "").lower() == "true":
-        return {"use_mock": True}
+        return RedisConfig(use_mock=True)
 
-    # Check for full URL (Railway, Heroku, etc.)
+    # Check for full URL (Railway, Heroku, managed services)
     redis_url = os.getenv("REDIS_URL") or os.getenv("REDIS_PRIVATE_URL")
     if redis_url:
-        config = parse_redis_url(redis_url)
-        config["use_mock"] = False
-        return config
+        url_config = parse_redis_url(redis_url)
+        return RedisConfig(
+            host=url_config["host"],
+            port=url_config["port"],
+            password=url_config["password"],
+            db=url_config["db"],
+            ssl=url_config.get("ssl", False),
+            use_mock=False,
+            # Apply additional env var overrides
+            socket_timeout=float(os.getenv("REDIS_SOCKET_TIMEOUT", "5.0")),
+            max_connections=int(os.getenv("REDIS_MAX_CONNECTIONS", "10")),
+            retry_max_attempts=int(os.getenv("REDIS_RETRY_MAX_ATTEMPTS", "3")),
+            retry_base_delay=float(os.getenv("REDIS_RETRY_BASE_DELAY", "0.1")),
+            retry_max_delay=float(os.getenv("REDIS_RETRY_MAX_DELAY", "2.0")),
+        )
 
-    # Fall back to individual env vars
+    # Build config from individual env vars
+    return RedisConfig(
+        host=os.getenv("REDIS_HOST", "localhost"),
+        port=int(os.getenv("REDIS_PORT", "6379")),
+        password=os.getenv("REDIS_PASSWORD"),
+        db=int(os.getenv("REDIS_DB", "0")),
+        use_mock=False,
+        # SSL settings
+        ssl=os.getenv("REDIS_SSL", "").lower() == "true",
+        ssl_cert_reqs=os.getenv("REDIS_SSL_CERT_REQS"),
+        ssl_ca_certs=os.getenv("REDIS_SSL_CA_CERTS"),
+        ssl_certfile=os.getenv("REDIS_SSL_CERTFILE"),
+        ssl_keyfile=os.getenv("REDIS_SSL_KEYFILE"),
+        # Connection settings
+        socket_timeout=float(os.getenv("REDIS_SOCKET_TIMEOUT", "5.0")),
+        socket_connect_timeout=float(os.getenv("REDIS_SOCKET_CONNECT_TIMEOUT", "5.0")),
+        max_connections=int(os.getenv("REDIS_MAX_CONNECTIONS", "10")),
+        # Retry settings
+        retry_on_timeout=os.getenv("REDIS_RETRY_ON_TIMEOUT", "true").lower() == "true",
+        retry_max_attempts=int(os.getenv("REDIS_RETRY_MAX_ATTEMPTS", "3")),
+        retry_base_delay=float(os.getenv("REDIS_RETRY_BASE_DELAY", "0.1")),
+        retry_max_delay=float(os.getenv("REDIS_RETRY_MAX_DELAY", "2.0")),
+    )
+
+
+def get_redis_config_dict() -> dict:
+    """
+    Get Redis configuration as a dictionary (legacy compatibility).
+
+    Returns:
+        Dict with connection parameters
+    """
+    config = get_redis_config()
     return {
-        "host": os.getenv("REDIS_HOST", "localhost"),
-        "port": int(os.getenv("REDIS_PORT", "6379")),
-        "password": os.getenv("REDIS_PASSWORD"),
-        "db": int(os.getenv("REDIS_DB", "0")),
-        "use_mock": False,
+        "host": config.host,
+        "port": config.port,
+        "password": config.password,
+        "db": config.db,
+        "use_mock": config.use_mock,
+        "ssl": config.ssl,
     }
 
 
 def get_redis_memory(
     url: str | None = None,
     use_mock: bool | None = None,
+    config: RedisConfig | None = None,
 ) -> RedisShortTermMemory:
     """
     Create a RedisShortTermMemory instance with environment-based config.
@@ -97,6 +177,7 @@ def get_redis_memory(
     Args:
         url: Optional explicit Redis URL (overrides env vars)
         use_mock: Optional explicit mock mode (overrides env vars)
+        config: Optional explicit RedisConfig (overrides all other options)
 
     Returns:
         Configured RedisShortTermMemory instance
@@ -105,40 +186,46 @@ def get_redis_memory(
         # Auto-configure from environment
         memory = get_redis_memory()
 
-        # Explicit URL
-        memory = get_redis_memory(url="redis://localhost:6379")
+        # Explicit URL (SSL auto-detected from rediss://)
+        memory = get_redis_memory(url="rediss://user:pass@managed-redis.com:6379")
 
         # Force mock mode
         memory = get_redis_memory(use_mock=True)
+
+        # Explicit config with all options
+        from empathy_os.memory.short_term import RedisConfig
+        config = RedisConfig(
+            host="redis.example.com",
+            port=6379,
+            ssl=True,
+            retry_max_attempts=5,
+        )
+        memory = get_redis_memory(config=config)
     """
+    # Explicit config takes highest priority
+    if config is not None:
+        return RedisShortTermMemory(config=config)
+
     # Explicit mock mode
     if use_mock is True:
         return RedisShortTermMemory(use_mock=True)
 
     # Explicit URL
     if url:
-        config = parse_redis_url(url)
-        return RedisShortTermMemory(
-            host=config["host"],
-            port=config["port"],
-            password=config["password"],
-            db=config["db"],
+        url_config = parse_redis_url(url)
+        redis_config = RedisConfig(
+            host=url_config["host"],
+            port=url_config["port"],
+            password=url_config["password"],
+            db=url_config["db"],
+            ssl=url_config.get("ssl", False),
             use_mock=False,
         )
+        return RedisShortTermMemory(config=redis_config)
 
     # Environment-based config
-    config = get_redis_config()
-
-    if config.get("use_mock"):
-        return RedisShortTermMemory(use_mock=True)
-
-    return RedisShortTermMemory(
-        host=config["host"],
-        port=config["port"],
-        password=config.get("password"),
-        db=config.get("db", 0),
-        use_mock=False,
-    )
+    env_config = get_redis_config()
+    return RedisShortTermMemory(config=env_config)
 
 
 def check_redis_connection() -> dict:
@@ -157,11 +244,11 @@ def check_redis_connection() -> dict:
 
     result = {
         "config_source": "environment",
-        "use_mock": config.get("use_mock", False),
-        "host": config.get("host"),
-        "port": config.get("port"),
-        "has_password": bool(config.get("password")),
-        "db": config.get("db", 0),
+        "use_mock": config.use_mock,
+        "host": config.host,
+        "port": config.port,
+        "has_password": bool(config.password),
+        "db": config.db,
         "connected": False,
         "error": None,
     }

empathy_os/workflow_commands.py

@@ -347,8 +347,8 @@ def ship_workflow(
         # Import here to avoid circular imports
         try:
             from empathy_llm_toolkit.cli.sync_claude import (
-                sync_patterns_to_claude,  # type: ignore[attr-defined]
-            )
+                sync_patterns_to_claude,
+            )  # type: ignore[attr-defined]
 
             result = sync_patterns_to_claude(
                 patterns_dir=patterns_dir, output_dir=".claude/rules/empathy"