henchman-ai 0.1.8__py3-none-any.whl → 0.1.9__py3-none-any.whl

henchman/cli/input.py

@@ -5,6 +5,7 @@ This module handles user input including @ file references and ! shell commands.
 
 from __future__ import annotations
 
+import contextlib
 import re
 from pathlib import Path
 from typing import Any
@@ -124,9 +125,10 @@ def create_session(
             # Clear buffer if there is text
             buffer.text = ""
         else:
-            # If buffer is empty, exit the application gracefully
-            # This signals the user wants to quit
-            event.app.exit(result="")
+            # If buffer is empty, return to prompt with empty result
+            # Use suppress to handle case where result is already set
+            with contextlib.suppress(Exception):
+                event.app.exit(result="")
 
     history = FileHistory(str(history_file)) if history_file else None
 

henchman/config/schema.py

@@ -44,6 +44,9 @@ class ToolSettings(BaseModel):
         max_tool_calls_per_turn: Maximum tool calls allowed per turn.
         max_protected_ratio: Maximum ratio of context that can be protected.
         adaptive_limits: Whether to adjust limits based on progress detection.
+        network_retries: Number of retries for network tools (0 = no retries).
+        retry_base_delay: Base delay in seconds for retry backoff.
+        retry_max_delay: Maximum delay in seconds for retry backoff.
     """
 
     auto_approve_read: bool = True
@@ -53,6 +56,9 @@ class ToolSettings(BaseModel):
     max_tool_calls_per_turn: int = 100
     max_protected_ratio: float = 0.3
     adaptive_limits: bool = True
+    network_retries: int = 3
+    retry_base_delay: float = 1.0
+    retry_max_delay: float = 30.0
 
 
 class UISettings(BaseModel):

henchman/tools/registry.py

@@ -1,9 +1,12 @@
 """Tool registry for managing and executing tools."""
 
+import asyncio
 from collections.abc import Awaitable, Callable
+from dataclasses import dataclass
 
 from henchman.providers.base import ToolDeclaration
-from henchman.tools.base import ConfirmationRequest, Tool, ToolResult
+from henchman.tools.base import ConfirmationRequest, Tool, ToolKind, ToolResult
+from henchman.utils.retry import RetryConfig, retry_async
 
 # Type alias for confirmation handler
 ConfirmationHandler = Callable[[ConfirmationRequest], Awaitable[bool]]
@@ -12,6 +15,21 @@ ConfirmationHandler = Callable[[ConfirmationRequest], Awaitable[bool]]
 MAX_TOOL_OUTPUT = 50000
 
 
+@dataclass
+class BatchResult:
+    """Result of a batch tool execution.
+
+    Attributes:
+        results: Mapping of tool names to their results.
+        successful: Number of successful executions.
+        failed: Number of failed executions.
+    """
+
+    results: dict[str, ToolResult]
+    successful: int
+    failed: int
+
+
 class ToolRegistry:
     """Registry for managing tools and their execution.
 
@@ -26,12 +44,29 @@ class ToolRegistry:
         >>> result = await registry.execute("read_file", {"path": "/etc/hosts"})
     """
 
-    def __init__(self) -> None:
-        """Initialize an empty tool registry."""
+    def __init__(
+        self,
+        retry_config: RetryConfig | None = None,
+    ) -> None:
+        """Initialize an empty tool registry.
+
+        Args:
+            retry_config: Optional retry configuration for network tools.
+                         If None, uses defaults (3 retries, 1s base delay).
+        """
         self._tools: dict[str, Tool] = {}
         self._confirmation_handler: ConfirmationHandler | None = None
         self._auto_approve_policies: set[str] = set()
         self._plan_mode: bool = False
+        self._retry_config = retry_config or RetryConfig()
+
+    def set_retry_config(self, config: RetryConfig) -> None:
+        """Set the retry configuration for network tools.
+
+        Args:
+            config: Retry configuration.
+        """
+        self._retry_config = config
 
     def set_plan_mode(self, enabled: bool) -> None:
         """Enable or disable Plan Mode (Read-Only).
@@ -143,7 +178,7 @@ class ToolRegistry:
         2. Check Plan Mode restrictions
         3. Check if confirmation is needed (unless auto-approved or READ tool)
         4. Call confirmation handler if needed
-        5. Execute the tool if approved
+        5. Execute the tool if approved (with retries for NETWORK tools)
 
         Args:
             name: The name of the tool to execute.
@@ -161,9 +196,8 @@ class ToolRegistry:
             )
 
         # Check Plan Mode
-        from henchman.tools.base import ToolKind
         if self._plan_mode and tool.kind in (ToolKind.WRITE, ToolKind.EXECUTE, ToolKind.NETWORK):
-             return ToolResult(
+            return ToolResult(
                 content=f"Tool '{name}' is disabled in Plan Mode. Use /plan to toggle.",
                 success=False,
                 error="Tool disabled in Plan Mode",
@@ -181,8 +215,21 @@ class ToolRegistry:
                         error="Execution denied by user",
                     )
 
-        # Execute the tool
-        result = await tool.execute(**params)
+        # Execute the tool (with retries for NETWORK tools)
+        try:
+            if tool.kind == ToolKind.NETWORK and self._retry_config.max_retries > 0:
+                result = await retry_async(
+                    lambda: tool.execute(**params),
+                    config=self._retry_config,
+                )
+            else:
+                result = await tool.execute(**params)
+        except Exception as exc:
+            return ToolResult(
+                content=f"Error executing tool '{name}': {exc}",
+                success=False,
+                error=str(exc),
+            )
 
         # Truncate large outputs to prevent context overflow
         if result.content and len(result.content) > MAX_TOOL_OUTPUT:
@@ -196,3 +243,59 @@ class ToolRegistry:
             )
 
         return result
+
+    async def execute_batch(
+        self,
+        calls: list[tuple[str, dict[str, object]]],
+    ) -> BatchResult:
+        """Execute multiple tools in parallel.
+
+        Independent tool calls are executed concurrently using asyncio.gather().
+        This is more efficient than sequential execution for I/O-bound operations.
+
+        Args:
+            calls: List of (tool_name, params) tuples to execute.
+
+        Returns:
+            BatchResult containing individual results and success/failure counts.
+
+        Example:
+            >>> results = await registry.execute_batch([
+            ...     ("read_file", {"path": "/etc/hosts"}),
+            ...     ("read_file", {"path": "/etc/passwd"}),
+            ...     ("glob", {"pattern": "*.py"}),
+            ... ])
+            >>> print(f"Completed: {results.successful} succeeded, {results.failed} failed")
+        """
+        if not calls:
+            return BatchResult(results={}, successful=0, failed=0)
+
+        # Execute all tools concurrently
+        tasks = [self.execute(name, params) for name, params in calls]
+        results_list = await asyncio.gather(*tasks, return_exceptions=True)
+
+        # Collect results
+        results: dict[str, ToolResult] = {}
+        successful = 0
+        failed = 0
+
+        for i, result in enumerate(results_list):
+            tool_name = calls[i][0]
+            key = f"{tool_name}_{i}"  # Unique key for duplicate tool names
+
+            if isinstance(result, BaseException):
+                results[key] = ToolResult(
+                    content=f"Error: {result}",
+                    success=False,
+                    error=str(result),
+                )
+                failed += 1
+            else:
+                tool_result: ToolResult = result
+                results[key] = tool_result
+                if tool_result.success:
+                    successful += 1
+                else:
+                    failed += 1
+
+        return BatchResult(results=results, successful=successful, failed=failed)

henchman/utils/__init__.py

@@ -1 +1,15 @@
 """Utility functions and helpers."""
+
+from henchman.utils.retry import (
+    RetryConfig,
+    calculate_delay,
+    retry_async,
+    with_retry,
+)
+
+__all__ = [
+    "RetryConfig",
+    "calculate_delay",
+    "retry_async",
+    "with_retry",
+]

henchman/utils/retry.py

@@ -0,0 +1,166 @@
+"""Retry utilities with exponential backoff for resilient operations.
+
+This module provides an async retry decorator with configurable exponential
+backoff for handling transient failures in network operations and other
+potentially flaky operations.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import functools
+import random
+from collections.abc import Awaitable, Callable
+from dataclasses import dataclass
+from typing import ParamSpec, TypeVar
+
+P = ParamSpec("P")
+R = TypeVar("R")
+
+
+@dataclass
+class RetryConfig:
+    """Configuration for retry behavior.
+
+    Attributes:
+        max_retries: Maximum number of retry attempts (0 = no retries).
+        base_delay: Base delay in seconds between retries.
+        max_delay: Maximum delay in seconds (cap for exponential growth).
+        exponential_base: Base for exponential backoff (default 2.0).
+        jitter: Whether to add random jitter to delay (prevents thundering herd).
+        retryable_exceptions: Tuple of exception types to retry on.
+    """
+
+    max_retries: int = 3
+    base_delay: float = 1.0
+    max_delay: float = 30.0
+    exponential_base: float = 2.0
+    jitter: bool = True
+    retryable_exceptions: tuple[type[Exception], ...] = (
+        ConnectionError,
+        TimeoutError,
+        OSError,
+    )
+
+
+def calculate_delay(attempt: int, config: RetryConfig) -> float:
+    """Calculate delay for a retry attempt with exponential backoff.
+
+    Args:
+        attempt: The current retry attempt number (0-indexed).
+        config: Retry configuration.
+
+    Returns:
+        Delay in seconds before the next retry.
+
+    Example:
+        >>> cfg = RetryConfig(base_delay=1.0, exponential_base=2.0, jitter=False)
+        >>> calculate_delay(0, cfg)
+        1.0
+        >>> calculate_delay(1, cfg)
+        2.0
+        >>> calculate_delay(2, cfg)
+        4.0
+    """
+    delay = config.base_delay * (config.exponential_base**attempt)
+    delay = min(delay, config.max_delay)
+
+    if config.jitter:
+        # Add random jitter between 0-50% of the delay
+        jitter_amount = delay * random.uniform(0, 0.5)  # noqa: S311
+        delay += jitter_amount
+
+    return delay
+
+
+def with_retry(
+    config: RetryConfig | None = None,
+) -> Callable[[Callable[P, Awaitable[R]]], Callable[P, Awaitable[R]]]:
+    """Decorator for adding retry logic with exponential backoff.
+
+    Args:
+        config: Retry configuration. If None, uses defaults.
+
+    Returns:
+        Decorated async function with retry logic.
+
+    Example:
+        >>> @with_retry(RetryConfig(max_retries=3))
+        ... async def fetch_data(url: str) -> str:
+        ...     # Network operation that might fail
+        ...     return await http_get(url)
+    """
+    if config is None:
+        config = RetryConfig()
+
+    def decorator(func: Callable[P, Awaitable[R]]) -> Callable[P, Awaitable[R]]:
+        """Inner decorator that wraps the function with retry logic."""
+        @functools.wraps(func)
+        async def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
+            """Wrapper function that implements retry with exponential backoff."""
+            last_exception: Exception | None = None
+
+            for attempt in range(config.max_retries + 1):
+                try:
+                    return await func(*args, **kwargs)
+                except config.retryable_exceptions as exc:
+                    last_exception = exc
+
+                    if attempt < config.max_retries:
+                        delay = calculate_delay(attempt, config)
+                        await asyncio.sleep(delay)
+                    # On last attempt, fall through to raise
+
+            # Should never reach here without an exception, but satisfy type checker
+            if last_exception is not None:
+                raise last_exception
+            msg = "Retry logic error: no exception captured"
+            raise RuntimeError(msg)  # pragma: no cover
+
+        return wrapper
+
+    return decorator
+
+
+async def retry_async(
+    func: Callable[[], Awaitable[R]],
+    config: RetryConfig | None = None,
+) -> R:
+    """Execute an async function with retry logic.
+
+    This is a functional alternative to the decorator for cases where
+    you want to retry a specific call rather than decorating a function.
+
+    Args:
+        func: Zero-argument async callable to execute.
+        config: Retry configuration. If None, uses defaults.
+
+    Returns:
+        Result of the function call.
+
+    Raises:
+        Exception: The last exception if all retries fail.
+
+    Example:
+        >>> result = await retry_async(
+        ...     lambda: fetch_data("https://api.example.com"),
+        ...     config=RetryConfig(max_retries=3)
+        ... )
+    """
+    if config is None:
+        config = RetryConfig()
+
+    @with_retry(config)
+    async def wrapped() -> R:
+        """Wrapped function with retry logic applied."""
+        return await func()
+
+    return await wrapped()
+
+
+__all__ = [
+    "RetryConfig",
+    "calculate_delay",
+    "retry_async",
+    "with_retry",
+]

henchman/version.py

@@ -1,6 +1,6 @@
 """Version information for Henchman-AI."""
 
-VERSION_TUPLE = (0, 1, 7)
+VERSION_TUPLE = (0, 1, 9)
 VERSION = ".".join(str(v) for v in VERSION_TUPLE)
 
 __all__ = ["VERSION", "VERSION_TUPLE"]

{henchman_ai-0.1.8.dist-info → henchman_ai-0.1.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: henchman-ai
-Version: 0.1.8
+Version: 0.1.9
 Summary: A model-agnostic AI agent CLI - your AI henchman for the terminal
 Project-URL: Homepage, https://github.com/MGPowerlytics/henchman-ai
 Project-URL: Repository, https://github.com/MGPowerlytics/henchman-ai

{henchman_ai-0.1.8.dist-info → henchman_ai-0.1.9.dist-info}/RECORD

@@ -1,10 +1,10 @@
 henchman/__init__.py,sha256=P_jCbtgAVbk2hn6uMum2UYkE7ptT361mWRkUZz0xKvk,148
 henchman/__main__.py,sha256=3oRWZvoWON5ErlJFYOOSU5p1PERRyK6MkT2LGEnbb2o,131
-henchman/version.py,sha256=__LbucVLec_Xjo5kM2xlVJLc9NovQpC_LE82ONoodKg,160
+henchman/version.py,sha256=FD_uykl80efNIvznILv6PLP9U62_N9a6PJtpNG-nhlA,160
 henchman/cli/__init__.py,sha256=Gv86a_heuBLqUd-y46JZUyzUaDl5H-9RtcWGr3rMwBw,673
 henchman/cli/app.py,sha256=AFiMOfqYdwJrzcp5LRqwgwic2A6yhAUr_01w6BQwPq8,6097
 henchman/cli/console.py,sha256=TOuGBSNUaxxQypmmzC0P1IY7tBNlaTgAZesKy8uuZN4,7850
-henchman/cli/input.py,sha256=uALc_0URsLvlCZ8geW4xtkzWgX6lFWb0b1TCz6GzdMA,4538
+henchman/cli/input.py,sha256=0qW36f7f06ct4XXca7ooxkTShID-QXkLtmROh_xso04,4632
 henchman/cli/json_output.py,sha256=9kP9S5q0xBgP4HQGTT4P6DDT76F9VVTdEY_KiEpoZnI,2669
 henchman/cli/prompts.py,sha256=AxUN-JfWSetOgIwhVxgouQetNqY8hTc7FnLO5jb00LI,5402
 henchman/cli/repl.py,sha256=7nO2Lfy5pUoZiSmWH1ne755_g2SRldMB9CIgz1GZXDg,19023
@@ -20,7 +20,7 @@ henchman/cli/commands/skill.py,sha256=azXb6-KXjtZKwHiBV-Ppk6CdJQKZhetr46hNgZ_r45
 henchman/cli/commands/unlimited.py,sha256=eFMTwrcUFWbfJnXpwBcRqviYt66tDz4xAYBDcton50Y,2101
 henchman/config/__init__.py,sha256=Q3eooEkht80FPzLJQgc-JNFfnFXS6uJlXyQyGl58QYk,557
 henchman/config/context.py,sha256=bJSV56bQFAgECNMDBgM2ZwIkn0h50uibUtUWaQnMq_0,5007
-henchman/config/schema.py,sha256=tlVriPdxCc8YvrWhDnGDdYx2nLLfux4L95hCrTdrbJg,4028
+henchman/config/schema.py,sha256=Ur-GP9aQv5WVAr9k6ordgK1iHkl3L9UWVDxOEYYe-Zw,4340
 henchman/config/settings.py,sha256=KwlWlX3Ogqb_ByIchX9i_p8VM16umDNOa0n-Q4SrxTs,4501
 henchman/core/__init__.py,sha256=BtOHfsJB6eW-QhtK4sbqOzzO6GLqWeVLkewOA-wuqL0,521
 henchman/core/agent.py,sha256=l9BJO8Zw4bMdUyTDjcZKG84WdZ1Kndm3Y09oUAZFYp0,13475
@@ -51,7 +51,7 @@ henchman/skills/models.py,sha256=Vvr6ObxQe5G8EwuLW2Odzpej3CfyqGkgXgCQcY91wps,833
 henchman/skills/store.py,sha256=z_qHnVdyHAm-jtGNy5b33d9jQ-3pN-mkjrBAzc7CA5U,5331
 henchman/tools/__init__.py,sha256=NLQuYRtPECju8TZHg-ZgVUrtdlHdMTu7P8C3D4Nhdqg,440
 henchman/tools/base.py,sha256=PPeKS6jOCv3jFSgjd5j3kzgjTzw7VpBAY3ikmeDlIcI,4820
-henchman/tools/registry.py,sha256=FNcfoqwD9JUh-NrWsx2Vkon3juypWxhrTofrKxWg9Ac,6739
+henchman/tools/registry.py,sha256=YrDz29mwMGPGdJB5RD0QlakHiJ-24p3d_jnIaMY05hI,10228
 henchman/tools/builtins/__init__.py,sha256=EtrnR1rtFh0uBqDembg236HnZfQXSLUHJachESvYG28,715
 henchman/tools/builtins/ask_user.py,sha256=xPu74cB0rYahZHajVdjKgdmKU121SWyAgZSkU_wBYjQ,3007
 henchman/tools/builtins/file_edit.py,sha256=VjfpYVZulpIBufRSIsTx9eD5gYGnSybksyo5vGCL4wo,3709
@@ -62,12 +62,13 @@ henchman/tools/builtins/grep.py,sha256=PV8X2ydnAutrWCS5VR9lABFpfSv0Olzsqa1Ktb5X4
 henchman/tools/builtins/ls.py,sha256=5iSqHilrEiZ8ziOG4nKwC90fuLEx01V_0BzfS2PNAro,4167
 henchman/tools/builtins/shell.py,sha256=Gx8x1jBq1NvERFnc-kUNMovFoWg_i4IrV_askSECfEM,4134
 henchman/tools/builtins/web_fetch.py,sha256=uwgZm0ye3yDuS2U2DPV4D-8bjviYDTKN-cNi7mCMRpw,3370
-henchman/utils/__init__.py,sha256=tqyNdgGqZrcISSg2vBtMlVxsOvwaLo3zjqIk5f3QkhM,37
+henchman/utils/__init__.py,sha256=ayu2XRNx3Fw0z8vbIne63A3gBjxu779QE8sUQsjNnm4,240
 henchman/utils/compaction.py,sha256=jPpJ5tQm-IBn4YChiGrKy8u_K4OJ23lk3Jvq8sNbQYc,22763
+henchman/utils/retry.py,sha256=sobZk9LLGxglSJw_jeNaBYCrvH14YNFrBVyp_OwLWcw,4993
 henchman/utils/tokens.py,sha256=D9H4ciFNH7l1b05IGbw0U0tmy2yF5aItFZyDufGF53k,5665
 henchman/utils/validation.py,sha256=moj4LQXVXt2J-3_pWVH_0-EabyRYApOU2Oh5JSTIua8,4146
-henchman_ai-0.1.8.dist-info/METADATA,sha256=iMG-vJgyJRKxO3-sah01k1fyqfHTtTcMH21DXdy4Hr0,3492
-henchman_ai-0.1.8.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-henchman_ai-0.1.8.dist-info/entry_points.txt,sha256=dtPyd6BzK3A8lmrj1KXTFlHBplIWcWMdryjtR0jw5iU,51
-henchman_ai-0.1.8.dist-info/licenses/LICENSE,sha256=TMoSCCG1I1vCMK-Bjtvxe80E8kIdSdrtuQXYHc_ahqg,1064
-henchman_ai-0.1.8.dist-info/RECORD,,
+henchman_ai-0.1.9.dist-info/METADATA,sha256=C1bCnWJpK3B-vjpJ0deP2OWikysCGW9hOkBkbfAB9pQ,3492
+henchman_ai-0.1.9.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+henchman_ai-0.1.9.dist-info/entry_points.txt,sha256=dtPyd6BzK3A8lmrj1KXTFlHBplIWcWMdryjtR0jw5iU,51
+henchman_ai-0.1.9.dist-info/licenses/LICENSE,sha256=TMoSCCG1I1vCMK-Bjtvxe80E8kIdSdrtuQXYHc_ahqg,1064
+henchman_ai-0.1.9.dist-info/RECORD,,