code-puppy 0.0.166__tar.gz → 0.0.167__tar.gz

{code_puppy-0.0.166 → code_puppy-0.0.167}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-puppy
-Version: 0.0.166
+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.167/code_puppy/http_utils.py

@@ -0,0 +1,225 @@
+"""
+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
+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
+    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,
+    retry_status_codes: tuple = (429, 502, 503, 504),
+) -> httpx.Client:
+    if verify is None:
+        verify = get_cert_bundle_path()
+
+    # 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()
+
+    # 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(
+    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,
+    retry_status_codes: tuple = (429, 502, 503, 504),
+) -> Union[ReopenableAsyncClient, httpx.AsyncClient]:
+    if verify is None:
+        verify = get_cert_bundle_path()
+
+    # 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 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:
+    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

{code_puppy-0.0.166 → code_puppy-0.0.167}/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-0.0.166 → code_puppy-0.0.167}/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-0.0.166 → code_puppy-0.0.167}/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-0.0.166 → code_puppy-0.0.167}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "code-puppy"
-version = "0.0.166"
+version = "0.0.167"
 description = "Code generation agent"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -33,6 +33,7 @@ dependencies = [
     "textual-dev>=1.7.0",
     "openai>=1.99.1",
     "ripgrep>=14.1.0",
+    "tenacity>=8.2.0",
 ]
 dev-dependencies = [
     "pytest>=8.3.4",

code_puppy-0.0.166/code_puppy/http_utils.py

@@ -1,122 +0,0 @@
-"""
-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