empathy-framework 3.2.3__py3-none-any.whl → 3.8.2__py3-none-any.whl

empathy_os/cli.py

@@ -1,5 +1,4 @@
-"""
-Command-Line Interface for Empathy Framework
+"""Command-Line Interface for Empathy Framework
 
 Provides CLI commands for:
 - Running interactive REPL (empathy run)
@@ -25,9 +24,10 @@ from empathy_os.discovery import show_tip_if_available
 from empathy_os.logging_config import get_logger
 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 (
-    WorkflowConfig,
     cmd_fix_all,
     cmd_learn,
     cmd_morning,
@@ -285,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")
@@ -482,10 +484,9 @@ for a quick reference of all commands.
             print("  Congratulations! You've completed the onboarding!")
             print()
             _show_achievements(engine)
-    else:
-        if step_data["action"]:
-            print(f"  NEXT: Run '{step_data['action']}'")
-            print("        Then run 'empathy onboard' to continue")
+    elif step_data["action"]:
+        print(f"  NEXT: Run '{step_data['action']}'")
+        print("        Then run 'empathy onboard' to continue")
 
     print()
     print("-" * 60)
@@ -642,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):
@@ -736,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)
 
@@ -750,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)
 
@@ -783,7 +812,7 @@ def cmd_patterns_resolve(args):
     if not args.root_cause or not args.fix:
         print("✗ --root-cause and --fix are required when resolving a bug")
         print(
-            "  Example: empathy patterns resolve bug_123 --root-cause 'Null check' --fix 'Added ?.'"
+            "  Example: empathy patterns resolve bug_123 --root-cause 'Null check' --fix 'Added ?.'",
         )
         sys.exit(1)
 
@@ -870,8 +899,8 @@ def cmd_review(args):
                 "files": args.files,
                 "staged_only": args.staged,
                 "severity_threshold": args.severity,
-            }
-        )
+            },
+        ),
     )
 
     # Output results
@@ -972,7 +1001,7 @@ def cmd_health(args):
                 print(f"\n⚠ Skipped {len(result['skipped'])} issue(s) (could not auto-fix)")
             else:
                 print(
-                    f"\n⚠ Skipped {len(result['skipped'])} issue(s) (use --interactive to review)"
+                    f"\n⚠ Skipped {len(result['skipped'])} issue(s) (use --interactive to review)",
                 )
 
         if result["failed"]:
@@ -1043,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)
 
@@ -1098,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)
 
@@ -1182,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")
 
 
@@ -1225,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)
 
@@ -1247,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)
 
@@ -1264,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)
 
@@ -1316,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)
 
@@ -1369,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)
 
@@ -1413,13 +1510,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"
@@ -1480,14 +1593,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
@@ -1569,7 +1762,7 @@ def _generate_claude_rule(category: str, patterns: list) -> str:
                 "",
                 "When debugging similar issues, consider these historical fixes:",
                 "",
-            ]
+            ],
         )
         for p in patterns[:20]:  # Limit to 20 most recent
             bug_type = p.get("bug_type", "unknown")
@@ -1591,7 +1784,7 @@ def _generate_claude_rule(category: str, patterns: list) -> str:
                 "",
                 "Previously reviewed security items:",
                 "",
-            ]
+            ],
         )
         for p in patterns[:20]:
             decision = p.get("decision", "unknown")
@@ -1608,7 +1801,7 @@ def _generate_claude_rule(category: str, patterns: list) -> str:
                 "",
                 "Known technical debt items:",
                 "",
-            ]
+            ],
         )
         for p in patterns[:20]:
             lines.append(f"- {p.get('description', str(p))}")
@@ -1618,7 +1811,7 @@ def _generate_claude_rule(category: str, patterns: list) -> str:
             [
                 f"## {category.title()} Items",
                 "",
-            ]
+            ],
         )
         for p in patterns[:20]:
             lines.append(f"- {p.get('description', str(p)[:100])}")
@@ -1627,8 +1820,7 @@ def _generate_claude_rule(category: str, patterns: list) -> str:
 
 
 def _extract_workflow_content(final_output):
-    """
-    Extract readable content from workflow final_output.
+    """Extract readable content from workflow final_output.
 
     Workflows return their results in various formats - this extracts
     the actual content users want to see.
@@ -1643,7 +1835,9 @@ def _extract_workflow_content(final_output):
     # If it's a dict, try to extract meaningful content
     if isinstance(final_output, dict):
         # Common keys that contain the main output
+        # formatted_report is first - preferred for security-audit and other formatted outputs
         content_keys = [
+            "formatted_report",  # Human-readable formatted output (security-audit, etc.)
             "answer",
             "synthesis",
             "result",
@@ -1661,11 +1855,11 @@ def _extract_workflow_content(final_output):
             "plan",
         ]
         for key in content_keys:
-            if key in final_output and final_output[key]:
+            if final_output.get(key):
                 val = final_output[key]
                 if isinstance(val, str):
                     return val
-                elif isinstance(val, dict):
+                if isinstance(val, dict):
                     # Recursively extract
                     return _extract_workflow_content(val)
 
@@ -1761,8 +1955,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
@@ -1770,8 +1970,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))
@@ -1779,6 +1988,11 @@ def cmd_workflow(args):
             # Extract the actual content - handle different result types
             if hasattr(result, "final_output"):
                 output_content = _extract_workflow_content(result.final_output)
+            elif hasattr(result, "metadata") and isinstance(result.metadata, dict):
+                # Check for formatted_report in metadata (e.g., HealthCheckResult)
+                output_content = result.metadata.get("formatted_report")
+                if not output_content and hasattr(result, "summary"):
+                    output_content = result.summary
             elif hasattr(result, "summary"):
                 output_content = result.summary
             else:
@@ -1789,37 +2003,81 @@ def cmd_workflow(args):
             if duration_ms is None and hasattr(result, "duration_seconds"):
                 duration_ms = int(result.duration_seconds * 1000)
 
-            # Get cost info if available
+            # Get cost info if available (check cost_report first, then direct cost attribute)
             cost_report = getattr(result, "cost_report", None)
-            total_cost = cost_report.total_cost if cost_report else 0.0
-            savings = cost_report.savings if cost_report else 0.0
+            if cost_report and hasattr(cost_report, "total_cost"):
+                total_cost = cost_report.total_cost
+                savings = getattr(cost_report, "savings", 0.0)
+            else:
+                # Fall back to direct cost attribute (e.g., CodeReviewPipelineResult)
+                total_cost = getattr(result, "cost", 0.0)
+                savings = 0.0
 
             if args.json:
+                # Extract error from various result types
+                error = getattr(result, "error", None)
+                if not error and not result.success:
+                    blockers = getattr(result, "blockers", [])
+                    if blockers:
+                        error = "; ".join(blockers)
+                    else:
+                        metadata = getattr(result, "metadata", {})
+                        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 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
+
                 output = {
                     "success": result.success,
                     "output": output_content,
+                    "final_output": final_output_serializable,
                     "cost": total_cost,
                     "savings": savings,
                     "duration_ms": duration_ms or 0,
-                    "error": getattr(result, "error", None),
+                    "error": error,
                 }
                 print(json_mod.dumps(output, indent=2))
+            # Display the actual results - this is what users want to see
+            elif result.success:
+                if output_content:
+                    print(f"\n{output_content}\n")
+                else:
+                    print("\n✓ Workflow completed successfully.\n")
             else:
-                # Display the actual results - this is what users want to see
-                if result.success:
-                    if output_content:
-                        print(f"\n{output_content}\n")
+                # Extract error from various result types
+                error_msg = getattr(result, "error", None)
+                if not error_msg:
+                    # Check for blockers (CodeReviewPipelineResult)
+                    blockers = getattr(result, "blockers", [])
+                    if blockers:
+                        error_msg = "; ".join(blockers)
                     else:
-                        print("\n✓ Workflow completed successfully.\n")
-
-                    # Brief footer with timing (detailed costs available via 'empathy costs')
-                    print("-" * 50)
-                    ms = duration_ms or 0
-                    print(f"Completed in {ms}ms | Cost: ${total_cost:.4f} (saved ${savings:.4f})")
-                else:
-                    error_msg = getattr(result, "error", None) or "Unknown error"
-                    print(f"\n✗ Workflow failed: {error_msg}\n")
+                        # Check metadata for error
+                        metadata = getattr(result, "metadata", {})
+                        error_msg = metadata.get("error") if isinstance(metadata, dict) else None
+                error_msg = error_msg or "Unknown error"
+                print(f"\n✗ Workflow failed: {error_msg}\n")
 
         except KeyError as e:
             print(f"Error: {e}")
@@ -1898,7 +2156,7 @@ def cmd_frameworks(args):
                 json_mod.dumps(
                     {"use_case": recommend_use_case, "recommended": recommended.value, **info},
                     indent=2,
-                )
+                ),
             )
         else:
             print(f"\nRecommended framework for '{recommend_use_case}': {info['name']}")
@@ -1925,7 +2183,7 @@ def cmd_frameworks(args):
                     for f in frameworks
                 ],
                 indent=2,
-            )
+            ),
         )
     else:
         print("\n" + "=" * 60)
@@ -1950,6 +2208,9 @@ def cmd_frameworks(args):
 
 def main():
     """Main CLI entry point"""
+    # Configure Windows-compatible asyncio event loop policy
+    setup_asyncio_policy()
+
     parser = argparse.ArgumentParser(
         prog="empathy",
         description="Empathy - Build AI systems with 5 levels of empathy",
@@ -2002,32 +2263,45 @@ def main():
     parser_patterns_export.add_argument("input", help="Input file path")
     parser_patterns_export.add_argument("output", help="Output file path")
     parser_patterns_export.add_argument(
-        "--input-format", choices=["json", "sqlite"], default="json"
+        "--input-format",
+        choices=["json", "sqlite"],
+        default="json",
     )
     parser_patterns_export.add_argument(
-        "--output-format", choices=["json", "sqlite"], default="json"
+        "--output-format",
+        choices=["json", "sqlite"],
+        default="json",
     )
     parser_patterns_export.set_defaults(func=cmd_patterns_export)
 
     # Patterns resolve - mark investigating bugs as resolved
     parser_patterns_resolve = patterns_subparsers.add_parser(
-        "resolve", help="Resolve investigating bug patterns"
+        "resolve",
+        help="Resolve investigating bug patterns",
     )
     parser_patterns_resolve.add_argument(
-        "bug_id", nargs="?", help="Bug ID to resolve (omit to list investigating)"
+        "bug_id",
+        nargs="?",
+        help="Bug ID to resolve (omit to list investigating)",
     )
     parser_patterns_resolve.add_argument("--root-cause", help="Description of the root cause")
     parser_patterns_resolve.add_argument("--fix", help="Description of the fix applied")
     parser_patterns_resolve.add_argument("--fix-code", help="Code snippet of the fix")
     parser_patterns_resolve.add_argument("--time", type=int, help="Resolution time in minutes")
     parser_patterns_resolve.add_argument(
-        "--resolved-by", default="@developer", help="Who resolved it"
+        "--resolved-by",
+        default="@developer",
+        help="Who resolved it",
     )
     parser_patterns_resolve.add_argument(
-        "--patterns-dir", default="./patterns", help="Path to patterns directory"
+        "--patterns-dir",
+        default="./patterns",
+        help="Path to patterns directory",
     )
     parser_patterns_resolve.add_argument(
-        "--no-regenerate", action="store_true", help="Skip regenerating summary"
+        "--no-regenerate",
+        action="store_true",
+        help="Skip regenerating summary",
     )
     parser_patterns_resolve.set_defaults(func=cmd_patterns_resolve)
 
@@ -2048,7 +2322,9 @@ def main():
     # State list
     parser_state_list = state_subparsers.add_parser("list", help="List saved states")
     parser_state_list.add_argument(
-        "--state-dir", default="./empathy_state", help="State directory path"
+        "--state-dir",
+        default="./empathy_state",
+        help="State directory path",
     )
     parser_state_list.set_defaults(func=cmd_state_list)
 
@@ -2057,7 +2333,10 @@ def main():
     parser_run.add_argument("--config", "-c", help="Configuration file path")
     parser_run.add_argument("--user-id", help="User ID (default: cli_user)")
     parser_run.add_argument(
-        "--level", type=int, default=4, help="Target empathy level (1-5, default: 4)"
+        "--level",
+        type=int,
+        default=4,
+        help="Target empathy level (1-5, default: 4)",
     )
     parser_run.set_defaults(func=cmd_run)
 
@@ -2071,21 +2350,27 @@ def main():
     parser_inspect.add_argument("--user-id", help="User ID to filter by (optional)")
     parser_inspect.add_argument("--db", help="Database path (default: .empathy/patterns.db)")
     parser_inspect.add_argument(
-        "--state-dir", help="State directory path (default: .empathy/state)"
+        "--state-dir",
+        help="State directory path (default: .empathy/state)",
     )
     parser_inspect.set_defaults(func=cmd_inspect)
 
     # Export command
     parser_export = subparsers.add_parser(
-        "export", help="Export patterns to file for sharing/backup"
+        "export",
+        help="Export patterns to file for sharing/backup",
     )
     parser_export.add_argument("output", help="Output file path")
     parser_export.add_argument(
-        "--user-id", help="User ID to export (optional, exports all if not specified)"
+        "--user-id",
+        help="User ID to export (optional, exports all if not specified)",
     )
     parser_export.add_argument("--db", help="Database path (default: .empathy/patterns.db)")
     parser_export.add_argument(
-        "--format", default="json", choices=["json"], help="Export format (default: json)"
+        "--format",
+        default="json",
+        choices=["json"],
+        help="Export format (default: json)",
     )
     parser_export.set_defaults(func=cmd_export)
 
@@ -2097,20 +2382,59 @@ def main():
 
     # Wizard command (Interactive setup)
     parser_wizard = subparsers.add_parser(
-        "wizard", help="Interactive setup wizard for creating configuration"
+        "wizard",
+        help="Interactive setup wizard for creating configuration",
     )
     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"
+        "status",
+        help="Session status - prioritized project status report",
     )
     parser_status.add_argument(
-        "--patterns-dir", default="./patterns", help="Path to patterns directory"
+        "--patterns-dir",
+        default="./patterns",
+        help="Path to patterns directory",
     )
     parser_status.add_argument("--project-root", default=".", help="Project root directory")
     parser_status.add_argument(
-        "--force", action="store_true", help="Force show status regardless of inactivity"
+        "--force",
+        action="store_true",
+        help="Force show status regardless of inactivity",
     )
     parser_status.add_argument("--full", action="store_true", help="Show all items (no limit)")
     parser_status.add_argument("--json", action="store_true", help="Output as JSON")
@@ -2125,7 +2449,8 @@ def main():
 
     # Review command (Pattern-based code review)
     parser_review = subparsers.add_parser(
-        "review", help="Pattern-based code review against historical bugs"
+        "review",
+        help="Pattern-based code review against historical bugs",
     )
     parser_review.add_argument("files", nargs="*", help="Files to review (default: recent changes)")
     parser_review.add_argument("--staged", action="store_true", help="Review staged changes only")
@@ -2141,10 +2466,13 @@ def main():
 
     # Health command (Code Health Assistant)
     parser_health = subparsers.add_parser(
-        "health", help="Code health assistant - run checks and auto-fix issues"
+        "health",
+        help="Code health assistant - run checks and auto-fix issues",
     )
     parser_health.add_argument(
-        "--deep", action="store_true", help="Run comprehensive checks (slower)"
+        "--deep",
+        action="store_true",
+        help="Run comprehensive checks (slower)",
     )
     parser_health.add_argument(
         "--check",
@@ -2153,20 +2481,31 @@ def main():
     )
     parser_health.add_argument("--fix", action="store_true", help="Auto-fix issues where possible")
     parser_health.add_argument(
-        "--dry-run", action="store_true", help="Show what would be fixed without applying"
+        "--dry-run",
+        action="store_true",
+        help="Show what would be fixed without applying",
     )
     parser_health.add_argument(
-        "--interactive", action="store_true", help="Prompt before applying non-safe fixes"
+        "--interactive",
+        action="store_true",
+        help="Prompt before applying non-safe fixes",
     )
     parser_health.add_argument("--details", action="store_true", help="Show detailed issue list")
     parser_health.add_argument(
-        "--full", action="store_true", help="Show full report with all details"
+        "--full",
+        action="store_true",
+        help="Show full report with all details",
     )
     parser_health.add_argument(
-        "--trends", type=int, metavar="DAYS", help="Show health trends over N days"
+        "--trends",
+        type=int,
+        metavar="DAYS",
+        help="Show health trends over N days",
     )
     parser_health.add_argument(
-        "--project-root", default=".", help="Project root directory (default: current)"
+        "--project-root",
+        default=".",
+        help="Project root directory (default: current)",
     )
     parser_health.add_argument("--json", action="store_true", help="Output as JSON")
     parser_health.set_defaults(func=cmd_health)
@@ -2177,10 +2516,13 @@ def main():
 
     # Morning command (start-of-day briefing)
     parser_morning = subparsers.add_parser(
-        "morning", help="Start-of-day briefing with patterns, debt, and focus areas"
+        "morning",
+        help="Start-of-day briefing with patterns, debt, and focus areas",
     )
     parser_morning.add_argument(
-        "--patterns-dir", default="./patterns", help="Path to patterns directory"
+        "--patterns-dir",
+        default="./patterns",
+        help="Path to patterns directory",
     )
     parser_morning.add_argument("--project-root", default=".", help="Project root directory")
     parser_morning.add_argument("--verbose", "-v", action="store_true", help="Show detailed output")
@@ -2189,48 +2531,77 @@ def main():
     # Ship command (pre-commit validation)
     parser_ship = subparsers.add_parser("ship", help="Pre-commit validation pipeline")
     parser_ship.add_argument(
-        "--patterns-dir", default="./patterns", help="Path to patterns directory"
+        "--patterns-dir",
+        default="./patterns",
+        help="Path to patterns directory",
     )
     parser_ship.add_argument("--project-root", default=".", help="Project root directory")
     parser_ship.add_argument(
-        "--skip-sync", action="store_true", help="Skip syncing patterns to Claude"
+        "--skip-sync",
+        action="store_true",
+        help="Skip syncing patterns to Claude",
+    )
+    parser_ship.add_argument(
+        "--tests-only",
+        action="store_true",
+        help="Run tests only (skip lint/format checks)",
+    )
+    parser_ship.add_argument(
+        "--security-only",
+        action="store_true",
+        help="Run security checks only",
     )
     parser_ship.add_argument("--verbose", "-v", action="store_true", help="Show detailed output")
     parser_ship.set_defaults(func=cmd_ship)
 
     # Fix-all command (auto-fix everything)
     parser_fix_all = subparsers.add_parser(
-        "fix-all", help="Auto-fix all fixable lint and format issues"
+        "fix-all",
+        help="Auto-fix all fixable lint and format issues",
     )
     parser_fix_all.add_argument("--project-root", default=".", help="Project root directory")
     parser_fix_all.add_argument(
-        "--dry-run", action="store_true", help="Show what would be fixed without applying"
+        "--dry-run",
+        action="store_true",
+        help="Show what would be fixed without applying",
     )
     parser_fix_all.add_argument("--verbose", "-v", action="store_true", help="Show detailed output")
     parser_fix_all.set_defaults(func=cmd_fix_all)
 
     # Learn command (pattern learning from git history)
     parser_learn = subparsers.add_parser(
-        "learn", help="Learn patterns from git history and bug fixes"
+        "learn",
+        help="Learn patterns from git history and bug fixes",
     )
     parser_learn.add_argument(
-        "--patterns-dir", default="./patterns", help="Path to patterns directory"
+        "--patterns-dir",
+        default="./patterns",
+        help="Path to patterns directory",
     )
     parser_learn.add_argument(
-        "--analyze", type=int, metavar="N", help="Analyze last N commits (default: 10)"
+        "--analyze",
+        type=int,
+        metavar="N",
+        help="Analyze last N commits (default: 10)",
     )
     parser_learn.add_argument(
-        "--watch", action="store_true", help="Watch for new commits (not yet implemented)"
+        "--watch",
+        action="store_true",
+        help="Watch for new commits (not yet implemented)",
     )
     parser_learn.add_argument("--verbose", "-v", action="store_true", help="Show detailed output")
     parser_learn.set_defaults(func=cmd_learn)
 
     # Costs command (cost tracking dashboard)
     parser_costs = subparsers.add_parser(
-        "costs", help="View API cost tracking and savings from model routing"
+        "costs",
+        help="View API cost tracking and savings from model routing",
     )
     parser_costs.add_argument(
-        "--days", type=int, default=7, help="Number of days to include (default: 7)"
+        "--days",
+        type=int,
+        default=7,
+        help="Number of days to include (default: 7)",
     )
     parser_costs.add_argument("--empathy-dir", default=".empathy", help="Empathy data directory")
     parser_costs.add_argument("--json", action="store_true", help="Output as JSON")
@@ -2252,16 +2623,25 @@ def main():
     # Dashboard command (visual web interface)
     parser_dashboard = subparsers.add_parser("dashboard", help="Launch visual dashboard in browser")
     parser_dashboard.add_argument(
-        "--port", type=int, default=8765, help="Port to run on (default: 8765)"
+        "--port",
+        type=int,
+        default=8765,
+        help="Port to run on (default: 8765)",
     )
     parser_dashboard.add_argument(
-        "--patterns-dir", default="./patterns", help="Path to patterns directory"
+        "--patterns-dir",
+        default="./patterns",
+        help="Path to patterns directory",
     )
     parser_dashboard.add_argument(
-        "--empathy-dir", default=".empathy", help="Empathy data directory"
+        "--empathy-dir",
+        default=".empathy",
+        help="Empathy data directory",
     )
     parser_dashboard.add_argument(
-        "--no-browser", action="store_true", help="Don't open browser automatically"
+        "--no-browser",
+        action="store_true",
+        help="Don't open browser automatically",
     )
     parser_dashboard.set_defaults(func=cmd_dashboard)
 
@@ -2271,7 +2651,9 @@ def main():
         help="List and manage agent frameworks (LangChain, LangGraph, AutoGen, Haystack)",
     )
     parser_frameworks.add_argument(
-        "--all", action="store_true", help="Show all frameworks including uninstalled"
+        "--all",
+        action="store_true",
+        help="Show all frameworks including uninstalled",
     )
     parser_frameworks.add_argument(
         "--recommend",
@@ -2304,9 +2686,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",
@@ -2314,14 +2696,27 @@ 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)
     parser_sync_claude = subparsers.add_parser(
-        "sync-claude", help="Sync learned patterns to Claude Code rules"
+        "sync-claude",
+        help="Sync learned patterns to Claude Code rules",
     )
     parser_sync_claude.add_argument(
-        "--patterns-dir", default="./patterns", help="Path to patterns directory"
+        "--patterns-dir",
+        default="./patterns",
+        help="Path to patterns directory",
     )
     parser_sync_claude.add_argument(
         "--output-dir",
@@ -2342,13 +2737,16 @@ def main():
         help="Category to show (getting-started, daily-workflow, code-quality, etc.)",
     )
     parser_cheatsheet.add_argument(
-        "--compact", action="store_true", help="Show commands only without descriptions"
+        "--compact",
+        action="store_true",
+        help="Show commands only without descriptions",
     )
     parser_cheatsheet.set_defaults(func=cmd_cheatsheet)
 
     # Onboard command (interactive tutorial)
     parser_onboard = subparsers.add_parser(
-        "onboard", help="Interactive onboarding tutorial for new users"
+        "onboard",
+        help="Interactive onboarding tutorial for new users",
     )
     parser_onboard.add_argument("--step", type=int, help="Jump to a specific step (1-5)")
     parser_onboard.add_argument("--reset", action="store_true", help="Reset onboarding progress")
@@ -2356,7 +2754,8 @@ def main():
 
     # Explain command (detailed command explanations)
     parser_explain = subparsers.add_parser(
-        "explain", help="Get detailed explanation of how a command works"
+        "explain",
+        help="Get detailed explanation of how a command works",
     )
     parser_explain.add_argument(
         "command",
@@ -2367,10 +2766,14 @@ def main():
 
     # Achievements command (progress tracking)
     parser_achievements = subparsers.add_parser(
-        "achievements", help="View your usage statistics and achievements"
+        "achievements",
+        help="View your usage statistics and achievements",
     )
     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()
 
@@ -2382,13 +2785,16 @@ 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
-    else:
-        parser.print_help()
-        return 0
+    parser.print_help()
+    return 0
 
 
 if __name__ == "__main__":