code-puppy 0.0.348__py3-none-any.whl → 0.0.372__py3-none-any.whl

code_puppy/command_line/core_commands.py

@@ -6,6 +6,7 @@ discovered by the command registry system.
 
 import os
 
+from code_puppy.command_line.agent_menu import interactive_agent_picker
 from code_puppy.command_line.command_registry import register_command
 from code_puppy.command_line.model_picker_completion import update_model_in_input
 from code_puppy.command_line.motd import print_motd
@@ -168,7 +169,7 @@ def handle_tutorial_command(command: str) -> bool:
         reset_onboarding,
         run_onboarding_wizard,
     )
-    from code_puppy.config import set_model_name
+    from code_puppy.model_switching import set_model_and_reload_agent
 
     # Always reset so user can re-run the tutorial anytime
     reset_onboarding()
@@ -183,7 +184,7 @@ def handle_tutorial_command(command: str) -> bool:
         from code_puppy.plugins.chatgpt_oauth.oauth_flow import run_oauth_flow
 
         run_oauth_flow()
-        set_model_name("chatgpt-gpt-5.2-codex")
+        set_model_and_reload_agent("chatgpt-gpt-5.2-codex")
     elif result == "claude":
         emit_info("🔐 Starting Claude Code OAuth flow...")
         from code_puppy.plugins.claude_code_oauth.register_callbacks import (
@@ -191,7 +192,7 @@ def handle_tutorial_command(command: str) -> bool:
         )
 
         _perform_authentication()
-        set_model_name("claude-code-claude-opus-4-5-20251101")
+        set_model_and_reload_agent("claude-code-claude-opus-4-5-20251101")
     elif result == "completed":
         emit_info("🎉 Tutorial complete! Happy coding!")
     elif result == "skipped":
@@ -398,115 +399,6 @@ def handle_agent_command(command: str) -> bool:
         return True
 
 
-async def interactive_agent_picker() -> str | None:
-    """Show an interactive arrow-key selector to pick an agent (async version).
-
-    Returns:
-        The selected agent name, or None if cancelled
-    """
-    import sys
-    import time
-
-    from rich.console import Console
-    from rich.panel import Panel
-    from rich.text import Text
-
-    from code_puppy.agents import (
-        get_agent_descriptions,
-        get_available_agents,
-        get_current_agent,
-    )
-    from code_puppy.tools.command_runner import set_awaiting_user_input
-    from code_puppy.tools.common import arrow_select_async
-
-    # Load available agents
-    available_agents = get_available_agents()
-    descriptions = get_agent_descriptions()
-    current_agent = get_current_agent()
-
-    # Build choices with current agent indicator and keep track of agent names
-    choices = []
-    agent_names = list(available_agents.keys())
-    for agent_name in agent_names:
-        display_name = available_agents[agent_name]
-        if agent_name == current_agent.name:
-            choices.append(f"✓ {agent_name} - {display_name} (current)")
-        else:
-            choices.append(f"  {agent_name} - {display_name}")
-
-    # Create preview callback to show agent description
-    def get_preview(index: int) -> str:
-        """Get the description for the agent at the given index."""
-        agent_name = agent_names[index]
-        description = descriptions.get(agent_name, "No description available")
-        return description
-
-    # Create panel content
-    panel_content = Text()
-    panel_content.append("🐶 Select an agent to use\n", style="bold cyan")
-    panel_content.append("Current agent: ", style="dim")
-    panel_content.append(f"{current_agent.name}", style="bold green")
-    panel_content.append(" - ", style="dim")
-    panel_content.append(current_agent.display_name, style="bold green")
-    panel_content.append("\n", style="dim")
-    panel_content.append(current_agent.description, style="dim italic")
-
-    # Display panel
-    panel = Panel(
-        panel_content,
-        title="[bold white]Agent Selection[/bold white]",
-        border_style="cyan",
-        padding=(1, 2),
-    )
-
-    # Pause spinners BEFORE showing panel
-    set_awaiting_user_input(True)
-    time.sleep(0.3)  # Let spinners fully stop
-
-    local_console = Console()
-    emit_info("")
-    local_console.print(panel)
-    emit_info("")
-
-    # Flush output before prompt_toolkit takes control
-    sys.stdout.flush()
-    sys.stderr.flush()
-    time.sleep(0.1)
-
-    selected_agent = None
-
-    try:
-        # Final flush
-        sys.stdout.flush()
-
-        # Show arrow-key selector with preview (async version)
-        choice = await arrow_select_async(
-            "💭 Which agent would you like to use?",
-            choices,
-            preview_callback=get_preview,
-        )
-
-        # Extract agent name from choice (remove prefix and suffix)
-        if choice:
-            # Remove the "✓ " or "  " prefix and extract agent name (before " - ")
-            choice_stripped = choice.strip().lstrip("✓").strip()
-            # Split on " - " and take the first part (agent name)
-            agent_name = choice_stripped.split(" - ")[0].strip()
-            # Remove " (current)" suffix if present
-            if agent_name.endswith(" (current)"):
-                agent_name = agent_name[:-10].strip()
-            selected_agent = agent_name
-
-    except (KeyboardInterrupt, EOFError):
-        emit_error("Cancelled by user")
-        selected_agent = None
-
-    finally:
-        set_awaiting_user_input(False)
-
-    return selected_agent
-
-
 async def interactive_model_picker() -> str | None:
     """Show an interactive arrow-key selector to pick a model (async version).
 
@@ -772,6 +664,91 @@ def handle_mcp_command(command: str) -> bool:
     return handler.handle_mcp_command(command)
 
 
+@register_command(
+    name="api",
+    description="Manage the Code Puppy API server",
+    usage="/api [start|stop|status]",
+    category="core",
+    detailed_help="Start, stop, or check status of the local FastAPI server for GUI integration.",
+)
+def handle_api_command(command: str) -> bool:
+    """Handle the /api command."""
+    import os
+    import signal
+    import subprocess
+    import sys
+    from pathlib import Path
+
+    from code_puppy.config import STATE_DIR
+    from code_puppy.messaging import emit_error, emit_info, emit_success
+
+    parts = command.split()
+    subcommand = parts[1] if len(parts) > 1 else "status"
+
+    pid_file = Path(STATE_DIR) / "api_server.pid"
+
+    if subcommand == "start":
+        # Check if already running
+        if pid_file.exists():
+            try:
+                pid = int(pid_file.read_text().strip())
+                os.kill(pid, 0)  # Check if process exists
+                emit_info(f"API server already running (PID {pid})")
+                return True
+            except (OSError, ValueError):
+                pid_file.unlink(missing_ok=True)  # Stale PID file
+
+        # Start the server in background
+        emit_info("Starting API server on http://127.0.0.1:8765 ...")
+        proc = subprocess.Popen(
+            [sys.executable, "-m", "code_puppy.api.main"],
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+            start_new_session=True,
+        )
+        pid_file.parent.mkdir(parents=True, exist_ok=True)
+        pid_file.write_text(str(proc.pid))
+        emit_success(f"API server started (PID {proc.pid})")
+        emit_info("Docs available at http://127.0.0.1:8765/docs")
+        return True
+
+    elif subcommand == "stop":
+        if not pid_file.exists():
+            emit_info("API server is not running")
+            return True
+
+        try:
+            pid = int(pid_file.read_text().strip())
+            os.kill(pid, signal.SIGTERM)
+            pid_file.unlink()
+            emit_success(f"API server stopped (PID {pid})")
+        except (OSError, ValueError) as e:
+            pid_file.unlink(missing_ok=True)
+            emit_error(f"Error stopping server: {e}")
+        return True
+
+    elif subcommand == "status":
+        if not pid_file.exists():
+            emit_info("API server is not running")
+            return True
+
+        try:
+            pid = int(pid_file.read_text().strip())
+            os.kill(pid, 0)  # Check if process exists
+            emit_success(f"API server is running (PID {pid})")
+            emit_info("URL: http://127.0.0.1:8765")
+            emit_info("Docs: http://127.0.0.1:8765/docs")
+        except (OSError, ValueError):
+            pid_file.unlink(missing_ok=True)
+            emit_info("API server is not running (stale PID file removed)")
+        return True
+
+    else:
+        emit_error(f"Unknown subcommand: {subcommand}")
+        emit_info("Usage: /api [start|stop|status]")
+        return True
+
+
 @register_command(
     name="generate-pr-description",
     description="Generate comprehensive PR description",

code_puppy/command_line/model_picker_completion.py

@@ -6,8 +6,9 @@ from prompt_toolkit.completion import Completer, Completion
 from prompt_toolkit.document import Document
 from prompt_toolkit.history import FileHistory
 
-from code_puppy.config import get_global_model_name, set_model_name
+from code_puppy.config import get_global_model_name
 from code_puppy.model_factory import ModelFactory
+from code_puppy.model_switching import set_model_and_reload_agent
 
 
 def load_model_names():
@@ -28,25 +29,7 @@ def set_active_model(model_name: str):
     """
     Sets the active model name by updating the config (for persistence).
     """
-    from code_puppy.messaging import emit_info, emit_warning
-
-    set_model_name(model_name)
-    # Reload the currently active agent so the new model takes effect immediately
-    try:
-        from code_puppy.agents import get_current_agent
-
-        current_agent = get_current_agent()
-        # JSON agents may need to refresh their config before reload
-        if hasattr(current_agent, "refresh_config"):
-            try:
-                current_agent.refresh_config()
-            except Exception:
-                # Non-fatal, continue to reload
-                ...
-        current_agent.reload_code_generation_agent()
-        emit_info("Active agent reloaded")
-    except Exception as e:
-        emit_warning(f"Model changed but agent reload failed: {e}")
+    set_model_and_reload_agent(model_name)
 
 
 class ModelNameCompleter(Completer):

code_puppy/command_line/model_settings_menu.py

@@ -39,10 +39,10 @@ SETTING_DEFINITIONS: Dict[str, Dict] = {
         "description": "Controls randomness. Lower = more deterministic, higher = more creative.",
         "type": "numeric",
         "min": 0.0,
-        "max": 1.0,  # Clamped to 0-1 per user request
-        "step": 0.1,
+        "max": 1.0,
+        "step": 0.05,
         "default": None,  # None means use model default
-        "format": "{:.1f}",
+        "format": "{:.2f}",
     },
     "seed": {
         "name": "Seed",
@@ -54,6 +54,16 @@ SETTING_DEFINITIONS: Dict[str, Dict] = {
         "default": None,
         "format": "{:.0f}",
     },
+    "top_p": {
+        "name": "Top-P (Nucleus Sampling)",
+        "description": "Controls token diversity. 0.0 = least random (only most likely tokens), 1.0 = most random (sample from all tokens).",
+        "type": "numeric",
+        "min": 0.0,
+        "max": 1.0,
+        "step": 0.05,
+        "default": None,
+        "format": "{:.2f}",
+    },
     "reasoning_effort": {
         "name": "Reasoning Effort",
         "description": "Controls how much effort GPT-5 models spend on reasoning. Higher = more thorough but slower.",
@@ -90,6 +100,12 @@ SETTING_DEFINITIONS: Dict[str, Dict] = {
         "type": "boolean",
         "default": False,
     },
+    "clear_thinking": {
+        "name": "Clear Thinking",
+        "description": "False = Preserved Thinking (keep <think> blocks visible). True = strip thinking from responses.",
+        "type": "boolean",
+        "default": False,
+    },
 }
 
 
@@ -569,6 +585,8 @@ class ModelSettingsMenu:
             # Default to a sensible starting point for numeric
             if setting_key == "temperature":
                 self.edit_value = 0.7
+            elif setting_key == "top_p":
+                self.edit_value = 0.9  # Common default for top_p
             elif setting_key == "seed":
                 self.edit_value = 42
             elif setting_key == "budget_tokens":

code_puppy/config.py

@@ -75,17 +75,61 @@ def get_use_dbos() -> bool:
     return str(cfg_val).strip().lower() in {"1", "true", "yes", "on"}
 
 
+def get_subagent_verbose() -> bool:
+    """Return True if sub-agent verbose output is enabled (default False).
+
+    When False (default), sub-agents produce quiet, sparse output suitable
+    for parallel execution. When True, sub-agents produce full verbose output
+    like the main agent (useful for debugging).
+    """
+    cfg_val = get_value("subagent_verbose")
+    if cfg_val is None:
+        return False
+    return str(cfg_val).strip().lower() in {"1", "true", "yes", "on"}
+
+
+# Pack agents - the specialized sub-agents coordinated by Pack Leader
+PACK_AGENT_NAMES = frozenset(
+    [
+        "pack-leader",
+        "bloodhound",
+        "husky",
+        "shepherd",
+        "terrier",
+        "watchdog",
+        "retriever",
+    ]
+)
+
+
+def get_pack_agents_enabled() -> bool:
+    """Return True if pack agents are enabled (default False).
+
+    When False (default), pack agents (pack-leader, bloodhound, husky, shepherd,
+    terrier, watchdog, retriever) are hidden from `list_agents` tool and `/agents`
+    command. They cannot be invoked by other agents or selected by users.
+
+    When True, pack agents are available for use.
+    """
+    cfg_val = get_value("enable_pack_agents")
+    if cfg_val is None:
+        return False
+    return str(cfg_val).strip().lower() in {"1", "true", "yes", "on"}
+
+
 DEFAULT_SECTION = "puppy"
 REQUIRED_KEYS = ["puppy_name", "owner_name"]
 
 # Runtime-only autosave session ID (per-process)
 _CURRENT_AUTOSAVE_ID: Optional[str] = None
 
+# Session-local model name (initialized from file on first access, then cached)
+_SESSION_MODEL: Optional[str] = None
+
 # Cache containers for model validation and defaults
 _model_validation_cache = {}
 _default_model_cache = None
 _default_vision_model_cache = None
-_default_vqa_model_cache = None
 
 
 def ensure_config_exists():
@@ -208,9 +252,14 @@ def get_config_keys():
         "diff_context_lines",
         "default_agent",
         "temperature",
+        "frontend_emitter_enabled",
+        "frontend_emitter_max_recent_events",
+        "frontend_emitter_queue_size",
     ]
     # Add DBOS control key
     default_keys.append("enable_dbos")
+    # Add pack agents control key
+    default_keys.append("enable_pack_agents")
     # Add cancel agent key configuration
     default_keys.append("cancel_agent_key")
     # Add banner color keys
@@ -237,6 +286,22 @@ def set_config_value(key: str, value: str):
         config.write(f)
 
 
+# Alias for API compatibility
+def set_value(key: str, value: str) -> None:
+    """Set a config value. Alias for set_config_value."""
+    set_config_value(key, value)
+
+
+def reset_value(key: str) -> None:
+    """Remove a key from the config file, resetting it to default."""
+    config = configparser.ConfigParser()
+    config.read(CONFIG_FILE)
+    if DEFAULT_SECTION in config and key in config[DEFAULT_SECTION]:
+        del config[DEFAULT_SECTION][key]
+        with open(CONFIG_FILE, "w") as f:
+            config.write(f)
+
+
 # --- MODEL STICKY EXTENSION STARTS HERE ---
 def load_mcp_server_configs():
     """
@@ -326,47 +391,6 @@ def _default_vision_model_from_models_json() -> str:
         return "gpt-4.1"
 
 
-def _default_vqa_model_from_models_json() -> str:
-    """Select a default VQA-capable model, preferring vision-ready options."""
-    global _default_vqa_model_cache
-
-    if _default_vqa_model_cache is not None:
-        return _default_vqa_model_cache
-
-    try:
-        from code_puppy.model_factory import ModelFactory
-
-        models_config = ModelFactory.load_config()
-        if models_config:
-            # Allow explicit VQA hints if present
-            for name, config in models_config.items():
-                if config.get("supports_vqa"):
-                    _default_vqa_model_cache = name
-                    return name
-
-            # Reuse multimodal heuristics before falling back to generic default
-            preferred_candidates = (
-                "gpt-4.1",
-                "gpt-4.1-mini",
-                "claude-4-0-sonnet",
-                "gemini-2.5-flash-preview-05-20",
-                "gpt-4.1-nano",
-            )
-            for candidate in preferred_candidates:
-                if candidate in models_config:
-                    _default_vqa_model_cache = candidate
-                    return candidate
-
-            _default_vqa_model_cache = _default_model_from_models_json()
-            return _default_vqa_model_cache
-
-        _default_vqa_model_cache = "gpt-4.1"
-        return "gpt-4.1"
-    except Exception:
-        _default_vqa_model_cache = "gpt-4.1"
-        return "gpt-4.1"
-
-
 def _validate_model_exists(model_name: str) -> bool:
     """Check if a model exists in models.json with caching to avoid redundant calls."""
     global _model_validation_cache
@@ -392,15 +416,20 @@ def _validate_model_exists(model_name: str) -> bool:
 
 def clear_model_cache():
     """Clear the model validation cache. Call this when models.json changes."""
-    global \
-        _model_validation_cache, \
-        _default_model_cache, \
-        _default_vision_model_cache, \
-        _default_vqa_model_cache
+    global _model_validation_cache, _default_model_cache, _default_vision_model_cache
     _model_validation_cache.clear()
     _default_model_cache = None
     _default_vision_model_cache = None
-    _default_vqa_model_cache = None
+
+
+def reset_session_model():
+    """Reset the session-local model cache.
+
+    This is primarily for testing purposes. In normal operation, the session
+    model is set once at startup and only changes via set_model_name().
+    """
+    global _SESSION_MODEL
+    _SESSION_MODEL = None
 
 
 def model_supports_setting(model_name: str, setting: str) -> bool:
@@ -414,6 +443,10 @@ def model_supports_setting(model_name: str, setting: str) -> bool:
         True if the model supports the setting, False otherwise.
         Defaults to True for backwards compatibility if model config doesn't specify.
     """
+    # GLM-4.7 models always support clear_thinking setting
+    if setting == "clear_thinking" and "glm-4.7" in model_name.lower():
+        return True
+
     try:
         from code_puppy.model_factory import ModelFactory
 
@@ -439,26 +472,49 @@ def model_supports_setting(model_name: str, setting: str) -> bool:
 def get_global_model_name():
     """Return a valid model name for Code Puppy to use.
 
-    1. Look at ``model`` in *puppy.cfg*.
-    2. If that value exists **and** is present in *models.json*, use it.
-    3. Otherwise return the first model listed in *models.json*.
-    4. As a last resort (e.g.
-       *models.json* unreadable) fall back to ``claude-4-0-sonnet``.
+    Uses session-local caching so that model changes in other terminals
+    don't affect this running instance. The file is only read once at startup.
+
+    1. If _SESSION_MODEL is set, return it (session cache)
+    2. Otherwise, look at ``model`` in *puppy.cfg*
+    3. If that value exists **and** is present in *models.json*, use it
+    4. Otherwise return the first model listed in *models.json*
+    5. As a last resort fall back to ``claude-4-0-sonnet``
+
+    The result is cached in _SESSION_MODEL for subsequent calls.
     """
+    global _SESSION_MODEL
+
+    # Return cached session model if already initialized
+    if _SESSION_MODEL is not None:
+        return _SESSION_MODEL
 
+    # First access - initialize from file
     stored_model = get_value("model")
 
     if stored_model:
         # Use cached validation to avoid hitting ModelFactory every time
         if _validate_model_exists(stored_model):
-            return stored_model
+            _SESSION_MODEL = stored_model
+            return _SESSION_MODEL
 
     # Either no stored model or it's not valid – choose default from models.json
-    return _default_model_from_models_json()
+    _SESSION_MODEL = _default_model_from_models_json()
+    return _SESSION_MODEL
 
 
 def set_model_name(model: str):
-    """Sets the model name in the persistent config file."""
+    """Sets the model name in both the session cache and persistent config file.
+
+    Updates _SESSION_MODEL immediately for this process, and writes to the
+    config file so new terminals will pick up this model as their default.
+    """
+    global _SESSION_MODEL
+
+    # Update session cache immediately
+    _SESSION_MODEL = model
+
+    # Also persist to file for new terminal sessions
     config = configparser.ConfigParser()
     config.read(CONFIG_FILE)
     if DEFAULT_SECTION not in config:
@@ -471,20 +527,6 @@ def set_model_name(model: str):
     clear_model_cache()
 
 
-def get_vqa_model_name() -> str:
-    """Return the configured VQA model, falling back to an inferred default."""
-    stored_model = get_value("vqa_model_name")
-    if stored_model and _validate_model_exists(stored_model):
-        return stored_model
-    return _default_vqa_model_from_models_json()
-
-
-def set_vqa_model_name(model: str):
-    """Persist the configured VQA model name and refresh caches."""
-    set_config_value("vqa_model_name", model or "")
-    clear_model_cache()
-
-
 def get_puppy_token():
     """Returns the puppy_token from config, or None if not set."""
     return get_value("puppy_token")
@@ -1291,6 +1333,8 @@ DEFAULT_BANNER_COLORS = {
     "invoke_agent": "deep_pink4",  # Ruby - agent invocation
     "subagent_response": "sea_green3",  # Emerald - sub-agent success
     "list_agents": "dark_slate_gray3",  # Slate - neutral listing
+    # Browser/Terminal tools - same color as edit_file (gold)
+    "terminal_tool": "dark_goldenrod",  # Gold - browser terminal operations
 }
 
 
@@ -1584,3 +1628,34 @@ def set_default_agent(agent_name: str) -> None:
         agent_name: The name of the agent to set as default.
     """
     set_config_value("default_agent", agent_name)
+
+
+# --- FRONTEND EMITTER CONFIGURATION ---
+def get_frontend_emitter_enabled() -> bool:
+    """Check if frontend emitter is enabled."""
+    val = get_value("frontend_emitter_enabled")
+    if val is None:
+        return True  # Enabled by default
+    return str(val).lower() in ("1", "true", "yes", "on")
+
+
+def get_frontend_emitter_max_recent_events() -> int:
+    """Get max number of recent events to buffer."""
+    val = get_value("frontend_emitter_max_recent_events")
+    if val is None:
+        return 100
+    try:
+        return int(val)
+    except ValueError:
+        return 100
+
+
+def get_frontend_emitter_queue_size() -> int:
+    """Get max subscriber queue size."""
+    val = get_value("frontend_emitter_queue_size")
+    if val is None:
+        return 100
+    try:
+        return int(val)
+    except ValueError:
+        return 100