code-puppy 0.0.302__py3-none-any.whl → 0.0.323__py3-none-any.whl

code_puppy/command_line/mcp/wizard_utils.py

@@ -7,6 +7,8 @@ Provides interactive functionality for installing and configuring MCP servers.
 import logging
 from typing import Any, Dict, Optional
 
+from rich.text import Text
+
 from code_puppy.messaging import emit_error, emit_info, emit_prompt
 
 # Configure logging
@@ -51,7 +53,7 @@ def run_interactive_install_wizard(manager, group_id: str) -> bool:
         required_env_vars = selected_server.get_environment_vars()
         if required_env_vars:
             emit_info(
-                "\n[yellow]Required Environment Variables:[/yellow]",
+                Text.from_markup("\n[yellow]Required Environment Variables:[/yellow]"),
                 message_group=group_id,
             )
             for var in required_env_vars:
@@ -61,7 +63,8 @@ def run_interactive_install_wizard(manager, group_id: str) -> bool:
                 current_value = os.environ.get(var, "")
                 if current_value:
                     emit_info(
-                        f"  {var}: [green]Already set[/green]", message_group=group_id
+                        Text.from_markup(f"  {var}: [green]Already set[/green]"),
+                        message_group=group_id,
                     )
                     env_vars[var] = current_value
                 else:
@@ -73,7 +76,8 @@ def run_interactive_install_wizard(manager, group_id: str) -> bool:
         required_cmd_args = selected_server.get_command_line_args()
         if required_cmd_args:
             emit_info(
-                "\n[yellow]Command Line Arguments:[/yellow]", message_group=group_id
+                Text.from_markup("\n[yellow]Command Line Arguments:[/yellow]"),
+                message_group=group_id,
             )
             for arg_config in required_cmd_args:
                 name = arg_config.get("name", "")
@@ -312,7 +316,9 @@ def install_server_from_catalog(
             json.dump(data, f, indent=2)
 
         emit_info(
-            f"[green]✓ Successfully installed server: {server_name}[/green]",
+            Text.from_markup(
+                f"[green]✓ Successfully installed server: {server_name}[/green]"
+            ),
             message_group=group_id,
         )
         emit_info(

code_puppy/command_line/model_settings_menu.py

@@ -58,7 +58,7 @@ SETTING_DEFINITIONS: Dict[str, Dict] = {
         "name": "Reasoning Effort",
         "description": "Controls how much effort GPT-5 models spend on reasoning. Higher = more thorough but slower.",
         "type": "choice",
-        "choices": ["low", "medium", "high"],
+        "choices": ["minimal", "low", "medium", "high", "xhigh"],
         "default": "medium",
     },
     "verbosity": {
@@ -72,7 +72,7 @@ SETTING_DEFINITIONS: Dict[str, Dict] = {
         "name": "Extended Thinking",
         "description": "Enable Claude's extended thinking mode for complex reasoning tasks.",
         "type": "boolean",
-        "default": False,
+        "default": True,
     },
     "budget_tokens": {
         "name": "Thinking Budget (tokens)",
@@ -84,6 +84,12 @@ SETTING_DEFINITIONS: Dict[str, Dict] = {
         "default": 10000,
         "format": "{:.0f}",
     },
+    "interleaved_thinking": {
+        "name": "Interleaved Thinking",
+        "description": "Enable thinking between tool calls (Claude 4 only: Opus 4.5, Opus 4.1, Opus 4, Sonnet 4). Adds beta header. WARNING: On Vertex/Bedrock, this FAILS for non-Claude 4 models!",
+        "type": "boolean",
+        "default": False,
+    },
 }
 
 
@@ -93,6 +99,42 @@ def _load_all_model_names() -> List[str]:
     return list(models_config.keys())
 
 
+def _get_setting_choices(
+    setting_key: str, model_name: Optional[str] = None
+) -> List[str]:
+    """Get the available choices for a setting, filtered by model capabilities.
+
+    For reasoning_effort, only codex models support 'xhigh' - regular GPT-5.2
+    models are capped at 'high'.
+
+    Args:
+        setting_key: The setting name (e.g., 'reasoning_effort', 'verbosity')
+        model_name: Optional model name to filter choices for
+
+    Returns:
+        List of valid choices for this setting and model combination.
+    """
+    setting_def = SETTING_DEFINITIONS.get(setting_key, {})
+    if setting_def.get("type") != "choice":
+        return []
+
+    base_choices = setting_def.get("choices", [])
+
+    # For reasoning_effort, filter 'xhigh' based on model support
+    if setting_key == "reasoning_effort" and model_name:
+        models_config = ModelFactory.load_config()
+        model_config = models_config.get(model_name, {})
+
+        # Check if model supports xhigh reasoning
+        supports_xhigh = model_config.get("supports_xhigh_reasoning", False)
+
+        if not supports_xhigh:
+            # Remove xhigh from choices for non-codex models
+            return [c for c in base_choices if c != "xhigh"]
+
+    return base_choices
+
+
 class ModelSettingsMenu:
     """Interactive TUI for model settings configuration.
 
@@ -427,7 +469,8 @@ class ModelSettingsMenu:
             if setting_def.get("type") == "choice":
                 lines.append(("bold", "  Options:"))
                 lines.append(("", "\n"))
-                choices = setting_def.get("choices", [])
+                # Get filtered choices based on model capabilities
+                choices = _get_setting_choices(setting_key, self.selected_model)
                 lines.append(
                     (
                         "fg:ansibrightblack",
@@ -514,8 +557,11 @@ class ModelSettingsMenu:
         if current is not None:
             self.edit_value = current
         elif setting_def.get("type") == "choice":
-            # For choice settings, start with the default
-            self.edit_value = setting_def.get("default", setting_def["choices"][0])
+            # For choice settings, start with the default (using filtered choices)
+            choices = _get_setting_choices(setting_key, self.selected_model)
+            self.edit_value = setting_def.get(
+                "default", choices[0] if choices else None
+            )
         elif setting_def.get("type") == "boolean":
             # For boolean settings, start with the default
             self.edit_value = setting_def.get("default", False)
@@ -541,8 +587,8 @@ class ModelSettingsMenu:
         setting_def = SETTING_DEFINITIONS[setting_key]
 
         if setting_def.get("type") == "choice":
-            # Cycle through choices
-            choices = setting_def["choices"]
+            # Cycle through filtered choices based on model capabilities
+            choices = _get_setting_choices(setting_key, self.selected_model)
             current_idx = (
                 choices.index(self.edit_value) if self.edit_value in choices else 0
             )

code_puppy/command_line/prompt_toolkit_completion.py

@@ -582,12 +582,26 @@ async def get_input_with_combined_completion(
     # Ctrl+X keybinding - exit with KeyboardInterrupt for shell command cancellation
     @bindings.add(Keys.ControlX)
     def _(event):
-        event.app.exit(exception=KeyboardInterrupt)
+        try:
+            event.app.exit(exception=KeyboardInterrupt)
+        except Exception:
+            # Ignore "Return value already set" errors when exit was already called
+            # This happens when user presses multiple exit keys in quick succession
+            pass
 
     # Escape keybinding - exit with KeyboardInterrupt
     @bindings.add(Keys.Escape)
     def _(event):
-        event.app.exit(exception=KeyboardInterrupt)
+        try:
+            event.app.exit(exception=KeyboardInterrupt)
+        except Exception:
+            # Ignore "Return value already set" errors when exit was already called
+            pass
+
+    # NOTE: We intentionally do NOT override Ctrl+C here.
+    # prompt_toolkit's default Ctrl+C handler properly resets the terminal state on Windows.
+    # Overriding it with event.app.exit(exception=KeyboardInterrupt) can leave the terminal
+    # in a bad state where characters cannot be typed. Let prompt_toolkit handle Ctrl+C natively.
 
     # Toggle multiline with Alt+M
     @bindings.add(Keys.Escape, "m")

code_puppy/command_line/session_commands.py

@@ -246,6 +246,8 @@ def handle_dump_context_command(command: str) -> bool:
 )
 def handle_load_context_command(command: str) -> bool:
     """Load message history from a file."""
+    from rich.text import Text
+
     from code_puppy.agents.agent_manager import get_current_agent
     from code_puppy.config import rotate_autosave_id
     from code_puppy.messaging import emit_error, emit_info, emit_success, emit_warning
@@ -278,12 +280,17 @@ def handle_load_context_command(command: str) -> bool:
     # Rotate autosave id to avoid overwriting any existing autosave
     try:
         new_id = rotate_autosave_id()
-        autosave_info = f"\n[dim]Autosave session rotated to: {new_id}[/dim]"
+        autosave_info = Text.from_markup(
+            f"\n[dim]Autosave session rotated to: {new_id}[/dim]"
+        )
     except Exception:
-        autosave_info = ""
+        autosave_info = Text("")
 
-    emit_success(
+    # Build the success message with proper Text concatenation
+    success_msg = Text(
         f"✅ Context loaded: {len(history)} messages ({total_tokens} tokens)\n"
-        f"📁 From: {session_path}{autosave_info}"
+        f"📁 From: {session_path}"
     )
+    success_msg.append_text(autosave_info)
+    emit_success(success_msg)
     return True

code_puppy/config.py

@@ -212,6 +212,9 @@ def get_config_keys():
     default_keys.append("enable_dbos")
     # Add cancel agent key configuration
     default_keys.append("cancel_agent_key")
+    # Add banner color keys
+    for banner_name in DEFAULT_BANNER_COLORS:
+        default_keys.append(f"banner_color_{banner_name}")
 
     config = configparser.ConfigParser()
     config.read(CONFIG_FILE)
@@ -256,9 +259,8 @@ def load_mcp_server_configs():
 def _default_model_from_models_json():
     """Load the default model name from models.json.
 
-    Prefers synthetic-GLM-4.6 as the default model.
-    Falls back to the first model in models.json if synthetic-GLM-4.6 is not available.
-    As a last resort, falls back to ``gpt-5`` if the file cannot be read.
+    Returns the first model in models.json as the default.
+    Falls back to ``gpt-5`` if the file cannot be read.
     """
     global _default_model_cache
 
@@ -270,11 +272,7 @@ def _default_model_from_models_json():
 
         models_config = ModelFactory.load_config()
         if models_config:
-            # Prefer synthetic-GLM-4.6 as default
-            if "synthetic-GLM-4.6" in models_config:
-                _default_model_cache = "synthetic-GLM-4.6"
-                return "synthetic-GLM-4.6"
-            # Fall back to first model if synthetic-GLM-4.6 is not available
+            # Use first model in models.json as default
             first_key = next(iter(models_config))
             _default_model_cache = first_key
             return first_key
@@ -497,8 +495,8 @@ def set_puppy_token(token: str):
 
 
 def get_openai_reasoning_effort() -> str:
-    """Return the configured OpenAI reasoning effort (low, medium, high)."""
-    allowed_values = {"low", "medium", "high"}
+    """Return the configured OpenAI reasoning effort (minimal, low, medium, high, xhigh)."""
+    allowed_values = {"minimal", "low", "medium", "high", "xhigh"}
     configured = (get_value("openai_reasoning_effort") or "medium").strip().lower()
     if configured not in allowed_values:
         return "medium"
@@ -507,7 +505,7 @@ def get_openai_reasoning_effort() -> str:
 
 def set_openai_reasoning_effort(value: str) -> None:
     """Persist the OpenAI reasoning effort ensuring it remains within allowed values."""
-    allowed_values = {"low", "medium", "high"}
+    allowed_values = {"minimal", "low", "medium", "high", "xhigh"}
     normalized = (value or "").strip().lower()
     if normalized not in allowed_values:
         raise ValueError(
@@ -658,10 +656,22 @@ def get_all_model_settings(model_name: str) -> dict:
         for key, val in config[DEFAULT_SECTION].items():
             if key.startswith(prefix) and val.strip():
                 setting_name = key[len(prefix) :]
-                try:
-                    settings[setting_name] = float(val)
-                except (ValueError, TypeError):
-                    pass
+                # Handle different value types
+                val_stripped = val.strip()
+                # Check for boolean values first
+                if val_stripped.lower() in ("true", "false"):
+                    settings[setting_name] = val_stripped.lower() == "true"
+                else:
+                    # Try to parse as number (int first, then float)
+                    try:
+                        # Try int first for cleaner values like budget_tokens
+                        if "." not in val_stripped:
+                            settings[setting_name] = int(val_stripped)
+                        else:
+                            settings[setting_name] = float(val_stripped)
+                    except (ValueError, TypeError):
+                        # Keep as string if not a number
+                        settings[setting_name] = val_stripped
 
     return settings
 
@@ -1257,6 +1267,84 @@ def set_diff_deletion_color(color: str):
     set_config_value("highlight_deletion_color", color)
 
 
+# =============================================================================
+# Banner Color Configuration
+# =============================================================================
+
+# Default banner colors (Rich color names)
+# A beautiful jewel-tone palette with semantic meaning:
+#   - Blues/Teals: Reading & navigation (calm, informational)
+#   - Warm tones: Actions & changes (edits, shell commands)
+#   - Purples: AI thinking & reasoning (the "brain" colors)
+#   - Greens: Completions & success
+#   - Neutrals: Search & listings
+DEFAULT_BANNER_COLORS = {
+    "thinking": "deep_sky_blue4",  # Sapphire - contemplation
+    "agent_response": "medium_purple4",  # Amethyst - main AI output
+    "shell_command": "dark_orange3",  # Amber - system commands
+    "read_file": "steel_blue",  # Steel - reading files
+    "edit_file": "dark_goldenrod",  # Gold - modifications
+    "grep": "grey37",  # Silver - search results
+    "directory_listing": "dodger_blue2",  # Sky - navigation
+    "agent_reasoning": "dark_violet",  # Violet - deep thought
+    "invoke_agent": "deep_pink4",  # Ruby - agent invocation
+    "subagent_response": "sea_green3",  # Emerald - sub-agent success
+    "list_agents": "dark_slate_gray3",  # Slate - neutral listing
+}
+
+
+def get_banner_color(banner_name: str) -> str:
+    """Get the background color for a specific banner.
+
+    Args:
+        banner_name: The banner identifier (e.g., 'thinking', 'agent_response')
+
+    Returns:
+        Rich color name or hex code for the banner background
+    """
+    config_key = f"banner_color_{banner_name}"
+    val = get_value(config_key)
+    if val:
+        return val
+    return DEFAULT_BANNER_COLORS.get(banner_name, "blue")
+
+
+def set_banner_color(banner_name: str, color: str):
+    """Set the background color for a specific banner.
+
+    Args:
+        banner_name: The banner identifier (e.g., 'thinking', 'agent_response')
+        color: Rich color name or hex code
+    """
+    config_key = f"banner_color_{banner_name}"
+    set_config_value(config_key, color)
+
+
+def get_all_banner_colors() -> dict:
+    """Get all banner colors (configured or default).
+
+    Returns:
+        Dict mapping banner names to their colors
+    """
+    return {name: get_banner_color(name) for name in DEFAULT_BANNER_COLORS}
+
+
+def reset_banner_color(banner_name: str):
+    """Reset a banner color to its default.
+
+    Args:
+        banner_name: The banner identifier to reset
+    """
+    default_color = DEFAULT_BANNER_COLORS.get(banner_name, "blue")
+    set_banner_color(banner_name, default_color)
+
+
+def reset_all_banner_colors():
+    """Reset all banner colors to their defaults."""
+    for name, color in DEFAULT_BANNER_COLORS.items():
+        set_banner_color(name, color)
+
+
 def get_current_autosave_id() -> str:
     """Get or create the current autosave session ID for this process."""
     global _CURRENT_AUTOSAVE_ID

code_puppy/keymap.py

@@ -86,9 +86,15 @@ def cancel_agent_uses_signal() -> bool:
     """Check if the cancel agent key uses SIGINT (Ctrl+C).
 
     Returns:
-        True if the cancel key is ctrl+c (uses SIGINT handler),
-        False if it uses keyboard listener approach.
+        True if the cancel key is ctrl+c AND we're not on Windows
+        (uses SIGINT handler), False if it uses keyboard listener approach.
     """
+    import sys
+
+    # On Windows, always use keyboard listener - SIGINT is unreliable
+    if sys.platform == "win32":
+        return False
+
     return get_cancel_agent_key() == "ctrl+c"