code-puppy 0.0.165__py3-none-any.whl → 0.0.167__py3-none-any.whl

code_puppy/http_utils.py

@@ -10,12 +10,34 @@ from typing import Dict, Optional, Union
 
 import httpx
 import requests
+from tenacity import retry_if_exception_type, stop_after_attempt, wait_exponential
+
+try:
+    from pydantic_ai.retries import (
+        AsyncTenacityTransport,
+        RetryConfig,
+        TenacityTransport,
+        wait_retry_after,
+    )
+except ImportError:
+    # Fallback if pydantic_ai.retries is not available
+    AsyncTenacityTransport = None
+    RetryConfig = None
+    TenacityTransport = None
+    wait_retry_after = None
 
 try:
     from .reopenable_async_client import ReopenableAsyncClient
 except ImportError:
     ReopenableAsyncClient = None
 
+try:
+    from .messaging import emit_info
+except ImportError:
+    # Fallback if messaging system is not available
+    def emit_info(content: str, **metadata):
+        pass  # No-op if messaging system is not available
+
 
 def get_cert_bundle_path() -> str:
     # First check if SSL_CERT_FILE environment variable is set
@@ -28,22 +50,72 @@ def create_client(
     timeout: int = 180,
     verify: Union[bool, str] = None,
     headers: Optional[Dict[str, str]] = None,
+    retry_status_codes: tuple = (429, 502, 503, 504),
 ) -> httpx.Client:
     if verify is None:
         verify = get_cert_bundle_path()
 
-    return httpx.Client(verify=verify, headers=headers or {}, timeout=timeout)
+    # If retry components are available, create a client with retry transport
+    if TenacityTransport and RetryConfig and wait_retry_after:
+        def should_retry_status(response):
+            """Raise exceptions for retryable HTTP status codes."""
+            if response.status_code in retry_status_codes:
+                emit_info(f"HTTP retry: Retrying request due to status code {response.status_code}")
+                response.raise_for_status()
+
+        transport = TenacityTransport(
+            config=RetryConfig(
+                retry=lambda e: isinstance(e, httpx.HTTPStatusError) and e.response.status_code in retry_status_codes,
+                wait=wait_retry_after(
+                    fallback_strategy=wait_exponential(multiplier=1, max=60),
+                    max_wait=300
+                ),
+                stop=stop_after_attempt(5),
+                reraise=True
+            ),
+            validate_response=should_retry_status
+        )
+        
+        return httpx.Client(transport=transport, verify=verify, headers=headers or {}, timeout=timeout)
+    else:
+        # Fallback to regular client if retry components are not available
+        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,
+    retry_status_codes: tuple = (429, 502, 503, 504),
 ) -> httpx.AsyncClient:
     if verify is None:
         verify = get_cert_bundle_path()
 
-    return httpx.AsyncClient(verify=verify, headers=headers or {}, timeout=timeout)
+    # If retry components are available, create a client with retry transport
+    if AsyncTenacityTransport and RetryConfig and wait_retry_after:
+        def should_retry_status(response):
+            """Raise exceptions for retryable HTTP status codes."""
+            if response.status_code in retry_status_codes:
+                emit_info(f"HTTP retry: Retrying request due to status code {response.status_code}")
+                response.raise_for_status()
+
+        transport = AsyncTenacityTransport(
+            config=RetryConfig(
+                retry=lambda e: isinstance(e, httpx.HTTPStatusError) and e.response.status_code in retry_status_codes,
+                wait=wait_retry_after(
+                    fallback_strategy=wait_exponential(multiplier=1, max=60),
+                    max_wait=300
+                ),
+                stop=stop_after_attempt(5),
+                reraise=True
+            ),
+            validate_response=should_retry_status
+        )
+        
+        return httpx.AsyncClient(transport=transport, verify=verify, headers=headers or {}, timeout=timeout)
+    else:
+        # Fallback to regular client if retry components are not available
+        return httpx.AsyncClient(verify=verify, headers=headers or {}, timeout=timeout)
 
 
 def create_requests_session(
@@ -90,17 +162,48 @@ def create_reopenable_async_client(
     timeout: int = 180,
     verify: Union[bool, str] = None,
     headers: Optional[Dict[str, str]] = None,
+    retry_status_codes: tuple = (429, 502, 503, 504),
 ) -> 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
+    # If retry components are available, create a client with retry transport
+    if AsyncTenacityTransport and RetryConfig and wait_retry_after:
+        def should_retry_status(response):
+            """Raise exceptions for retryable HTTP status codes."""
+            if response.status_code in retry_status_codes:
+                emit_info(f"HTTP retry: Retrying request due to status code {response.status_code}")
+                response.raise_for_status()
+
+        transport = AsyncTenacityTransport(
+            config=RetryConfig(
+                retry=lambda e: isinstance(e, httpx.HTTPStatusError) and e.response.status_code in retry_status_codes,
+                wait=wait_retry_after(
+                    fallback_strategy=wait_exponential(multiplier=1, max=60),
+                    max_wait=300
+                ),
+                stop=stop_after_attempt(5),
+                reraise=True
+            ),
+            validate_response=should_retry_status
         )
+        
+        if ReopenableAsyncClient is not None:
+            return ReopenableAsyncClient(
+                transport=transport, verify=verify, headers=headers or {}, timeout=timeout
+            )
+        else:
+            # Fallback to regular AsyncClient if ReopenableAsyncClient is not available
+            return httpx.AsyncClient(transport=transport, 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)
+        # Fallback to regular clients if retry components are not available
+        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:

code_puppy/mcp/managed_server.py

@@ -226,11 +226,9 @@ class ManagedMCPServer:
                     http_kwargs["timeout"] = config["timeout"]
                 if "read_timeout" in config:
                     http_kwargs["read_timeout"] = config["read_timeout"]
-                if "http_client" in config:
-                    http_kwargs["http_client"] = config["http_client"]
-                elif config.get("headers"):
+                if "headers" in config:
+                    http_kwargs["headers"] = config.get("headers")
                     # Create HTTP client if headers are provided but no client specified
-                    http_kwargs["http_client"] = self._get_http_client()
 
                 self._pydantic_server = MCPServerStreamableHTTP(
                     **http_kwargs, process_tool_call=process_tool_call

code_puppy/mcp/server_registry_catalog.py

@@ -791,18 +791,17 @@ MCP_SERVER_REGISTRY: List[MCPServerTemplate] = [
         description="Search and retrieve documentation from multiple sources with AI-powered context understanding",
         category="Documentation",
         tags=["documentation", "search", "context", "ai", "knowledge", "docs", "cloud"],
-        type="stdio",
+        type="http",
         config={
-            "timeout": 30,
-            "command": "npx",
-            "args": ["-y", "@upstash/context7-mcp", "--api-key", "$CONTEXT7_API_KEY"],
+            "url": "https://mcp.context7.com/mcp",
+             "headers": {
+                "Authorization": "Bearer $CONTEXT7_API_KEY"
+             }
         },
         verified=True,
         popular=True,
         requires=MCPServerRequirements(
             environment_vars=["CONTEXT7_API_KEY"],
-            required_tools=["node", "npx"],
-            package_dependencies=["@upstash/context7-mcp"],
         ),
         example_usage="Cloud-based service - no local setup required",
     ),

code_puppy/message_history_processor.py

@@ -1,15 +1,15 @@
 import json
 import queue
-from typing import Any, Dict, List, Set, Tuple
+from typing import Any, List, Set, Tuple
 
 import pydantic
 from pydantic_ai.messages import ModelMessage, ModelRequest, TextPart, ToolCallPart
 
 from code_puppy.config import (
-    get_compaction_strategy,
-    get_compaction_threshold,
     get_model_name,
     get_protected_token_count,
+    get_compaction_threshold,
+    get_compaction_strategy,
 )
 from code_puppy.messaging import emit_error, emit_info, emit_warning
 from code_puppy.model_factory import ModelFactory
@@ -82,9 +82,7 @@ def estimate_tokens_for_message(message: ModelMessage) -> int:
 
 
 def filter_huge_messages(messages: List[ModelMessage]) -> List[ModelMessage]:
-    # First deduplicate tool returns to clean up any duplicates
-    deduplicated = deduplicate_tool_returns(messages)
-    filtered = [m for m in deduplicated if estimate_tokens_for_message(m) < 50000]
+    filtered = [m for m in messages if estimate_tokens_for_message(m) < 50000]
     pruned = prune_interrupted_tool_calls(filtered)
     return pruned
 
@@ -150,6 +148,81 @@ def split_messages_for_protected_summarization(
     return messages_to_summarize, protected_messages
 
 
+def deduplicate_tool_returns(messages: List[ModelMessage]) -> List[ModelMessage]:
+    """
+    Remove duplicate tool returns while preserving the first occurrence for each tool_call_id.
+
+    This function identifies tool-return parts that share the same tool_call_id and
+    removes duplicates, keeping only the first return for each id. This prevents
+    conversation corruption from duplicate tool_result blocks.
+    """
+    if not messages:
+        return messages
+
+    seen_tool_returns: Set[str] = set()
+    deduplicated: List[ModelMessage] = []
+    removed_count = 0
+
+    for msg in messages:
+        # Check if this message has any parts we need to filter
+        if not hasattr(msg, "parts") or not msg.parts:
+            deduplicated.append(msg)
+            continue
+
+        # Filter parts within this message
+        filtered_parts = []
+        msg_had_duplicates = False
+
+        for part in msg.parts:
+            tool_call_id = getattr(part, "tool_call_id", None)
+            part_kind = getattr(part, "part_kind", None)
+
+            # Check if this is a tool-return part
+            if tool_call_id and part_kind in {
+                "tool-return",
+                "tool-result",
+                "tool_result",
+            }:
+                if tool_call_id in seen_tool_returns:
+                    # This is a duplicate return, skip it
+                    msg_had_duplicates = True
+                    removed_count += 1
+                    continue
+                else:
+                    # First occurrence of this return, keep it
+                    seen_tool_returns.add(tool_call_id)
+                    filtered_parts.append(part)
+            else:
+                # Not a tool return, always keep
+                filtered_parts.append(part)
+
+        # If we filtered out parts, create a new message with filtered parts
+        if msg_had_duplicates and filtered_parts:
+            # Create a new message with the same attributes but filtered parts
+            new_msg = type(msg)(parts=filtered_parts)
+            # Copy over other attributes if they exist
+            for attr_name in dir(msg):
+                if (
+                    not attr_name.startswith("_")
+                    and attr_name != "parts"
+                    and hasattr(msg, attr_name)
+                ):
+                    try:
+                        setattr(new_msg, attr_name, getattr(msg, attr_name))
+                    except (AttributeError, TypeError):
+                        # Skip attributes that can't be set
+                        pass
+            deduplicated.append(new_msg)
+        elif filtered_parts:  # No duplicates but has parts
+            deduplicated.append(msg)
+        # If no parts remain after filtering, drop the entire message
+
+    if removed_count > 0:
+        emit_warning(f"Removed {removed_count} duplicate tool-return part(s)")
+
+    return deduplicated
+
+
 def summarize_messages(
     messages: List[ModelMessage], with_protection=True
 ) -> Tuple[List[ModelMessage], List[ModelMessage]]:
@@ -236,100 +309,21 @@ def get_model_context_length() -> int:
     return int(context_length)
 
 
-def deduplicate_tool_returns(messages: List[ModelMessage]) -> List[ModelMessage]:
-    """
-    Remove duplicate tool returns while preserving the first occurrence for each tool_call_id.
-
-    This function identifies tool-return parts that share the same tool_call_id and
-    removes duplicates, keeping only the first return for each id. This prevents
-    conversation corruption from duplicate tool_result blocks.
-    """
-    if not messages:
-        return messages
-
-    seen_tool_returns: Set[str] = set()
-    deduplicated: List[ModelMessage] = []
-    removed_count = 0
-
-    for msg in messages:
-        # Check if this message has any parts we need to filter
-        if not hasattr(msg, "parts") or not msg.parts:
-            deduplicated.append(msg)
-            continue
-
-        # Filter parts within this message
-        filtered_parts = []
-        msg_had_duplicates = False
-
-        for part in msg.parts:
-            tool_call_id = getattr(part, "tool_call_id", None)
-            part_kind = getattr(part, "part_kind", None)
-
-            # Check if this is a tool-return part
-            if tool_call_id and part_kind in {
-                "tool-return",
-                "tool-result",
-                "tool_result",
-            }:
-                if tool_call_id in seen_tool_returns:
-                    # This is a duplicate return, skip it
-                    msg_had_duplicates = True
-                    removed_count += 1
-                    continue
-                else:
-                    # First occurrence of this return, keep it
-                    seen_tool_returns.add(tool_call_id)
-                    filtered_parts.append(part)
-            else:
-                # Not a tool return, always keep
-                filtered_parts.append(part)
-
-        # If we filtered out parts, create a new message with filtered parts
-        if msg_had_duplicates and filtered_parts:
-            # Create a new message with the same attributes but filtered parts
-            new_msg = type(msg)(parts=filtered_parts)
-            # Copy over other attributes if they exist
-            for attr_name in dir(msg):
-                if (
-                    not attr_name.startswith("_")
-                    and attr_name != "parts"
-                    and hasattr(msg, attr_name)
-                ):
-                    try:
-                        setattr(new_msg, attr_name, getattr(msg, attr_name))
-                    except (AttributeError, TypeError):
-                        # Skip attributes that can't be set
-                        pass
-            deduplicated.append(new_msg)
-        elif filtered_parts:  # No duplicates but has parts
-            deduplicated.append(msg)
-        # If no parts remain after filtering, drop the entire message
-
-    if removed_count > 0:
-        emit_warning(f"Removed {removed_count} duplicate tool-return part(s)")
-
-    return deduplicated
-
-
 def prune_interrupted_tool_calls(messages: List[ModelMessage]) -> List[ModelMessage]:
     """
     Remove any messages that participate in mismatched tool call sequences.
 
     A mismatched tool call id is one that appears in a ToolCall (model/tool request)
-    without a corresponding tool return, or vice versa. We enforce a strict 1:1 ratio
-    between tool calls and tool returns. We preserve original order and only drop
-    messages that contain parts referencing mismatched tool_call_ids.
+    without a corresponding tool return, or vice versa. We preserve original order
+    and only drop messages that contain parts referencing mismatched tool_call_ids.
     """
     if not messages:
         return messages
 
-    # First deduplicate tool returns to clean up any duplicate returns
-    messages = deduplicate_tool_returns(messages)
+    tool_call_ids: Set[str] = set()
+    tool_return_ids: Set[str] = set()
 
-    tool_call_counts: Dict[str, int] = {}
-    tool_return_counts: Dict[str, int] = {}
-
-    # First pass: count occurrences of each tool_call_id for calls vs returns
+    # First pass: collect ids for calls vs returns
     for msg in messages:
         for part in getattr(msg, "parts", []) or []:
             tool_call_id = getattr(part, "tool_call_id", None)
@@ -338,25 +332,11 @@ def prune_interrupted_tool_calls(messages: List[ModelMessage]) -> List[ModelMess
             # Heuristic: if it's an explicit ToolCallPart or has a tool_name/args,
             # consider it a call; otherwise it's a return/result.
             if part.part_kind == "tool-call":
-                tool_call_counts[tool_call_id] = (
-                    tool_call_counts.get(tool_call_id, 0) + 1
-                )
+                tool_call_ids.add(tool_call_id)
             else:
-                tool_return_counts[tool_call_id] = (
-                    tool_return_counts.get(tool_call_id, 0) + 1
-                )
-
-    # Find mismatched tool_call_ids (not exactly 1:1 ratio)
-    all_tool_ids = set(tool_call_counts.keys()) | set(tool_return_counts.keys())
-    mismatched: Set[str] = set()
-
-    for tool_id in all_tool_ids:
-        call_count = tool_call_counts.get(tool_id, 0)
-        return_count = tool_return_counts.get(tool_id, 0)
-        # Enforce strict 1:1 ratio - both must be exactly 1
-        if call_count != 1 or return_count != 1:
-            mismatched.add(tool_id)
+                tool_return_ids.add(tool_call_id)
 
+    mismatched: Set[str] = tool_call_ids.symmetric_difference(tool_return_ids)
     if not mismatched:
         return messages
 
@@ -382,10 +362,7 @@ def prune_interrupted_tool_calls(messages: List[ModelMessage]) -> List[ModelMess
 
 
 def message_history_processor(messages: List[ModelMessage]) -> List[ModelMessage]:
-    # First, deduplicate tool returns to clean up any duplicates
-    messages = deduplicate_tool_returns(messages)
-
-    # Then, prune any interrupted/mismatched tool-call conversations
+    # First, prune any interrupted/mismatched tool-call conversations
     total_current_tokens = sum(estimate_tokens_for_message(msg) for msg in messages)
 
     model_max = get_model_context_length()
@@ -477,8 +454,6 @@ def truncation(
     messages: List[ModelMessage], protected_tokens: int
 ) -> List[ModelMessage]:
     emit_info("Truncating message history to manage token usage")
-    # First deduplicate tool returns to clean up any duplicates
-    messages = deduplicate_tool_returns(messages)
     result = [messages[0]]  # Always keep the first message (system prompt)
     num_tokens = 0
     stack = queue.LifoQueue()
@@ -501,10 +476,6 @@ def truncation(
 
 def message_history_accumulator(messages: List[Any]):
     _message_history = get_message_history()
-
-    # Deduplicate tool returns in current history before processing new messages
-    _message_history = deduplicate_tool_returns(_message_history)
-
     message_history_hashes = set([hash_message(m) for m in _message_history])
     for msg in messages:
         if (
@@ -513,12 +484,6 @@ def message_history_accumulator(messages: List[Any]):
         ):
             _message_history.append(msg)
 
-    # Deduplicate tool returns again after adding new messages to ensure no duplicates
-    _message_history = deduplicate_tool_returns(_message_history)
-
-    # Update the message history with deduplicated messages
-    set_message_history(_message_history)
-
     # Apply message history trimming using the main processor
     # This ensures we maintain global state while still managing context limits
     message_history_processor(_message_history)

code_puppy/tools/command_runner.py

@@ -22,6 +22,17 @@ from code_puppy.messaging import (
 from code_puppy.state_management import is_tui_mode
 from code_puppy.tools.common import generate_group_id
 
+# Maximum line length for shell command output to prevent massive token usage
+# This helps avoid exceeding model context limits when commands produce very long lines
+MAX_LINE_LENGTH = 256
+
+
+def _truncate_line(line: str) -> str:
+    """Truncate a line to MAX_LINE_LENGTH if it exceeds the limit."""
+    if len(line) > MAX_LINE_LENGTH:
+        return line[:MAX_LINE_LENGTH] + "... [truncated]"
+    return line
+
 _AWAITING_USER_INPUT = False
 
 _CONFIRMATION_LOCK = threading.Lock()
@@ -188,6 +199,8 @@ def run_shell_command_streaming(
             for line in iter(process.stdout.readline, ""):
                 if line:
                     line = line.rstrip("\n\r")
+                    # Limit line length to prevent massive token usage
+                    line = _truncate_line(line)
                     stdout_lines.append(line)
                     emit_system_message(line, message_group=group_id)
                     last_output_time[0] = time.time()
@@ -199,6 +212,8 @@ def run_shell_command_streaming(
             for line in iter(process.stderr.readline, ""):
                 if line:
                     line = line.rstrip("\n\r")
+                    # Limit line length to prevent massive token usage
+                    line = _truncate_line(line)
                     stderr_lines.append(line)
                     emit_system_message(line, message_group=group_id)
                     last_output_time[0] = time.time()
@@ -252,8 +267,8 @@ def run_shell_command_streaming(
             **{
                 "success": False,
                 "command": command,
-                "stdout": "\n".join(stdout_lines[-1000:]),
-                "stderr": "\n".join(stderr_lines[-1000:]),
+                "stdout": "\n".join(stdout_lines[-256:]),
+                "stderr": "\n".join(stderr_lines[-256:]),
                 "exit_code": -9,
                 "execution_time": execution_time,
                 "timeout": True,
@@ -315,23 +330,31 @@ def run_shell_command_streaming(
             )
             emit_info(f"Took {execution_time:.2f}s", message_group=group_id)
             time.sleep(1)
+            # Apply line length limits to stdout/stderr before returning
+            truncated_stdout = [_truncate_line(line) for line in stdout_lines[-256:]]
+            truncated_stderr = [_truncate_line(line) for line in stderr_lines[-256:]]
+                
             return ShellCommandOutput(
                 success=False,
                 command=command,
                 error="""The process didn't exit cleanly! If the user_interrupted flag is true,
                 please stop all execution and ask the user for clarification!""",
-                stdout="\n".join(stdout_lines[-1000:]),
-                stderr="\n".join(stderr_lines[-1000:]),
+                stdout="\n".join(truncated_stdout),
+                stderr="\n".join(truncated_stderr),
                 exit_code=exit_code,
                 execution_time=execution_time,
                 timeout=False,
                 user_interrupted=process.pid in _USER_KILLED_PROCESSES,
             )
+        # Apply line length limits to stdout/stderr before returning
+        truncated_stdout = [_truncate_line(line) for line in stdout_lines[-256:]]
+        truncated_stderr = [_truncate_line(line) for line in stderr_lines[-256:]]
+            
         return ShellCommandOutput(
             success=exit_code == 0,
             command=command,
-            stdout="\n".join(stdout_lines[-1000:]),
-            stderr="\n".join(stderr_lines[-1000:]),
+            stdout="\n".join(truncated_stdout),
+            stderr="\n".join(truncated_stderr),
             exit_code=exit_code,
             execution_time=execution_time,
             timeout=False,
@@ -453,12 +476,24 @@ def run_shell_command(
             stdout = None
         if "stderr" not in locals():
             stderr = None
+            
+        # Apply line length limits to stdout/stderr if they exist
+        truncated_stdout = None
+        if stdout:
+            stdout_lines = stdout.split("\n")
+            truncated_stdout = "\n".join([_truncate_line(line) for line in stdout_lines[-256:]])
+            
+        truncated_stderr = None
+        if stderr:
+            stderr_lines = stderr.split("\n")
+            truncated_stderr = "\n".join([_truncate_line(line) for line in stderr_lines[-256:]])
+            
         return ShellCommandOutput(
             success=False,
             command=command,
             error=f"Error executing command {str(e)}",
-            stdout="\n".join(stdout[-1000:]) if stdout else None,
-            stderr="\n".join(stderr[-1000:]) if stderr else None,
+            stdout=truncated_stdout,
+            stderr=truncated_stderr,
             exit_code=-1,
             timeout=False,
         )
@@ -520,8 +555,8 @@ def register_agent_run_shell_command(agent):
                 - 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)
+                - stdout (str | None): Standard output from the command (last 256 lines)
+                - stderr (str | None): Standard error from the command (last 256 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

code_puppy/tools/file_operations.py

@@ -208,17 +208,22 @@ def _list_files(
         files = result.stdout.strip().split("\n") if result.stdout.strip() else []
 
         # Create ListedFile objects with metadata
-        for file_path in files:
-            if not file_path:  # Skip empty lines
+        for full_path in files:
+            if not full_path:  # Skip empty lines
                 continue
 
-            full_path = os.path.join(directory, file_path)
-
             # Skip if file doesn't exist (though it should)
             if not os.path.exists(full_path):
                 continue
 
+            # Extract relative path from the full path
+            if full_path.startswith(directory):
+                file_path = full_path[len(directory):].lstrip(os.sep)
+            else:
+                file_path = full_path
+
             # For non-recursive mode, skip files in subdirectories
+            # Only check the relative path, not the full path
             if not recursive and os.sep in file_path:
                 continue
 
@@ -242,7 +247,7 @@ def _list_files(
                 if entry_type == "file":
                     size = actual_size
 
-                # Calculate depth
+                # Calculate depth based on the relative path
                 depth = file_path.count(os.sep)
 
                 # Add directory entries if needed for files
@@ -281,6 +286,33 @@ def _list_files(
             except (FileNotFoundError, PermissionError, OSError):
                 # Skip files we can't access
                 continue
+
+        # In non-recursive mode, we also need to explicitly list directories in the target directory
+        # ripgrep's --files option only returns files, not directories
+        if not recursive:
+            try:
+                entries = os.listdir(directory)
+                for entry in entries:
+                    full_entry_path = os.path.join(directory, entry)
+                    # Skip if it doesn't exist or if it's a file (since files are already listed by ripgrep)
+                    if not os.path.exists(full_entry_path) or os.path.isfile(full_entry_path):
+                        continue
+                    
+                    # For non-recursive mode, only include directories that are directly in the target directory
+                    if os.path.isdir(full_entry_path):
+                        # Create a ListedFile for the directory
+                        results.append(
+                            ListedFile(
+                                path=entry,
+                                type="directory",
+                                size=0,
+                                full_path=full_entry_path,
+                                depth=0,
+                            )
+                        )
+            except (FileNotFoundError, PermissionError, OSError):
+                # Skip directories we can't access
+                pass
     except subprocess.TimeoutExpired:
         error_msg = (
             "[red bold]Error:[/red bold] List files command timed out after 30 seconds"
@@ -337,9 +369,12 @@ def _list_files(
         else:
             return "\U0001f4c4"
 
+    # Count items in results
     dir_count = sum(1 for item in results if item.type == "directory")
     file_count = sum(1 for item in results if item.type == "file")
     total_size = sum(item.size for item in results if item.type == "file")
+    
+
 
     # Build the directory header section
     dir_name = os.path.basename(directory) or directory
@@ -393,8 +428,8 @@ def _list_files(
     final_divider = "[dim]" + "─" * 100 + "\n" + "[/dim]"
     output_lines.append(final_divider)
 
-    # Return both the content string and the list of ListedFile objects
-    return ListFileOutput(content="\n".join(output_lines), files=results)
+    # Return the content string
+    return ListFileOutput(content="\n".join(output_lines))
 
 
 def _read_file(

code_puppy/tui/components/custom_widgets.py

@@ -21,8 +21,13 @@ class CustomTextArea(TextArea):
 
     def on_key(self, event):
         """Handle key events before they reach the internal _on_key handler."""
-        # Explicitly handle escape+enter/alt+enter sequences
-        if event.key == "escape+enter" or event.key == "alt+enter":
+        # Let the binding system handle alt+enter
+        if event.key == "alt+enter":
+            # Don't prevent default - let the binding system handle it
+            return
+        
+        # Handle escape+enter manually
+        if event.key == "escape+enter":
             self.action_insert_newline()
             event.prevent_default()
             event.stop()

{code_puppy-0.0.165.dist-info → code_puppy-0.0.167.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-puppy
-Version: 0.0.165
+Version: 0.0.167
 Summary: Code generation agent
 Project-URL: repository, https://github.com/mpfaffenberger/code_puppy
 Project-URL: HomePage, https://github.com/mpfaffenberger/code_puppy
@@ -33,6 +33,7 @@ Requires-Dist: rapidfuzz>=3.13.0
 Requires-Dist: rich>=13.4.2
 Requires-Dist: ripgrep>=14.1.0
 Requires-Dist: ruff>=0.11.11
+Requires-Dist: tenacity>=8.2.0
 Requires-Dist: termcolor>=3.1.0
 Requires-Dist: textual-dev>=1.7.0
 Requires-Dist: textual>=5.0.0

{code_puppy-0.0.165.dist-info → code_puppy-0.0.167.dist-info}/RECORD

@@ -3,9 +3,9 @@ code_puppy/__main__.py,sha256=pDVssJOWP8A83iFkxMLY9YteHYat0EyWDQqMkKHpWp4,203
 code_puppy/agent.py,sha256=wCARhq7PcD38c4l83fuXm4Us_6c1TXVa0U7TnBnNPEY,8064
 code_puppy/callbacks.py,sha256=6wYB6K_fGSCkKKEFaYOYkJT45WaV5W_NhUIzcvVH_nU,5060
 code_puppy/config.py,sha256=J8XU0iOPtfzrkDD49b4TdrdHoQmW2kaP-25PPbGGdKU,16386
-code_puppy/http_utils.py,sha256=BAvt4hed7fVMXglA7eS9gOb08h2YTuOyai6VmQq09fg,3432
+code_puppy/http_utils.py,sha256=JecBdukr9dr1xcjw-Zyx2iD65RDEd183r8e1NMU4HLo,8093
 code_puppy/main.py,sha256=tYLfhUjPTJ-4S1r-pr-jSbn6kIU1iYvt2Z8lxI7zDFY,22220
-code_puppy/message_history_processor.py,sha256=ZlEMGMGiBdlP_xBmipfPtD9zjp0bt1SbRhlHn89nlPE,20375
+code_puppy/message_history_processor.py,sha256=zzeOSUC1Wpsry-z2MD6pQWk2wt1axGSOKaGR2v22_qQ,18825
 code_puppy/model_factory.py,sha256=z9vQbcGllgMwU0On8rPvzYxkygW2Uyd3NJmRzbKv-is,13759
 code_puppy/models.json,sha256=iXmLZGflnQcu2DRh4WUlgAhoXdvoxUc7KBhB8YxawXM,3088
 code_puppy/reopenable_async_client.py,sha256=4UJRaMp5np8cbef9F0zKQ7TPKOfyf5U-Kv-0zYUWDho,8274
@@ -59,11 +59,11 @@ code_puppy/mcp/config_wizard.py,sha256=SIsm8uhDInfRYy_2W8wPIZcmoxk24680ikhMT93Vu
 code_puppy/mcp/dashboard.py,sha256=y6t6trrBZU-mr8W1_29VN5DeZI8VYvOsKNz1EXxlvUg,9022
 code_puppy/mcp/error_isolation.py,sha256=mpPBiH17zTXPsOEAn9WmkbwQwnt4gmgiaWv87JBJbUo,12426
 code_puppy/mcp/health_monitor.py,sha256=n5R6EeYOYbUucUFe74qGWCU3g6Mep5UEQbLF0wbT0dU,19688
-code_puppy/mcp/managed_server.py,sha256=vYD_uwHJDyRB7iHNIZHTNEin5bVe9lCMMjJyFMWNjc8,14381
+code_puppy/mcp/managed_server.py,sha256=EZwWsQGxzgnjL6TGJTm58Pj6fw7kkYpLuolYQY-GbXY,14256
 code_puppy/mcp/manager.py,sha256=Yx9zxukdXgdPDgeJiiQPYlPae0zQPofHWB-axuoMNc8,26426
 code_puppy/mcp/registry.py,sha256=IvbIL-pETQ7HS7iRgsoT5j7eY8TOJXqYczSiigT2ofU,15752
 code_puppy/mcp/retry_manager.py,sha256=evVxbtrsHNyo8UoI7zpO-NVDegibn82RLlgN8VKewA8,10665
-code_puppy/mcp/server_registry_catalog.py,sha256=jYx__H-b-f4Ucpczx-wwpU-TRx6fXzFDR0kr2Qhwqb0,38857
+code_puppy/mcp/server_registry_catalog.py,sha256=U0HJMgEeF8Ntq3ZWepA0Z9t8ZG82Toa9JCGBjiDAzh8,38760
 code_puppy/mcp/status_tracker.py,sha256=uekxrzkzIWrv3OfSVgblaPuoGFcAh_dBYwCcaHZ_CrM,12183
 code_puppy/mcp/system_tools.py,sha256=7_oR8k0c8YjtCcYF9g7A946oAGuKOf_i-92aJH7VmlQ,7331
 code_puppy/mcp/examples/retry_example.py,sha256=En3LiqECYmG00gWaa7K9L9vvGk1VJyYtKWcv3p3gzCc,7220
@@ -78,10 +78,10 @@ code_puppy/messaging/spinner/textual_spinner.py,sha256=Omx9A-FSPkxYDMYgBXgYMBQnK
 code_puppy/plugins/__init__.py,sha256=fksDqMUiXPJ5WNuMsYsVR8ulueQRCXPlvECEyicHPtQ,1312
 code_puppy/tools/__init__.py,sha256=YiiXRqxU1BEJ5t0Oe163lSqOneI9sKtwDW0swCPgBt4,2119
 code_puppy/tools/agent_tools.py,sha256=bHMrFIbYRhuubR41G_XdLsk3cUKWfIPl2O4bVzo2pE0,5591
-code_puppy/tools/command_runner.py,sha256=6mGO90xks2OwJCEvwrsrNf3lRfcKXrMeLbkJEpX5bMw,20857
+code_puppy/tools/command_runner.py,sha256=TeKbUY1BeHpUEYtBbmEXnYd4ESI-RGNXRlI-7I1UNHU,22427
 code_puppy/tools/common.py,sha256=pL-9xcRs3rxU7Fl9X9EUgbDp2-csh2LLJ5DHH_KAHKY,10596
 code_puppy/tools/file_modifications.py,sha256=EaDWcv6gi8wAvpgyeJdKSKPWg9fTpZoEkxQiLCE6rn4,23218
-code_puppy/tools/file_operations.py,sha256=Cxa5bqbVNwgViSdBjwGOrqWmtxBPhQRjDBepgt2Xuxk,30852
+code_puppy/tools/file_operations.py,sha256=dEnsGCbDF12ctegCm9Kiu-mgNCrvopf64ij_CQbikW4,32460
 code_puppy/tools/tools_content.py,sha256=bsBqW-ppd1XNAS_g50B3UHDQBWEALC1UneH6-afz1zo,2365
 code_puppy/tui/__init__.py,sha256=XesAxIn32zLPOmvpR2wIDxDAnnJr81a5pBJB4cZp1Xs,321
 code_puppy/tui/app.py,sha256=nPOzwlusjdWzBfu__EbC3Q0etkPrqRq-2g-mk4IcfG4,39378
@@ -90,7 +90,7 @@ code_puppy/tui/components/__init__.py,sha256=uj5pnk3s6SEN3SbFI0ZnzaA2KK1NNg8TfUj
 code_puppy/tui/components/chat_view.py,sha256=NfyNXuN2idPht1rKJB4YhHVXb1AIRNO5q_nLdt8Ocug,19913
 code_puppy/tui/components/command_history_modal.py,sha256=pUPEQvoCWa2iUnuMgNwO22y8eUbyw0HpcPH3wAosHvU,7097
 code_puppy/tui/components/copy_button.py,sha256=E4-OJYk5YNzDf-E81NyiVGKsTRPrUX-RnQ8qFuVnabw,4375
-code_puppy/tui/components/custom_widgets.py,sha256=pnjkB3ZNa5lwSrAXUFlhN9AHNh4uMTpSap8AdbpecKw,1986
+code_puppy/tui/components/custom_widgets.py,sha256=y-ZodibwL_GNaWntmFMn7eeC93wJNss590D43rGMO6A,2122
 code_puppy/tui/components/human_input_modal.py,sha256=isj-zrSIcK5iy3L7HJNgDFWN1zhxY4f3zvp4krbs07E,5424
 code_puppy/tui/components/input_area.py,sha256=R4R32eXPZ2R8KFisIbldNGq60KMk7kCxWrdbeTgJUr8,4395
 code_puppy/tui/components/sidebar.py,sha256=nGtCiYzZalPmiFaJ4dwj2S4EJBu5wQZVzhoigYYY7U4,10369
@@ -104,9 +104,9 @@ code_puppy/tui/screens/help.py,sha256=eJuPaOOCp7ZSUlecearqsuX6caxWv7NQszUh0tZJjB
 code_puppy/tui/screens/mcp_install_wizard.py,sha256=xqwN5omltMkfxWZwXj3D2PbXbtrxUi1dT0XT77oxOKk,27685
 code_puppy/tui/screens/settings.py,sha256=GMpv-qa08rorAE9mj3AjmqjZFPhmeJ_GWd-DBHG6iAA,10671
 code_puppy/tui/screens/tools.py,sha256=3pr2Xkpa9Js6Yhf1A3_wQVRzFOui-KDB82LwrsdBtyk,1715
-code_puppy-0.0.165.data/data/code_puppy/models.json,sha256=iXmLZGflnQcu2DRh4WUlgAhoXdvoxUc7KBhB8YxawXM,3088
-code_puppy-0.0.165.dist-info/METADATA,sha256=IHbmXg1BoiexNSYBnNpjLyNCmPVYopMvIKwMZfaiCVk,19567
-code_puppy-0.0.165.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-code_puppy-0.0.165.dist-info/entry_points.txt,sha256=d8YkBvIUxF-dHNJAj-x4fPEqizbY5d_TwvYpc01U5kw,58
-code_puppy-0.0.165.dist-info/licenses/LICENSE,sha256=31u8x0SPgdOq3izJX41kgFazWsM43zPEF9eskzqbJMY,1075
-code_puppy-0.0.165.dist-info/RECORD,,
+code_puppy-0.0.167.data/data/code_puppy/models.json,sha256=iXmLZGflnQcu2DRh4WUlgAhoXdvoxUc7KBhB8YxawXM,3088
+code_puppy-0.0.167.dist-info/METADATA,sha256=kmno03NP1H0J8qL2UAKHSq200Bsv1XkwCk9GqfwsrXg,19598
+code_puppy-0.0.167.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+code_puppy-0.0.167.dist-info/entry_points.txt,sha256=d8YkBvIUxF-dHNJAj-x4fPEqizbY5d_TwvYpc01U5kw,58
+code_puppy-0.0.167.dist-info/licenses/LICENSE,sha256=31u8x0SPgdOq3izJX41kgFazWsM43zPEF9eskzqbJMY,1075
+code_puppy-0.0.167.dist-info/RECORD,,