code-puppy 0.0.97__py3-none-any.whl → 0.0.118__py3-none-any.whl

code_puppy/command_line/prompt_toolkit_completion.py

@@ -19,17 +19,23 @@ from prompt_toolkit.keys import Keys
 from prompt_toolkit.styles import Style
 
 from code_puppy.command_line.file_path_completion import FilePathCompleter
+from code_puppy.command_line.load_context_completion import LoadContextCompleter
 from code_puppy.command_line.model_picker_completion import (
     ModelNameCompleter,
     get_active_model,
     update_model_in_input,
 )
 from code_puppy.command_line.utils import list_directory
-from code_puppy.config import get_config_keys, get_puppy_name, get_value
+from code_puppy.config import (
+    COMMAND_HISTORY_FILE,
+    get_config_keys,
+    get_puppy_name,
+    get_value,
+)
 
 
 class SetCompleter(Completer):
-    def __init__(self, trigger: str = "~set"):
+    def __init__(self, trigger: str = "/set"):
         self.trigger = trigger
 
     def get_completions(self, document, complete_event):
@@ -40,15 +46,15 @@ class SetCompleter(Completer):
             return
 
         # Determine the part of the text that is relevant for this completer
-        # This handles cases like "  ~set foo" where the trigger isn't at the start of the string
+        # This handles cases like "  /set foo" where the trigger isn't at the start of the string
         actual_trigger_pos = text_before_cursor.find(self.trigger)
         effective_input = text_before_cursor[
             actual_trigger_pos:
-        ]  # e.g., "~set keypart" or "~set " or "~set"
+        ]  # e.g., "/set keypart" or "/set "
 
         tokens = effective_input.split()
 
-        # Case 1: Input is exactly the trigger (e.g., "~set") and nothing more (not even a trailing space on effective_input).
+        # Case 1: Input is exactly the trigger (e.g., "/set") and nothing more (not even a trailing space on effective_input).
         # Suggest adding a space.
         if (
             len(tokens) == 1
@@ -63,11 +69,11 @@ class SetCompleter(Completer):
             )
             return
 
-        # Case 2: Input is trigger + space (e.g., "~set ") or trigger + partial key (e.g., "~set partial")
+        # Case 2: Input is trigger + space (e.g., "/set ") or trigger + partial key (e.g., "/set partial")
         base_to_complete = ""
-        if len(tokens) > 1:  # e.g., ["~set", "partialkey"]
+        if len(tokens) > 1:  # e.g., ["/set", "partialkey"]
             base_to_complete = tokens[1]
-        # If len(tokens) == 1, it implies effective_input was like "~set ", so base_to_complete remains ""
+        # If len(tokens) == 1, it implies effective_input was like "/set ", so base_to_complete remains ""
         # This means we list all keys.
 
         # --- SPECIAL HANDLING FOR 'model' KEY ---
@@ -75,8 +81,8 @@ class SetCompleter(Completer):
             # Don't return any completions -- let ModelNameCompleter handle it
             return
         for key in get_config_keys():
-            if key == "model":
-                continue  # exclude 'model' from regular ~set completions
+            if key == "model" or key == "puppy_token":
+                continue  # exclude 'model' and 'puppy_token' from regular /set completions
             if key.startswith(base_to_complete):
                 prev_value = get_value(key)
                 value_part = f" = {prev_value}" if prev_value is not None else " = "
@@ -87,14 +93,12 @@ class SetCompleter(Completer):
                     start_position=-len(
                         base_to_complete
                     ),  # Correctly replace only the typed part of the key
-                    display_meta=f"puppy.cfg key (was: {prev_value})"
-                    if prev_value is not None
-                    else "puppy.cfg key",
+                    display_meta="",
                 )
 
 
 class CDCompleter(Completer):
-    def __init__(self, trigger: str = "~cd"):
+    def __init__(self, trigger: str = "/cd"):
         self.trigger = trigger
 
     def get_completions(self, document, complete_event):
@@ -159,19 +163,35 @@ async def get_input_with_combined_completion(
     completer = merge_completers(
         [
             FilePathCompleter(symbol="@"),
-            ModelNameCompleter(trigger="~m"),
-            CDCompleter(trigger="~cd"),
-            SetCompleter(trigger="~set"),
+            ModelNameCompleter(trigger="/m"),
+            CDCompleter(trigger="/cd"),
+            SetCompleter(trigger="/set"),
+            LoadContextCompleter(trigger="/load_context"),
         ]
     )
-    # Add custom key bindings for Alt+M to insert a new line without submitting
+    # Add custom key bindings for multiline input
     bindings = KeyBindings()
 
-    @bindings.add(Keys.Escape, "m")  # Alt+M
+    @bindings.add(Keys.Escape, "m")  # Alt+M (legacy support)
+    def _(event):
+        event.app.current_buffer.insert_text("\n")
+
+    # Create a special binding for shift+enter
+    @bindings.add("escape", "enter")
     def _(event):
+        """Pressing alt+enter (meta+enter) inserts a newline."""
         event.app.current_buffer.insert_text("\n")
 
-    @bindings.add("c-c")
+    # Override the default enter behavior to check for shift
+    @bindings.add("enter")
+    def _(event):
+        """Accept input or insert newline depending on shift key."""
+        # Check if shift is pressed - this comes from key press event data
+        # Using a key sequence like Alt+Enter is more reliable than detecting shift
+        # So we'll use the default behavior for Enter
+        event.current_buffer.validate_and_handle()
+
+    @bindings.add(Keys.Escape)
     def _(event):
         """Cancel the current prompt when the user presses the ESC key alone."""
         event.app.exit(exception=KeyboardInterrupt)
@@ -206,14 +226,13 @@ async def get_input_with_combined_completion(
 
 
 if __name__ == "__main__":
-    print("Type '@' for path-completion or '~m' to pick a model. Ctrl+D to exit.")
+    print("Type '@' for path-completion or '/m' to pick a model. Ctrl+D to exit.")
 
     async def main():
         while True:
             try:
                 inp = await get_input_with_combined_completion(
-                    get_prompt_with_active_model(),
-                    history_file="~/.path_completion_history.txt",
+                    get_prompt_with_active_model(), history_file=COMMAND_HISTORY_FILE
                 )
                 print(f"You entered: {inp}")
             except KeyboardInterrupt:

code_puppy/config.py

@@ -1,11 +1,14 @@
 import configparser
-import os
 import json
+import os
 import pathlib
 
 CONFIG_DIR = os.path.join(os.path.expanduser("~"), ".code_puppy")
 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")
 
 DEFAULT_SECTION = "puppy"
 REQUIRED_KEYS = ["puppy_name", "owner_name"]
@@ -35,7 +38,7 @@ def ensure_config_exists():
                 val = input("What should we name the puppy? ").strip()
             elif key == "owner_name":
                 val = input(
-                    "What's your name (so Code Puppy knows its master)? "
+                    "What's your name (so Code Puppy knows its owner)? "
                 ).strip()
             else:
                 val = input(f"Enter {key}: ").strip()
@@ -60,17 +63,9 @@ def get_owner_name():
     return get_value("owner_name") or "Master"
 
 
-def get_message_history_limit():
-    """
-    Returns the user-configured message truncation limit (for remembering context),
-    or 40 if unset or misconfigured.
-    Configurable by 'message_history_limit' key.
-    """
-    val = get_value("message_history_limit")
-    try:
-        return max(1, int(val)) if val else 40
-    except (ValueError, TypeError):
-        return 40
+# Legacy function removed - message history limit is no longer used
+# Message history is now managed by token-based compaction system
+# using get_protected_token_count() and get_summarization_threshold()
 
 
 # --- CONFIG SETTER STARTS HERE ---
@@ -107,21 +102,102 @@ def load_mcp_server_configs():
     Returns a dict mapping names to their URL or config dict.
     If file does not exist, returns an empty dict.
     """
+    from code_puppy.messaging.message_queue import emit_error, emit_system_message
+
     try:
         if not pathlib.Path(MCP_SERVERS_FILE).exists():
-            print("No MCP configuration was found")
+            emit_system_message("[dim]No MCP configuration was found[/dim]")
             return {}
         with open(MCP_SERVERS_FILE, "r") as f:
             conf = json.loads(f.read())
             return conf["mcp_servers"]
     except Exception as e:
-        print(f"Failed to load MCP servers - {str(e)}")
+        emit_error(f"Failed to load MCP servers - {str(e)}")
         return {}
 
 
+# Cache for model validation to prevent hitting ModelFactory on every call
+_model_validation_cache = {}
+_default_model_cache = None
+
+
+def _default_model_from_models_json():
+    """Attempt to load the first model name from models.json.
+
+    Falls back to the hard-coded default (``claude-4-0-sonnet``) if the file
+    cannot be read for any reason or is empty.
+    """
+    global _default_model_cache
+
+    # Return cached default if we have one
+    if _default_model_cache is not None:
+        return _default_model_cache
+
+    try:
+        # Local import to avoid potential circular dependency on module import
+        from code_puppy.model_factory import ModelFactory
+
+        models_config_path = os.path.join(CONFIG_DIR, "models.json")
+        models_config = ModelFactory.load_config(models_config_path)
+        first_key = next(iter(models_config))  # Raises StopIteration if empty
+        _default_model_cache = first_key
+        return first_key
+    except Exception:
+        # Any problem (network, file missing, empty dict, etc.) => fall back
+        _default_model_cache = "claude-4-0-sonnet"
+        return "claude-4-0-sonnet"
+
+
+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
+
+    # Check cache first
+    if model_name in _model_validation_cache:
+        return _model_validation_cache[model_name]
+
+    try:
+        from code_puppy.model_factory import ModelFactory
+
+        models_config_path = os.path.join(CONFIG_DIR, "models.json")
+        models_config = ModelFactory.load_config(models_config_path)
+        exists = model_name in models_config
+
+        # Cache the result
+        _model_validation_cache[model_name] = exists
+        return exists
+    except Exception:
+        # If we can't validate, assume it exists to avoid breaking things
+        _model_validation_cache[model_name] = True
+        return True
+
+
+def clear_model_cache():
+    """Clear the model validation cache. Call this when models.json changes."""
+    global _model_validation_cache, _default_model_cache
+    _model_validation_cache.clear()
+    _default_model_cache = None
+
+
 def get_model_name():
-    """Returns the last used model name stored in config, or None if unset."""
-    return get_value("model") or "gpt-4.1"
+    """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``.
+    """
+
+    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
+
+    # Either no stored model or it's not valid – choose default from models.json
+    return _default_model_from_models_json()
 
 
 def set_model_name(model: str):
@@ -134,15 +210,118 @@ def set_model_name(model: str):
     with open(CONFIG_FILE, "w") as f:
         config.write(f)
 
+    # Clear model cache when switching models to ensure fresh validation
+    clear_model_cache()
+
+
+def get_puppy_token():
+    """Returns the puppy_token from config, or None if not set."""
+    return get_value("puppy_token")
+
+
+def set_puppy_token(token: str):
+    """Sets the puppy_token in the persistent config file."""
+    set_config_value("puppy_token", token)
+
+
+def normalize_command_history():
+    """
+    Normalize the command history file by converting old format timestamps to the new format.
+
+    Old format example:
+    - "# 2025-08-04 12:44:45.469829"
+
+    New format example:
+    - "# 2025-08-05T10:35:33" (ISO)
+    """
+    import os
+    import re
+
+    # Skip implementation during tests
+    import sys
+
+    if "pytest" in sys.modules:
+        return
+
+    # Skip normalization if file doesn't exist
+    command_history_exists = os.path.isfile(COMMAND_HISTORY_FILE)
+    if not command_history_exists:
+        return
+
+    try:
+        # Read the entire file
+        with open(COMMAND_HISTORY_FILE, "r") as f:
+            content = f.read()
+
+        # Skip empty files
+        if not content.strip():
+            return
+
+        # Define regex pattern for old timestamp format
+        # Format: "# YYYY-MM-DD HH:MM:SS.ffffff"
+        old_timestamp_pattern = r"# (\d{4}-\d{2}-\d{2}) (\d{2}:\d{2}:\d{2})\.(\d+)"
+
+        # Function to convert matched timestamp to ISO format
+        def convert_to_iso(match):
+            date = match.group(1)
+            time = match.group(2)
+            # Create ISO format (YYYY-MM-DDThh:mm:ss)
+            return f"# {date}T{time}"
+
+        # Replace all occurrences of the old timestamp format with the new ISO format
+        updated_content = re.sub(old_timestamp_pattern, convert_to_iso, content)
+
+        # Write the updated content back to the file only if changes were made
+        if content != updated_content:
+            with open(COMMAND_HISTORY_FILE, "w") as f:
+                f.write(updated_content)
+    except Exception as e:
+        from rich.console import Console
+
+        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]")
+
+
+def initialize_command_history_file():
+    """Create the command history file if it doesn't exist.
+    Handles migration from the old history file location for backward compatibility.
+    Also normalizes the command history format if needed.
+    """
+    import os
+    from pathlib import Path
+
+    command_history_exists = os.path.isfile(COMMAND_HISTORY_FILE)
+    if not command_history_exists:
+        try:
+            Path(COMMAND_HISTORY_FILE).touch()
+
+            # For backwards compatibility, copy the old history file, then remove it
+            old_history_file = os.path.join(
+                os.path.expanduser("~"), ".code_puppy_history.txt"
+            )
+            old_history_exists = os.path.isfile(old_history_file)
+            if old_history_exists:
+                import shutil
+
+                shutil.copy2(Path(old_history_file), Path(COMMAND_HISTORY_FILE))
+                Path(old_history_file).unlink(missing_ok=True)
+
+                # Normalize the command history format if needed
+                normalize_command_history()
+        except Exception as e:
+            from rich.console import Console
+
+            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]")
+
 
 def get_yolo_mode():
     """
     Checks puppy.cfg for 'yolo_mode' (case-insensitive in value only).
-    If not set, checks YOLO_MODE env var:
-    - If found in env, saves that value to puppy.cfg for future use.
-    - If neither present, defaults to False.
+    Defaults to False if not set.
     Allowed values for ON: 1, '1', 'true', 'yes', 'on' (all case-insensitive for value).
-    Always prioritizes the config once set!
     """
     true_vals = {"1", "true", "yes", "on"}
     cfg_val = get_value("yolo_mode")
@@ -150,11 +329,72 @@ def get_yolo_mode():
         if str(cfg_val).strip().lower() in true_vals:
             return True
         return False
-    env_val = os.getenv("YOLO_MODE")
-    if env_val is not None:
-        # Persist the env value now
-        set_config_value("yolo_mode", env_val)
-        if str(env_val).strip().lower() in true_vals:
+    return False
+
+
+def get_mcp_disabled():
+    """
+    Checks puppy.cfg for 'disable_mcp' (case-insensitive in value only).
+    Defaults to False if not set.
+    Allowed values for ON: 1, '1', 'true', 'yes', 'on' (all case-insensitive for value).
+    When enabled, Code Puppy will skip loading MCP servers entirely.
+    """
+    true_vals = {"1", "true", "yes", "on"}
+    cfg_val = get_value("disable_mcp")
+    if cfg_val is not None:
+        if str(cfg_val).strip().lower() in true_vals:
             return True
         return False
     return False
+
+
+def get_protected_token_count():
+    """
+    Returns the user-configured protected token count for message history compaction.
+    This is the number of tokens in recent messages that won't be summarized.
+    Defaults to 50000 if unset or misconfigured.
+    Configurable by 'protected_token_count' key.
+    """
+    val = get_value("protected_token_count")
+    try:
+        return max(1000, int(val)) if val else 50000  # Minimum 1000 tokens
+    except (ValueError, TypeError):
+        return 50000
+
+
+def get_summarization_threshold():
+    """
+    Returns the user-configured summarization threshold as a float between 0.0 and 1.0.
+    This is the proportion of model context that triggers summarization.
+    Defaults to 0.85 (85%) if unset or misconfigured.
+    Configurable by 'summarization_threshold' key.
+    """
+    val = get_value("summarization_threshold")
+    try:
+        threshold = float(val) if val else 0.85
+        # Clamp between reasonable bounds
+        return max(0.1, min(0.95, threshold))
+    except (ValueError, TypeError):
+        return 0.85
+
+
+def save_command_to_history(command: str):
+    """Save a command to the history file with an ISO format timestamp.
+
+    Args:
+        command: The command to save
+    """
+    import datetime
+
+    try:
+        timestamp = datetime.datetime.now().isoformat(timespec="seconds")
+        with open(COMMAND_HISTORY_FILE, "a") as f:
+            f.write(f"\n# {timestamp}\n{command}\n")
+    except Exception as e:
+        from rich.console import Console
+
+        direct_console = Console()
+        error_msg = (
+            f"❌ An unexpected error occurred while saving command history: {str(e)}"
+        )
+        direct_console.print(f"[bold red]{error_msg}[/bold red]")

code_puppy/http_utils.py

@@ -0,0 +1,122 @@
+"""
+HTTP utilities module for code-puppy.
+
+This module provides functions for creating properly configured HTTP clients.
+"""
+
+import os
+import socket
+from typing import Dict, Optional, Union
+
+import httpx
+import requests
+
+try:
+    from .reopenable_async_client import ReopenableAsyncClient
+except ImportError:
+    ReopenableAsyncClient = None
+
+
+def get_cert_bundle_path() -> str:
+    # First check if SSL_CERT_FILE environment variable is set
+    ssl_cert_file = os.environ.get("SSL_CERT_FILE")
+    if ssl_cert_file and os.path.exists(ssl_cert_file):
+        return ssl_cert_file
+
+
+def create_client(
+    timeout: int = 180,
+    verify: Union[bool, str] = None,
+    headers: Optional[Dict[str, str]] = None,
+) -> httpx.Client:
+    if verify is None:
+        verify = get_cert_bundle_path()
+
+    return httpx.Client(verify=verify, headers=headers or {}, timeout=timeout)
+
+
+def create_async_client(
+    timeout: int = 180,
+    verify: Union[bool, str] = None,
+    headers: Optional[Dict[str, str]] = None,
+) -> httpx.AsyncClient:
+    if verify is None:
+        verify = get_cert_bundle_path()
+
+    return httpx.AsyncClient(verify=verify, headers=headers or {}, timeout=timeout)
+
+
+def create_requests_session(
+    timeout: float = 5.0,
+    verify: Union[bool, str] = None,
+    headers: Optional[Dict[str, str]] = None,
+) -> requests.Session:
+    session = requests.Session()
+
+    if verify is None:
+        verify = get_cert_bundle_path()
+
+    session.verify = verify
+
+    if headers:
+        session.headers.update(headers or {})
+
+    return session
+
+
+def create_auth_headers(
+    api_key: str, header_name: str = "Authorization"
+) -> Dict[str, str]:
+    return {header_name: f"Bearer {api_key}"}
+
+
+def resolve_env_var_in_header(headers: Dict[str, str]) -> Dict[str, str]:
+    resolved_headers = {}
+
+    for key, value in headers.items():
+        if isinstance(value, str):
+            try:
+                expanded = os.path.expandvars(value)
+                resolved_headers[key] = expanded
+            except Exception:
+                resolved_headers[key] = value
+        else:
+            resolved_headers[key] = value
+
+    return resolved_headers
+
+
+def create_reopenable_async_client(
+    timeout: int = 180,
+    verify: Union[bool, str] = None,
+    headers: Optional[Dict[str, str]] = None,
+) -> Union["ReopenableAsyncClient", httpx.AsyncClient]:
+    if verify is None:
+        verify = get_cert_bundle_path()
+
+    if ReopenableAsyncClient is not None:
+        return ReopenableAsyncClient(
+            verify=verify, headers=headers or {}, timeout=timeout
+        )
+    else:
+        # Fallback to regular AsyncClient if ReopenableAsyncClient is not available
+        return httpx.AsyncClient(verify=verify, headers=headers or {}, timeout=timeout)
+
+
+def is_cert_bundle_available() -> bool:
+    cert_path = get_cert_bundle_path()
+    return os.path.exists(cert_path) and os.path.isfile(cert_path)
+
+
+def find_available_port(start_port=8090, end_port=9010, host="127.0.0.1"):
+    for port in range(start_port, end_port + 1):
+        try:
+            # Try to bind to the port to check if it's available
+            with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
+                sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+                sock.bind((host, port))
+                return port
+        except OSError:
+            # Port is in use, try the next one
+            continue
+    return None