"""Interactive configuration wizard for AutoRestTest.""" from pathlib import Path from typing import Any, Dict, List, Optional, Tuple from rich.align import Align from rich.box import DOUBLE, ROUNDED from rich.console import Console, Group from rich.panel import Panel from rich.prompt import Confirm, FloatPrompt, IntPrompt, Prompt from rich.table import Table from rich.text import Text from autoresttest.config import get_config from autoresttest.config.config import ( Config, ) from .themes import DEFAULT_THEME, TUITheme class ConfigWizard: """Interactive configuration wizard with beautiful TUI.""" # Popular LLM engines organized by provider LLM_ENGINES = { "OpenAI": [ ( "gpt-5-mini-2025-08-07", "GPT-5 Mini - Recommended balance of speed & quality", ), ( "gpt-5-nano-2025-08-07", "GPT-5 Nano - Budget-friendly, may be less accurate", ), ("gpt-5.2-2025-12-11", "GPT-5.2 - Higher intelligence, slower"), ], "OpenRouter": [ ( "google/gemini-2.5-flash-lite-preview-09-2025", "Gemini 2.5 Flash Lite - Recommended: cheap & fast", ), ( "google/gemini-3-flash-preview", "Gemini 3 Flash - Fast with higher intelligence", ), ("anthropic/claude-haiku-4.5", "Claude Haiku 4.5 - Fast & smart"), ( "meta-llama/llama-3.3-70b-instruct", "Llama 3.3 70B - Efficient open-source", ), ], "Local": [ ("local-model", "Local Model - Custom endpoint"), ], } API_BASES = { "OpenAI": "https://api.openai.com/v1", "OpenRouter": "https://openrouter.ai/api/v1", "Local": "http://localhost:1234/v1", } def __init__(self, theme: TUITheme = DEFAULT_THEME, width: int = 100): self.console = Console(force_terminal=True, width=width) self.theme = theme self.width = width self._default_config = get_config() def _print_section(self, title: str, icon: str = ""): """Print a styled section header.""" header = Text() if icon: header.append(f"{icon} ", style=self.theme.primary) header.append(title, style=f"bold {self.theme.primary}") panel = Panel( Align.center(header), box=ROUNDED, border_style=self.theme.accent, padding=(0, 2), ) self.console.print() self.console.print(panel) def _print_option_table( self, options: List[Tuple[str, str]], title: str = "Options" ): """Print a table of numbered options.""" table = Table( box=ROUNDED, border_style=self.theme.accent, show_header=True, header_style=f"bold {self.theme.secondary}", padding=(0, 1), ) table.add_column( "#", style=f"bold {self.theme.primary}", width=4, justify="center" ) table.add_column("Option", style=self.theme.text) table.add_column("Description", style=self.theme.text_dim) for i, (option, desc) in enumerate(options, 1): table.add_row(str(i), option, desc) self.console.print(table) def _select_option( self, options: List[Tuple[str, str]], prompt_text: str, default_index: int = 0, ) -> int: """Display options and get user selection.""" self._print_option_table(options) while True: self.console.print() default_display = f"[{self.theme.text_dim}]default: {default_index + 1}[/{self.theme.text_dim}]" arrow = f"[{self.theme.symbol_arrow_color}]{self.theme.symbol_arrow}[/{self.theme.symbol_arrow_color}]" response = Prompt.ask( f" {arrow} {prompt_text} {default_display}", default=str(default_index + 1), console=self.console, ) try: idx = int(response) - 1 if 0 <= idx < len(options): return idx self.console.print( f" [red]Please enter a number between 1 and {len(options)}[/red]" ) except ValueError: if response.strip() == "": return default_index self.console.print(" [red]Please enter a valid number[/red]") def _prompt_value( self, prompt_text: str, default: Any, value_type: type = str, validation: Optional[callable] = None, ) -> Any: """Prompt for a value with type conversion and optional validation.""" default_display = ( f"[{self.theme.text_dim}]default: {default}[/{self.theme.text_dim}]" ) arrow = f"[{self.theme.symbol_arrow_color}]{self.theme.symbol_arrow}[/{self.theme.symbol_arrow_color}]" while True: if value_type == bool: return Confirm.ask( f" {arrow} {prompt_text}", default=default, console=self.console, ) elif value_type == int: result = IntPrompt.ask( f" {arrow} {prompt_text} {default_display}", default=default, console=self.console, ) elif value_type == float: result = FloatPrompt.ask( f" {arrow} {prompt_text} {default_display}", default=default, console=self.console, ) else: result = Prompt.ask( f" {arrow} {prompt_text} {default_display}", default=str(default), console=self.console, ) if validation: valid, error_msg = validation(result) if not valid: self.console.print(f" [red]{error_msg}[/red]") continue return result def _find_spec_files(self) -> List[Tuple[str, str]]: """Find OpenAPI specification files in the project.""" spec_dirs = [ Path("specs"), Path("aratrl-openapi"), ] specs = [] for spec_dir in spec_dirs: if spec_dir.exists(): for ext in ["*.yaml", "*.yml", "*.json"]: for spec_file in spec_dir.rglob(ext): rel_path = str(spec_file) specs.append((rel_path, f"Found in {spec_dir}")) # Limit to first 8 for display (has 2 other defaults, so 10 total) if len(specs) > 8: specs = specs[:8] specs.append(("... more available", "Enter custom path")) return specs def run(self, quick_mode: bool = False) -> Optional[Dict[str, Any]]: """Run the configuration wizard. Args: quick_mode: If True, only prompt for essential settings Returns: Dictionary of configuration overrides, or None if cancelled """ self.console.clear() # Welcome header welcome = Text() welcome.append("Configuration Wizard", style=f"bold {self.theme.primary}") desc = Text( "Configure AutoRestTest interactively. Press Enter to keep defaults.", style=self.theme.text_dim, ) panel = Panel( Group(Align.center(welcome), Text(), Align.center(desc)), box=DOUBLE, border_style=self.theme.primary, padding=(1, 2), ) self.console.print(panel) overrides: Dict[str, Any] = {} try: # Mode selection if not quick_mode: self._print_section("Setup Mode", "") modes = [ ("Quick Setup", "Configure essential settings only (spec, LLM)"), ("Full Setup", "Configure all available settings"), ("Use Defaults", "Start with current configurations.toml"), ] mode_idx = self._select_option( modes, "Select setup mode", default_index=2 ) if mode_idx == 2: # Use defaults self.console.print( f"\n [{self.theme.symbol_success_color}]{self.theme.symbol_success}[/{self.theme.symbol_success_color}] Using default configuration" ) return {} elif mode_idx == 0: quick_mode = True # 1. Specification Selection overrides.update(self._configure_spec()) # 2. LLM Configuration overrides.update(self._configure_llm()) if not quick_mode: # 3. Q-Learning Parameters overrides.update(self._configure_q_learning()) # 4. Request Generation overrides.update(self._configure_request_generation()) # 5. Cache Settings overrides.update(self._configure_cache()) # 6. API Override overrides.update(self._configure_api()) # 7. Agent Settings overrides.update(self._configure_agents()) # Summary self._print_config_summary(overrides) arrow = f"[{self.theme.symbol_arrow_color}]{self.theme.symbol_arrow}[/{self.theme.symbol_arrow_color}]" warning = f"[{self.theme.symbol_warning_color}]{self.theme.symbol_warning}[/{self.theme.symbol_warning_color}]" if Confirm.ask( f"\n {arrow} Proceed with this configuration?", default=True, console=self.console, ): return overrides else: self.console.print(f"\n {warning} Configuration cancelled") return None except KeyboardInterrupt: warning = f"[{self.theme.symbol_warning_color}]{self.theme.symbol_warning}[/{self.theme.symbol_warning_color}]" self.console.print(f"\n\n {warning} Configuration cancelled") return None def _configure_spec(self) -> Dict[str, Any]: """Configure specification settings.""" self._print_section("API Specification", "") overrides = {} # Find available specs specs = self._find_spec_files() if specs: specs.insert(0, ("Enter custom path", "Specify your own spec file path")) self.console.print( f"\n [dim]Current: {self._default_config.specification_location}[/dim]" ) idx = self._select_option(specs, "Select specification", default_index=0) if idx == 0: # Custom path spec_path = self._prompt_value( "Enter specification path (relative to project root)", self._default_config.specification_location, ) else: spec_path = specs[idx][0] if spec_path != self._default_config.specification_location: overrides["spec"] = {"location": spec_path} else: spec_path = self._prompt_value( "Enter specification path", self._default_config.specification_location, ) if spec_path != self._default_config.specification_location: overrides["spec"] = {"location": spec_path} return overrides def _configure_llm(self) -> Dict[str, Any]: """Configure LLM settings.""" self._print_section("LLM Configuration", "") overrides = {} llm_config = {} # Provider selection providers = [ ("OpenAI", "Direct OpenAI API"), ("OpenRouter", "Access many models via OpenRouter"), ("Local", "Local model (LM Studio, Ollama, etc.)"), ("Custom", "Enter custom engine and API base"), ] self.console.print( f"\n [dim]Current engine: {self._default_config.openai_llm_engine}[/dim]" ) self.console.print( f" [dim]Current API base: {self._default_config.llm_api_base}[/dim]" ) provider_idx = self._select_option( providers, "Select LLM provider", default_index=1 ) provider = providers[provider_idx][0] if provider == "Custom": engine = self._prompt_value( "Enter model name", self._default_config.openai_llm_engine ) api_base = self._prompt_value( "Enter API base URL", self._default_config.llm_api_base ) else: # Model selection for known providers if provider in self.LLM_ENGINES: models = list(self.LLM_ENGINES[provider]) # Add custom model ID option for all providers models.append(("custom", "Enter custom model ID")) model_idx = self._select_option(models, "Select model", default_index=0) if models[model_idx][0] == "custom": # User wants to enter a custom model ID engine = self._prompt_value( "Enter model ID", self._default_config.openai_llm_engine ) else: engine = models[model_idx][0] else: engine = self._default_config.openai_llm_engine api_base = self.API_BASES.get(provider, self._default_config.llm_api_base) if engine != self._default_config.openai_llm_engine: llm_config["engine"] = engine if api_base != self._default_config.llm_api_base: llm_config["api_base"] = api_base # Temperature settings temp = self._prompt_value( "Creative temperature (0.0-2.0)", self._default_config.creative_temperature, float, ) if temp != self._default_config.creative_temperature: llm_config["creative_temperature"] = temp llm_config["strict_temperature"] = temp # Max tokens max_tokens = self._prompt_value( "Max tokens (-1 for provider default)", self._default_config.llm_max_tokens, int, ) if max_tokens != self._default_config.llm_max_tokens: llm_config["max_tokens"] = max_tokens if llm_config: overrides["llm"] = llm_config return overrides def _configure_q_learning(self) -> Dict[str, Any]: """Configure Q-learning parameters.""" self._print_section("Q-Learning Parameters", "") overrides = {} q_config = {} self.console.print( "\n [dim]These settings control the reinforcement learning behavior.[/dim]" ) learning_rate = self._prompt_value( "Learning rate (alpha, 0.0-1.0)", self._default_config.q_learning.learning_rate, float, ) if learning_rate != self._default_config.q_learning.learning_rate: q_config["learning_rate"] = learning_rate discount = self._prompt_value( "Discount factor (gamma, 0.0-1.0)", self._default_config.q_learning.discount_factor, float, ) if discount != self._default_config.q_learning.discount_factor: q_config["discount_factor"] = discount exploration = self._prompt_value( "Initial exploration (epsilon, 0.0-1.0)", self._default_config.q_learning.max_exploration, float, ) if exploration != self._default_config.q_learning.max_exploration: q_config["max_exploration"] = exploration if q_config: overrides["q_learning"] = q_config return overrides def _configure_request_generation(self) -> Dict[str, Any]: """Configure request generation settings.""" self._print_section("Request Generation", "") overrides = {} req_config = {} # Time duration with helpful presets durations = [ ("300", "5 minutes - Quick test"), ("600", "10 minutes - Short run"), ("1200", "20 minutes - Standard (default)"), ("1800", "30 minutes - Extended"), ("3600", "60 minutes - Long run"), ("custom", "Enter custom duration"), ] self.console.print( f"\n [dim]Current duration: {self._default_config.request_generation.time_duration}s[/dim]" ) idx = self._select_option(durations, "Select test duration", default_index=2) if durations[idx][0] == "custom": duration = self._prompt_value( "Enter duration in seconds", self._default_config.request_generation.time_duration, int, ) else: duration = int(durations[idx][0]) if duration != self._default_config.request_generation.time_duration: req_config["time_duration"] = duration mutation_rate = self._prompt_value( "Mutation rate (0.0-1.0)", self._default_config.request_generation.mutation_rate, float, ) if mutation_rate != self._default_config.request_generation.mutation_rate: req_config["mutation_rate"] = mutation_rate if req_config: overrides["request_generation"] = req_config return overrides def _configure_cache(self) -> Dict[str, Any]: """Configure cache settings.""" self._print_section("Cache Settings", "") overrides = {} cache_config = {} self.console.print( "\n [dim]Caching speeds up repeated runs by reusing computed data.[/dim]" ) use_graph = self._prompt_value( "Use cached graph?", self._default_config.cache.use_cached_graph, bool, ) if use_graph != self._default_config.cache.use_cached_graph: cache_config["use_cached_graph"] = use_graph use_table = self._prompt_value( "Use cached Q-tables?", self._default_config.cache.use_cached_table, bool, ) if use_table != self._default_config.cache.use_cached_table: cache_config["use_cached_table"] = use_table if cache_config: overrides["cache"] = cache_config return overrides def _configure_api(self) -> Dict[str, Any]: """Configure API URL override settings.""" self._print_section("API URL Override", "") overrides = {} api_config = {} self.console.print( "\n [dim]Override the API URL from the specification with a custom endpoint.[/dim]" ) override_url = self._prompt_value( "Override API URL from spec?", self._default_config.api.override_url, bool, ) if override_url: api_config["override_url"] = True host = self._prompt_value( "API Host", self._default_config.api.host, ) if host != self._default_config.api.host: api_config["host"] = host port = self._prompt_value( "API Port", self._default_config.api.port, int, ) if port != self._default_config.api.port: api_config["port"] = port if api_config: overrides["api"] = api_config return overrides def _configure_agents(self) -> Dict[str, Any]: """Configure agent-specific settings.""" self._print_section("Agent Configuration", "") overrides = {} # Header agent self.console.print( "\n [dim]Header Agent generates Basic Authentication headers.[/dim]" ) enable_header = self._prompt_value( "Enable Header Agent?", self._default_config.enable_header_agent, bool, ) if enable_header != self._default_config.enable_header_agent: overrides["agents"] = {"header": {"enabled": enable_header}} # Value agent parallelization self.console.print( "\n [dim]Value Agent parallelization speeds up Q-table initialization.[/dim]" ) parallelize = self._prompt_value( "Parallelize value generation?", self._default_config.parallelize_value_generation, bool, ) if parallelize: workers = self._prompt_value( "Number of worker threads", self._default_config.value_generation_workers, int, ) if ( parallelize != self._default_config.parallelize_value_generation or workers != self._default_config.value_generation_workers ): if "agent" not in overrides: overrides["agent"] = {} overrides["agent"]["value"] = { "parallelize": parallelize, "max_workers": workers, } return overrides def _print_config_summary(self, overrides: Dict[str, Any]): """Print a summary of the configuration changes.""" self._print_section("Configuration Summary", "") if not overrides: info = f"[{self.theme.symbol_info_color}]{self.theme.symbol_info}[/{self.theme.symbol_info_color}]" self.console.print(f"\n {info} No changes from default configuration") return table = Table( box=ROUNDED, border_style=self.theme.accent, show_header=True, header_style=f"bold {self.theme.secondary}", ) table.add_column("Setting", style=self.theme.text_dim) table.add_column("New Value", style=f"bold {self.theme.success}") def flatten_dict(d: Dict, prefix: str = "") -> List[Tuple[str, str]]: items = [] for k, v in d.items(): key = f"{prefix}.{k}" if prefix else k if isinstance(v, dict): items.extend(flatten_dict(v, key)) else: items.append((key, str(v))) return items for key, value in flatten_dict(overrides): table.add_row(key, value) self.console.print() self.console.print(Align.center(table)) def apply_config_overrides(overrides: Dict[str, Any]) -> Config: """Apply configuration overrides and return a new Config object. This creates a modified config without writing to disk. """ from autoresttest.config.config import _load_raw_config raw_config = _load_raw_config() def deep_merge(base: Dict, override: Dict) -> Dict: result = base.copy() for key, value in override.items(): if ( key in result and isinstance(result[key], dict) and isinstance(value, dict) ): result[key] = deep_merge(result[key], value) else: result[key] = value return result merged = deep_merge(raw_config, overrides) return Config.model_validate(merged)