code-puppy 0.0.123__py3-none-any.whl → 0.0.125__py3-none-any.whl

code_puppy/config.py

@@ -9,6 +9,7 @@ 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")
 
 DEFAULT_SECTION = "puppy"
 REQUIRED_KEYS = ["puppy_name", "owner_name"]
@@ -68,13 +69,33 @@ def get_owner_name():
 # using get_protected_token_count() and get_summarization_threshold()
 
 
+def get_model_context_length() -> int:
+    """
+    Get the context length for the currently configured model from models.json
+    """
+    try:
+        from code_puppy.model_factory import ModelFactory
+
+        model_configs = ModelFactory.load_config()
+        model_name = get_model_name()
+
+        # Get context length from model config
+        model_config = model_configs.get(model_name, {})
+        context_length = model_config.get("context_length", 128000)  # Default value
+
+        return int(context_length)
+    except Exception:
+        # Fallback to default context length if anything goes wrong
+        return 128000
+
+
 # --- CONFIG SETTER STARTS HERE ---
 def get_config_keys():
     """
     Returns the list of all config keys currently in puppy.cfg,
-    plus certain preset expected keys (e.g. "yolo_mode", "model").
+    plus certain preset expected keys (e.g. "yolo_mode", "model", "compaction_strategy").
     """
-    default_keys = ["yolo_mode", "model"]
+    default_keys = ["yolo_mode", "model", "compaction_strategy"]
     config = configparser.ConfigParser()
     config.read(CONFIG_FILE)
     keys = set(config[DEFAULT_SECTION].keys()) if DEFAULT_SECTION in config else set()
@@ -283,6 +304,17 @@ def normalize_command_history():
         direct_console.print(f"[bold red]{error_msg}[/bold red]")
 
 
+def get_user_agents_directory() -> str:
+    """Get the user's agents directory path.
+
+    Returns:
+        Path to the user's Code Puppy agents directory.
+    """
+    # Ensure the agents directory exists
+    os.makedirs(AGENTS_DIR, exist_ok=True)
+    return AGENTS_DIR
+
+
 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.
@@ -354,30 +386,56 @@ def get_protected_token_count():
     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.
+    Enforces that protected tokens don't exceed 75% of model context length.
     """
     val = get_value("protected_token_count")
     try:
-        return max(1000, int(val)) if val else 50000  # Minimum 1000 tokens
+        # Get the model context length to enforce the 75% limit
+        model_context_length = get_model_context_length()
+        max_protected_tokens = int(model_context_length * 0.75)
+
+        # Parse the configured value
+        configured_value = int(val) if val else 50000
+
+        # Apply constraints: minimum 1000, maximum 75% of context length
+        return max(1000, min(configured_value, max_protected_tokens))
     except (ValueError, TypeError):
-        return 50000
+        # If parsing fails, return a reasonable default that respects the 75% limit
+        model_context_length = get_model_context_length()
+        max_protected_tokens = int(model_context_length * 0.75)
+        return min(50000, max_protected_tokens)
 
 
-def get_summarization_threshold():
+def get_compaction_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.
+    Returns the user-configured compaction threshold as a float between 0.0 and 1.0.
+    This is the proportion of model context that triggers compaction.
     Defaults to 0.85 (85%) if unset or misconfigured.
-    Configurable by 'summarization_threshold' key.
+    Configurable by 'compaction_threshold' key.
     """
-    val = get_value("summarization_threshold")
+    val = get_value("compaction_threshold")
     try:
         threshold = float(val) if val else 0.85
         # Clamp between reasonable bounds
-        return max(0.1, min(0.95, threshold))
+        return max(0.8, min(0.95, threshold))
     except (ValueError, TypeError):
         return 0.85
 
 
+def get_compaction_strategy() -> str:
+    """
+    Returns the user-configured compaction strategy.
+    Options are 'summarization' or 'truncation'.
+    Defaults to 'summarization' if not set or misconfigured.
+    Configurable by 'compaction_strategy' key.
+    """
+    val = get_value("compaction_strategy")
+    if val and val.lower() in ["summarization", "truncation"]:
+        return val.lower()
+    # Default to summarization
+    return "summarization"
+
+
 def save_command_to_history(command: str):
     """Save a command to the history file with an ISO format timestamp.
 

code_puppy/main.py

@@ -321,12 +321,14 @@ async def interactive_mode(message_renderer, initial_command: str = None) -> Non
                             initial_command, usage_limits=get_custom_usage_limits()
                         )
                     finally:
-                        set_message_history(prune_interrupted_tool_calls(get_message_history()))
+                        set_message_history(
+                            prune_interrupted_tool_calls(get_message_history())
+                        )
 
             agent_response = response.output
 
             emit_system_message(
-                f"\n[bold purple]AGENT RESPONSE: [/bold purple]\n{agent_response.output_message}"
+                f"\n[bold purple]AGENT RESPONSE: [/bold purple]\n{agent_response}"
             )
             new_msgs = response.all_messages()
             message_history_accumulator(new_msgs)
@@ -371,8 +373,13 @@ async def interactive_mode(message_renderer, initial_command: str = None) -> Non
 
     while True:
         from code_puppy.messaging import emit_info
+        from code_puppy.agents.agent_manager import get_current_agent_config
+
+        # Get the custom prompt from the current agent, or use default
+        current_agent = get_current_agent_config()
+        user_prompt = current_agent.get_user_prompt() or "Enter your coding task:"
 
-        emit_info("[bold blue]Enter your coding task:[/bold blue]")
+        emit_info(f"[bold blue]{user_prompt}[/bold blue]")
 
         try:
             # Use prompt_toolkit for enhanced input with path completion
@@ -466,7 +473,9 @@ async def interactive_mode(message_renderer, initial_command: str = None) -> Non
                                 usage_limits=get_custom_usage_limits(),
                             )
                         finally:
-                            set_message_history(prune_interrupted_tool_calls(get_message_history()))
+                            set_message_history(
+                                prune_interrupted_tool_calls(get_message_history())
+                            )
 
                     # Create the task
                     agent_task = asyncio.create_task(run_agent_task())

code_puppy/message_history_processor.py

@@ -1,4 +1,5 @@
 import json
+import queue
 from typing import Any, List, Set, Tuple
 
 import pydantic
@@ -7,7 +8,8 @@ from pydantic_ai.messages import ModelMessage, ModelRequest, TextPart, ToolCallP
 from code_puppy.config import (
     get_model_name,
     get_protected_token_count,
-    get_summarization_threshold,
+    get_compaction_threshold,
+    get_compaction_strategy,
 )
 from code_puppy.messaging import emit_error, emit_info, emit_warning
 from code_puppy.model_factory import ModelFactory
@@ -87,6 +89,12 @@ def estimate_tokens_for_message(message: ModelMessage) -> int:
     return max(1, total_tokens)
 
 
+def filter_huge_messages(messages: List[ModelMessage]) -> List[ModelMessage]:
+    filtered = [m for m in messages if estimate_tokens_for_message(m) < 50000]
+    pruned = prune_interrupted_tool_calls(filtered)
+    return pruned
+
+
 def split_messages_for_protected_summarization(
     messages: List[ModelMessage],
 ) -> Tuple[List[ModelMessage], List[ModelMessage]]:
@@ -306,7 +314,8 @@ def message_history_processor(messages: List[ModelMessage]) -> List[ModelMessage
                 status_bar.update_token_info(
                     total_current_tokens, model_max, proportion_used
                 )
-            except Exception:
+            except Exception as e:
+                emit_error(e)
                 # Fallback to chat message if status bar update fails
                 emit_info(
                     f"\n[bold white on blue] Tokens in context: {total_current_tokens}, total model capacity: {model_max}, proportion used: {proportion_used:.2f} [/bold white on blue] \n",
@@ -323,12 +332,26 @@ def message_history_processor(messages: List[ModelMessage]) -> List[ModelMessage
         emit_info(
             f"\n[bold white on blue] Tokens in context: {total_current_tokens}, total model capacity: {model_max}, proportion used: {proportion_used:.2f} [/bold white on blue] \n"
         )
+    # Get the configured compaction threshold
+    compaction_threshold = get_compaction_threshold()
+
+    # Get the configured compaction strategy
+    compaction_strategy = get_compaction_strategy()
+
+    if proportion_used > compaction_threshold:
+        if compaction_strategy == "truncation":
+            # Use truncation instead of summarization
+            protected_tokens = get_protected_token_count()
+            result_messages = truncation(
+                filter_huge_messages(messages), protected_tokens
+            )
+            summarized_messages = []  # No summarization in truncation mode
+        else:
+            # Default to summarization
+            result_messages, summarized_messages = summarize_messages(
+                filter_huge_messages(messages)
+            )
 
-    # Get the configured summarization threshold
-    summarization_threshold = get_summarization_threshold()
-
-    if proportion_used > summarization_threshold:
-        result_messages, summarized_messages = summarize_messages(messages)
         final_token_count = sum(
             estimate_tokens_for_message(msg) for msg in result_messages
         )
@@ -360,6 +383,30 @@ def message_history_processor(messages: List[ModelMessage]) -> List[ModelMessage
     return messages
 
 
+def truncation(
+    messages: List[ModelMessage], protected_tokens: int
+) -> List[ModelMessage]:
+    emit_info("Truncating message history to manage token usage")
+    result = [messages[0]]  # Always keep the first message (system prompt)
+    num_tokens = 0
+    stack = queue.LifoQueue()
+
+    # Put messages in reverse order (most recent first) into the stack
+    # but break when we exceed protected_tokens
+    for idx, msg in enumerate(reversed(messages[1:])):  # Skip the first message
+        num_tokens += estimate_tokens_for_message(msg)
+        if num_tokens > protected_tokens:
+            break
+        stack.put(msg)
+
+    # Pop messages from stack to get them in chronological order
+    while not stack.empty():
+        result.append(stack.get())
+
+    result = prune_interrupted_tool_calls(result)
+    return result
+
+
 def message_history_accumulator(messages: List[Any]):
     _message_history = get_message_history()
     message_history_hashes = set([hash_message(m) for m in _message_history])

code_puppy/tools/__init__.py

@@ -1,10 +1,63 @@
-from code_puppy.tools.command_runner import register_command_runner_tools
-from code_puppy.tools.file_modifications import register_file_modifications_tools
-from code_puppy.tools.file_operations import register_file_operations_tools
+from code_puppy.messaging import emit_warning
+from code_puppy.tools.command_runner import (
+    register_agent_run_shell_command,
+    register_agent_share_your_reasoning,
+)
+from code_puppy.tools.file_modifications import register_edit_file, register_delete_file
+from code_puppy.tools.file_operations import (
+    register_list_files,
+    register_read_file,
+    register_grep,
+)
+
+
+# Map of tool names to their individual registration functions
+TOOL_REGISTRY = {
+    # File Operations
+    "list_files": register_list_files,
+    "read_file": register_read_file,
+    "grep": register_grep,
+    # File Modifications
+    "edit_file": register_edit_file,
+    "delete_file": register_delete_file,
+    # Command Runner
+    "agent_run_shell_command": register_agent_run_shell_command,
+    "agent_share_your_reasoning": register_agent_share_your_reasoning,
+}
+
+
+def register_tools_for_agent(agent, tool_names: list[str]):
+    """Register specific tools for an agent based on tool names.
+
+    Args:
+        agent: The agent to register tools to.
+        tool_names: List of tool names to register.
+    """
+    for tool_name in tool_names:
+        if tool_name not in TOOL_REGISTRY:
+            # Skip unknown tools with a warning instead of failing
+            emit_warning(f"Warning: Unknown tool '{tool_name}' requested, skipping...")
+            continue
+
+        # Register the individual tool
+        register_func = TOOL_REGISTRY[tool_name]
+        register_func(agent)
 
 
 def register_all_tools(agent):
-    """Register all available tools to the provided agent."""
-    register_file_operations_tools(agent)
-    register_file_modifications_tools(agent)
-    register_command_runner_tools(agent)
+    """Register all available tools to the provided agent.
+
+    Args:
+        agent: The agent to register tools to.
+    """
+    all_tools = list(TOOL_REGISTRY.keys())
+    register_tools_for_agent(agent, all_tools)
+
+
+def get_available_tool_names() -> list[str]:
+    """Get list of all available tool names.
+
+    Returns:
+        List of all tool names that can be registered.
+    """
+    return list(TOOL_REGISTRY.keys())

code_puppy/tools/command_runner.py

@@ -12,6 +12,7 @@ from pydantic_ai import RunContext
 from rich.markdown import Markdown
 from rich.text import Text
 
+from code_puppy.callbacks import on_run_shell_command
 from code_puppy.messaging import (
     emit_divider,
     emit_error,
@@ -543,7 +544,8 @@ def register_command_runner_tools(agent):
             This tool can execute arbitrary shell commands. Exercise caution when
             running untrusted commands, especially those that modify system state.
         """
-        return run_shell_command(context, command, cwd, timeout)
+        result = run_shell_command(context, command, cwd, timeout)
+        on_run_shell_command(result)
 
     @agent.tool
     def agent_share_your_reasoning(
@@ -588,3 +590,100 @@ def register_command_runner_tools(agent):
             - When encountering unexpected situations
         """
         return share_your_reasoning(context, reasoning, next_steps)
+
+
+def register_agent_run_shell_command(agent):
+    """Register only the agent_run_shell_command tool."""
+
+    @agent.tool(strict=False)
+    def agent_run_shell_command(
+        context: RunContext, command: str = "", cwd: str = None, timeout: int = 60
+    ) -> ShellCommandOutput:
+        """Execute a shell command with comprehensive monitoring and safety features.
+
+        This tool provides robust shell command execution with streaming output,
+        timeout handling, user confirmation (when not in yolo mode), and proper
+        process lifecycle management. Commands are executed in a controlled
+        environment with cross-platform process group handling.
+
+        Args:
+            command: The shell command to execute. Cannot be empty or whitespace-only.
+            cwd: Working directory for command execution. If None,
+                uses the current working directory. Defaults to None.
+            timeout: Inactivity timeout in seconds. If no output is
+                produced for this duration, the process will be terminated.
+                Defaults to 60 seconds.
+
+        Returns:
+            ShellCommandOutput: A structured response containing:
+                - success (bool): True if command executed successfully (exit code 0)
+                - command (str | None): The executed command string
+                - error (str | None): Error message if execution failed
+                - stdout (str | None): Standard output from the command (last 1000 lines)
+                - stderr (str | None): Standard error from the command (last 1000 lines)
+                - exit_code (int | None): Process exit code
+                - execution_time (float | None): Total execution time in seconds
+                - timeout (bool | None): True if command was terminated due to timeout
+                - user_interrupted (bool | None): True if user killed the process
+
+        Examples:
+            >>> # Basic command execution
+            >>> result = agent_run_shell_command(ctx, "ls -la")
+            >>> print(result.stdout)
+
+            >>> # Command with working directory
+            >>> result = agent_run_shell_command(ctx, "npm test", "/path/to/project")
+            >>> if result.success:
+            ...     print("Tests passed!")
+
+            >>> # Command with custom timeout
+            >>> result = agent_run_shell_command(ctx, "long_running_command", timeout=300)
+            >>> if result.timeout:
+            ...     print("Command timed out")
+
+        Warning:
+            This tool can execute arbitrary shell commands. Exercise caution when
+            running untrusted commands, especially those that modify system state.
+        """
+        return run_shell_command(context, command, cwd, timeout)
+
+
+def register_agent_share_your_reasoning(agent):
+    """Register only the agent_share_your_reasoning tool."""
+
+    @agent.tool(strict=False)
+    def agent_share_your_reasoning(
+        context: RunContext, reasoning: str = "", next_steps: str | None = None
+    ) -> ReasoningOutput:
+        """Share the agent's current reasoning and planned next steps with the user.
+
+        This tool provides transparency into the agent's decision-making process
+        by displaying the current reasoning and upcoming actions in a formatted,
+        user-friendly manner. It's essential for building trust and understanding
+        between the agent and user.
+
+        Args:
+            reasoning: The agent's current thought process, analysis, or
+                reasoning for the current situation. This should be clear,
+                comprehensive, and explain the 'why' behind decisions.
+            next_steps: Planned upcoming actions or steps
+                the agent intends to take. Can be None if no specific next steps
+                are determined. Defaults to None.
+
+        Returns:
+            ReasoningOutput: A simple response object containing:
+                - success (bool): Always True, indicating the reasoning was shared
+
+        Examples:
+            >>> reasoning = "I need to analyze the codebase structure first"
+            >>> next_steps = "First, I'll list the directory contents, then read key files"
+            >>> result = agent_share_your_reasoning(ctx, reasoning, next_steps)
+
+        Best Practice:
+            Use this tool frequently to maintain transparency. Call it:
+            - Before starting complex operations
+            - When changing strategy or approach
+            - To explain why certain decisions are being made
+            - When encountering unexpected situations
+        """
+        return share_your_reasoning(context, reasoning, next_steps)