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

code_puppy/config.py

@@ -7,17 +7,58 @@ from typing import Optional
 
 from code_puppy.session_storage import save_session
 
-CONFIG_DIR = os.path.join(os.getenv("HOME", os.path.expanduser("~")), ".code_puppy")
+
+def _get_xdg_dir(env_var: str, fallback: str) -> str:
+    """
+    Get directory for code_puppy files, defaulting to ~/.code_puppy.
+
+    XDG paths are only used when the corresponding environment variable
+    is explicitly set by the user. Otherwise, we use the legacy ~/.code_puppy
+    directory for all file types (config, data, cache, state).
+
+    Args:
+        env_var: XDG environment variable name (e.g., "XDG_CONFIG_HOME")
+        fallback: Fallback path relative to home (e.g., ".config") - unused unless XDG var is set
+
+    Returns:
+        Path to the directory for code_puppy files
+    """
+    # Use XDG directory ONLY if environment variable is explicitly set
+    xdg_base = os.getenv(env_var)
+    if xdg_base:
+        return os.path.join(xdg_base, "code_puppy")
+
+    # Default to legacy ~/.code_puppy for all file types
+    return os.path.join(os.path.expanduser("~"), ".code_puppy")
+
+
+# XDG Base Directory paths
+CONFIG_DIR = _get_xdg_dir("XDG_CONFIG_HOME", ".config")
+DATA_DIR = _get_xdg_dir("XDG_DATA_HOME", ".local/share")
+CACHE_DIR = _get_xdg_dir("XDG_CACHE_HOME", ".cache")
+STATE_DIR = _get_xdg_dir("XDG_STATE_HOME", ".local/state")
+
+# Configuration files (XDG_CONFIG_HOME)
 CONFIG_FILE = os.path.join(CONFIG_DIR, "puppy.cfg")
 MCP_SERVERS_FILE = os.path.join(CONFIG_DIR, "mcp_servers.json")
-COMMAND_HISTORY_FILE = os.path.join(CONFIG_DIR, "command_history.txt")
-MODELS_FILE = os.path.join(CONFIG_DIR, "models.json")
-EXTRA_MODELS_FILE = os.path.join(CONFIG_DIR, "extra_models.json")
-AGENTS_DIR = os.path.join(CONFIG_DIR, "agents")
-CONTEXTS_DIR = os.path.join(CONFIG_DIR, "contexts")
-AUTOSAVE_DIR = os.path.join(CONFIG_DIR, "autosaves")
-# Default saving to a SQLite DB in the config dir
-_DEFAULT_SQLITE_FILE = os.path.join(CONFIG_DIR, "dbos_store.sqlite")
+
+# Data files (XDG_DATA_HOME)
+MODELS_FILE = os.path.join(DATA_DIR, "models.json")
+EXTRA_MODELS_FILE = os.path.join(DATA_DIR, "extra_models.json")
+AGENTS_DIR = os.path.join(DATA_DIR, "agents")
+CONTEXTS_DIR = os.path.join(DATA_DIR, "contexts")
+_DEFAULT_SQLITE_FILE = os.path.join(DATA_DIR, "dbos_store.sqlite")
+
+# OAuth plugin model files (XDG_DATA_HOME)
+GEMINI_MODELS_FILE = os.path.join(DATA_DIR, "gemini_models.json")
+CHATGPT_MODELS_FILE = os.path.join(DATA_DIR, "chatgpt_models.json")
+CLAUDE_MODELS_FILE = os.path.join(DATA_DIR, "claude_models.json")
+
+# Cache files (XDG_CACHE_HOME)
+AUTOSAVE_DIR = os.path.join(CACHE_DIR, "autosaves")
+
+# State files (XDG_STATE_HOME)
+COMMAND_HISTORY_FILE = os.path.join(STATE_DIR, "command_history.txt")
 DBOS_DATABASE_URL = os.environ.get(
     "DBOS_SYSTEM_DATABASE_URL", f"sqlite:///{_DEFAULT_SQLITE_FILE}"
 )
@@ -48,11 +89,13 @@ _default_vqa_model_cache = None
 
 def ensure_config_exists():
     """
-    Ensure that the .code_puppy dir and puppy.cfg exist, prompting if needed.
+    Ensure that XDG directories and puppy.cfg exist, prompting if needed.
     Returns configparser.ConfigParser for reading.
     """
-    if not os.path.exists(CONFIG_DIR):
-        os.makedirs(CONFIG_DIR, exist_ok=True)
+    # Create all XDG directories with 0700 permissions per XDG spec
+    for directory in [CONFIG_DIR, DATA_DIR, CACHE_DIR, STATE_DIR]:
+        if not os.path.exists(directory):
+            os.makedirs(directory, mode=0o700, exist_ok=True)
     exists = os.path.isfile(CONFIG_FILE)
     config = configparser.ConfigParser()
     if exists:
@@ -64,7 +107,11 @@ def ensure_config_exists():
         if not config[DEFAULT_SECTION].get(key):
             missing.append(key)
     if missing:
-        print("🐾 Let's get your Puppy ready!")
+        # Note: Using sys.stdout here for initial setup before messaging system is available
+        import sys
+
+        sys.stdout.write("🐾 Let's get your Puppy ready!\n")
+        sys.stdout.flush()
         for key in missing:
             if key == "puppy_name":
                 val = input("What should we name the puppy? ").strip()
@@ -163,6 +210,11 @@ def get_config_keys():
     ]
     # Add DBOS control key
     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)
@@ -187,7 +239,7 @@ def set_config_value(key: str, value: str):
 # --- MODEL STICKY EXTENSION STARTS HERE ---
 def load_mcp_server_configs():
     """
-    Loads the MCP server configurations from ~/.code_puppy/mcp_servers.json.
+    Loads the MCP server configurations from XDG_CONFIG_HOME/code_puppy/mcp_servers.json.
     Returns a dict mapping names to their URL or config dict.
     If file does not exist, returns an empty dict.
     """
@@ -207,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
 
@@ -221,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
@@ -448,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"
@@ -458,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(
@@ -609,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
 
@@ -789,11 +848,11 @@ def normalize_command_history():
             ) as f:
                 f.write(updated_content)
     except Exception as e:
-        from rich.console import Console
+        from code_puppy.messaging import emit_error
 
-        direct_console = Console()
-        error_msg = f"❌ An unexpected error occurred while normalizing command history: {str(e)}"
-        direct_console.print(f"[bold red]{error_msg}[/bold red]")
+        emit_error(
+            f"An unexpected error occurred while normalizing command history: {str(e)}"
+        )
 
 
 def get_user_agents_directory() -> str:
@@ -815,9 +874,9 @@ def initialize_command_history_file():
     import os
     from pathlib import Path
 
-    # Ensure the config directory exists before trying to create the history file
-    if not os.path.exists(CONFIG_DIR):
-        os.makedirs(CONFIG_DIR, exist_ok=True)
+    # Ensure the state directory exists before trying to create the history file
+    if not os.path.exists(STATE_DIR):
+        os.makedirs(STATE_DIR, exist_ok=True)
 
     command_history_exists = os.path.isfile(COMMAND_HISTORY_FILE)
     if not command_history_exists:
@@ -838,11 +897,11 @@ def initialize_command_history_file():
                 # Normalize the command history format if needed
                 normalize_command_history()
         except Exception as e:
-            from rich.console import Console
+            from code_puppy.messaging import emit_error
 
-            direct_console = Console()
-            error_msg = f"❌ An unexpected error occurred while trying to initialize history file: {str(e)}"
-            direct_console.print(f"[bold red]{error_msg}[/bold red]")
+            emit_error(
+                f"An unexpected error occurred while trying to initialize history file: {str(e)}"
+            )
 
 
 def get_yolo_mode():
@@ -1035,13 +1094,11 @@ def save_command_to_history(command: str):
         ) as f:
             f.write(f"\n# {timestamp}\n{command}\n")
     except Exception as e:
-        from rich.console import Console
+        from code_puppy.messaging import emit_error
 
-        direct_console = Console()
-        error_msg = (
-            f"❌ An unexpected error occurred while saving command history: {str(e)}"
+        emit_error(
+            f"An unexpected error occurred while saving command history: {str(e)}"
         )
-        direct_console.print(f"[bold red]{error_msg}[/bold red]")
 
 
 def get_agent_pinned_model(agent_name: str) -> str:
@@ -1077,6 +1134,38 @@ def clear_agent_pinned_model(agent_name: str):
     set_config_value(f"agent_model_{agent_name}", "")
 
 
+def get_all_agent_pinned_models() -> dict:
+    """Get all agent-to-model pinnings from config.
+
+    Returns:
+        Dict mapping agent names to their pinned model names.
+        Only includes agents that have a pinned model (non-empty value).
+    """
+    config = configparser.ConfigParser()
+    config.read(CONFIG_FILE)
+
+    pinnings = {}
+    if DEFAULT_SECTION in config:
+        for key, value in config[DEFAULT_SECTION].items():
+            if key.startswith("agent_model_") and value:
+                agent_name = key[len("agent_model_") :]
+                pinnings[agent_name] = value
+    return pinnings
+
+
+def get_agents_pinned_to_model(model_name: str) -> list:
+    """Get all agents that are pinned to a specific model.
+
+    Args:
+        model_name: The model name to look up.
+
+    Returns:
+        List of agent names pinned to this model.
+    """
+    all_pinnings = get_all_agent_pinned_models()
+    return [agent for agent, model in all_pinnings.items() if model == model_name]
+
+
 def get_auto_save_session() -> bool:
     """
     Checks puppy.cfg for 'auto_save_session' (case-insensitive in value only).
@@ -1178,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
@@ -1222,11 +1389,8 @@ def auto_save_session_if_enabled() -> bool:
     try:
         import pathlib
 
-        from rich.console import Console
-
         from code_puppy.agents.agent_manager import get_current_agent
-
-        console = Console()
+        from code_puppy.messaging import emit_info
 
         current_agent = get_current_agent()
         history = current_agent.get_message_history()
@@ -1246,16 +1410,16 @@ def auto_save_session_if_enabled() -> bool:
             auto_saved=True,
         )
 
-        console.print(
-            f"🐾 [dim]Auto-saved session: {metadata.message_count} messages ({metadata.total_tokens} tokens)[/dim]"
+        emit_info(
+            f"🐾 Auto-saved session: {metadata.message_count} messages ({metadata.total_tokens} tokens)"
         )
 
         return True
 
     except Exception as exc:  # pragma: no cover - defensive logging
-        from rich.console import Console
+        from code_puppy.messaging import emit_error
 
-        Console().print(f"[dim]❌ Failed to auto-save session: {exc}[/dim]")
+        emit_error(f"Failed to auto-save session: {exc}")
         return False
 
 

code_puppy/error_logging.py

@@ -0,0 +1,118 @@
+"""Error logging utility for code_puppy.
+
+Logs unexpected errors to XDG_STATE_HOME/code_puppy/logs/ for debugging purposes.
+Per XDG spec, logs are "state data" (actions history), not configuration.
+Because even good puppies make mistakes sometimes! 🐶
+"""
+
+import os
+import traceback
+from datetime import datetime
+from pathlib import Path
+from typing import Optional
+
+from code_puppy.config import STATE_DIR
+
+# Logs directory within the state directory (per XDG spec, logs are state data)
+LOGS_DIR = os.path.join(STATE_DIR, "logs")
+ERROR_LOG_FILE = os.path.join(LOGS_DIR, "errors.log")
+
+
+def _ensure_logs_dir() -> None:
+    """Create the logs directory if it doesn't exist (with 0700 perms per XDG spec)."""
+    Path(LOGS_DIR).mkdir(parents=True, exist_ok=True, mode=0o700)
+
+
+def log_error(
+    error: Exception,
+    context: Optional[str] = None,
+    include_traceback: bool = True,
+) -> None:
+    """Log an error to the error log file.
+
+    Args:
+        error: The exception to log
+        context: Optional context string describing where the error occurred
+        include_traceback: Whether to include the full traceback (default True)
+    """
+    try:
+        _ensure_logs_dir()
+
+        timestamp = datetime.now().isoformat()
+        error_type = type(error).__name__
+        error_msg = str(error)
+
+        log_entry_parts = [
+            f"\n{'=' * 80}",
+            f"Timestamp: {timestamp}",
+            f"Error Type: {error_type}",
+            f"Error Message: {error_msg}",
+        ]
+
+        if context:
+            log_entry_parts.append(f"Context: {context}")
+
+        if include_traceback:
+            tb = traceback.format_exception(type(error), error, error.__traceback__)
+            log_entry_parts.append(f"Traceback:\n{''.join(tb)}")
+
+        if hasattr(error, "args") and error.args:
+            log_entry_parts.append(f"Args: {error.args}")
+
+        log_entry_parts.append(f"{'=' * 80}\n")
+
+        log_entry = "\n".join(log_entry_parts)
+
+        with open(ERROR_LOG_FILE, "a", encoding="utf-8") as f:
+            f.write(log_entry)
+
+    except Exception:
+        # If we can't log, we silently fail - don't want logging errors
+        # to cause more problems than they solve!
+        pass
+
+
+def log_error_message(
+    message: str,
+    context: Optional[str] = None,
+) -> None:
+    """Log a simple error message without an exception object.
+
+    Args:
+        message: The error message to log
+        context: Optional context string describing where the error occurred
+    """
+    try:
+        _ensure_logs_dir()
+
+        timestamp = datetime.now().isoformat()
+
+        log_entry_parts = [
+            f"\n{'=' * 80}",
+            f"Timestamp: {timestamp}",
+            f"Message: {message}",
+        ]
+
+        if context:
+            log_entry_parts.append(f"Context: {context}")
+
+        log_entry_parts.append(f"{'=' * 80}\n")
+
+        log_entry = "\n".join(log_entry_parts)
+
+        with open(ERROR_LOG_FILE, "a", encoding="utf-8") as f:
+            f.write(log_entry)
+
+    except Exception:
+        # Silent fail - same reasoning as above
+        pass
+
+
+def get_log_file_path() -> str:
+    """Return the path to the error log file."""
+    return ERROR_LOG_FILE
+
+
+def get_logs_dir() -> str:
+    """Return the path to the logs directory."""
+    return LOGS_DIR