henchman-ai 0.1.6__tar.gz → 0.1.7__tar.gz

{henchman_ai-0.1.6 → henchman_ai-0.1.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: henchman-ai
-Version: 0.1.6
+Version: 0.1.7
 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.6 → henchman_ai-0.1.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "henchman-ai"
-version = "0.1.6"
+version = "0.1.7"
 description = "A model-agnostic AI agent CLI - your AI henchman for the terminal"
 readme = "README.md"
 license = "MIT"

{henchman_ai-0.1.6 → henchman_ai-0.1.7}/src/henchman/tools/builtins/glob_tool.py

@@ -80,16 +80,16 @@ class GlobTool(Tool):
             # Use a generator approach to avoid loading all files into memory if possible
             # But glob() returns a generator anyway.
             matches_iter = base_path.glob(pattern)
-            
+
             matches = []
             truncated = False
-            
+
             try:
                 for _ in range(self.MAX_MATCHES + 1):
                     matches.append(next(matches_iter))
             except StopIteration:
                 pass
-                
+
             if len(matches) > self.MAX_MATCHES:
                 truncated = True
                 matches = matches[:self.MAX_MATCHES]
@@ -108,7 +108,7 @@ class GlobTool(Tool):
                     results.append(str(rel_path))
                 except ValueError:  # pragma: no cover
                     results.append(str(match))
-            
+
             if truncated:
                 results.append(f"... Output truncated (limit reached: {self.MAX_MATCHES} matches) ...")
 

{henchman_ai-0.1.6 → henchman_ai-0.1.7}/src/henchman/tools/builtins/grep.py

@@ -132,11 +132,8 @@ class GrepTool(Tool):
                     for i, line in enumerate(lines, 1):
                         if regex.search(line):
                             prefix = f"{file_path}:" if len(files) > 1 else ""
-                            if line_numbers:
-                                match_str = f"{prefix}{i}:{line}"
-                            else:
-                                match_str = f"{prefix}{line}"
-                            
+                            match_str = f"{prefix}{i}:{line}" if line_numbers else f"{prefix}{line}"
+
                             results.append(match_str)
                             total_chars += len(match_str) + 1  # +1 for newline
 

{henchman_ai-0.1.6 → henchman_ai-0.1.7}/src/henchman/tools/builtins/ls.py

@@ -86,24 +86,24 @@ class LsTool(Tool):
             # List directory contents
             entries = []
             truncated = False
-            
+
             # Use iterdir() which returns an iterator
             iterator = target.iterdir()
-            # We can't sort immediately if we want to limit processing, 
+            # We can't sort immediately if we want to limit processing,
             # but for consistent output on small dirs, sorting is better.
             # So we collect up to limit + 1
-            
+
             all_items = []
             try:
                 for _ in range(self.MAX_ITEMS + 1):
                     all_items.append(next(iterator))
             except StopIteration:
                 pass
-                
+
             if len(all_items) > self.MAX_ITEMS:
                 truncated = True
                 all_items = all_items[:self.MAX_ITEMS]
-            
+
             # Sort the collected items
             all_items.sort(key=lambda p: p.name)
 
@@ -117,7 +117,7 @@ class LsTool(Tool):
                     entries.append(f"{item.name}/")
                 else:
                     entries.append(item.name)
-            
+
             if truncated:
                 entries.append(f"... Output truncated (limit reached: {self.MAX_ITEMS} items) ...")
 

{henchman_ai-0.1.6 → henchman_ai-0.1.7}/src/henchman/tools/builtins/shell.py

@@ -114,7 +114,7 @@ class ShellTool(Tool):
                 output_parts.append(stderr_text)
 
             output = "\n".join(output_parts)
-            
+
             # Truncate if too long
             if len(output) > self.MAX_OUTPUT_CHARS:
                 output = output[:self.MAX_OUTPUT_CHARS] + f"\n... (output truncated after {self.MAX_OUTPUT_CHARS} chars)"

{henchman_ai-0.1.6 → henchman_ai-0.1.7}/src/henchman/utils/compaction.py

@@ -68,9 +68,6 @@ class ContextCompactor:
 
     Preserves atomic sequences, especially tool call sequences.
     """
-    
-    # Safety limit for individual message size
-    MAX_MESSAGE_CHARS = 100_000
 
     def __init__(self, max_tokens: int = 8000) -> None:
         """Initialize compactor.
@@ -81,10 +78,10 @@ class ContextCompactor:
         self.max_tokens = max_tokens
 
     def enforce_safety_limits(self, messages: list[Message]) -> list[Message]:
-        """Enforce hard safety limits on individual message content size.
+        """Enforce limits on individual message size using tokens.
         
         This prevents context overflow from individual massive messages
-        that might slip through tool-specific limits.
+        by truncating them to fit within the context window.
         
         Args:
             messages: List of messages to check.
@@ -93,11 +90,33 @@ class ContextCompactor:
             List of messages with content limits enforced.
         """
         safe_messages = []
+        # Reserve tokens for overhead/other messages.
+        # We use 75% of max_tokens to allow for message overhead, system prompts,
+        # and the truncation suffix itself.
+        limit = int(self.max_tokens * 0.75)
+        
         for msg in messages:
-            # Check content length
-            if msg.content and len(msg.content) > self.MAX_MESSAGE_CHARS:
-                # Create a new message with truncated content
-                new_content = msg.content[:self.MAX_MESSAGE_CHARS] + f"\n... (truncated by safety limit: > {self.MAX_MESSAGE_CHARS} chars)"
+            if not msg.content:
+                safe_messages.append(msg)
+                continue
+
+            # Quick character check optimization:
+            # If chars < limit, tokens are definitely < limit (1 token >= 1 char usually)
+            # Actually, 1 token ~ 4 chars. So if chars < limit, it's definitely safe? 
+            # No, if chars < limit, tokens could be anything. 
+            # But if chars < limit (tokens), then tokens < limit is guaranteed since token count <= char count?
+            # Tiktoken: "hello" (5 chars) -> 1 token. " " (1 char) -> 1 token.
+            # Generally token count < char count.
+            # So if len(msg.content) < limit, we are safe.
+            if len(msg.content) < limit:
+                safe_messages.append(msg)
+                continue
+
+            # Check token count
+            if TokenCounter.count_text(msg.content) > limit:
+                # Truncate
+                truncated_content = TokenCounter.truncate_text(msg.content, limit)
+                new_content = truncated_content + f"\n... (truncated by safety limit: > {limit} tokens)"
                 
                 # Create copy with modified content
                 safe_msg = Message(
@@ -111,7 +130,6 @@ class ContextCompactor:
                 safe_messages.append(msg)
         
         return safe_messages
-
     def _group_into_sequences(self, messages: list[Message]) -> list[MessageSequence]:
         """Group messages into atomic sequences that must be kept together.
 
@@ -183,7 +201,7 @@ class ContextCompactor:
         """
         if not messages:  # pragma: no cover
             return []
-            
+
         # First, enforce safety limits on individual messages
         # This prevents massive messages from breaking the token counter or API
         messages = self.enforce_safety_limits(messages)
@@ -461,7 +479,7 @@ async def compact_with_summarization(
         return result
 
     # Identify dropped messages for summarization
-    kept_set = set(id(m) for m in result.messages)
+    kept_set = {id(m) for m in result.messages}
     dropped_messages = [m for m in messages if id(m) not in kept_set]
 
     # Attempt summarization if enabled and we have a provider

{henchman_ai-0.1.6 → henchman_ai-0.1.7}/src/henchman/utils/tokens.py

@@ -110,6 +110,30 @@ class TokenCounter:
         encoding = cls._get_encoding(model)
         return len(encoding.encode(text))
 
+    @classmethod
+    def truncate_text(cls, text: str, max_tokens: int, model: str | None = None) -> str:
+        """Truncate text to a maximum number of tokens.
+
+        Args:
+            text: The text to truncate.
+            max_tokens: Maximum number of tokens allowed.
+            model: Optional model name.
+
+        Returns:
+            The truncated text.
+        """
+        if not text:
+            return ""
+
+        encoding = cls._get_encoding(model)
+        tokens = encoding.encode(text)
+        if len(tokens) <= max_tokens:
+            return text
+        
+        # Decode the truncated tokens
+        # Note: We don't handle partial unicode bytes here as tiktoken handles text -> tokens -> text
+        return encoding.decode(tokens[:max_tokens])
+
     @classmethod
     def count_messages(cls, messages: list[Message], model: str | None = None) -> int:
         """Count tokens in a list of messages.

{henchman_ai-0.1.6 → henchman_ai-0.1.7}/src/henchman/version.py

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

{henchman_ai-0.1.6 → henchman_ai-0.1.7}/tests/e2e/test_context_safety.py

@@ -1,29 +1,27 @@
 
-import asyncio
+
 import pytest
-from pathlib import Path
-import os
-import shutil
 
-from henchman.tools.builtins.shell import ShellTool
+from henchman.providers.base import Message, ToolCall
 from henchman.tools.builtins.glob_tool import GlobTool
+from henchman.tools.builtins.shell import ShellTool
 from henchman.utils.compaction import ContextCompactor
-from henchman.providers.base import Message, ToolCall
+
 
 @pytest.mark.asyncio
 class TestContextSafety:
-    
+
     async def test_shell_tool_truncation(self):
         """Test that ShellTool truncates excessive output."""
         tool = ShellTool()
         limit = tool.MAX_OUTPUT_CHARS
-        
+
         # Create a command that produces massive output
         # Using python -c to generate it
         cmd = f"python3 -c 'print(\"a\" * {limit + 1000})'"
-        
+
         result = await tool.execute(command=cmd)
-        
+
         assert result.success
         assert len(result.content) < limit + 200  # Allow for "truncated" message
         assert "output truncated" in result.content
@@ -33,33 +31,36 @@ class TestContextSafety:
         """Test that GlobTool truncates matching list."""
         tool = GlobTool()
         limit = tool.MAX_MATCHES
-        
+
         # Create more files than the limit
         test_dir = tmp_path / "glob_test"
         test_dir.mkdir()
-        
+
         for i in range(limit + 50):
             (test_dir / f"test_{i}.txt").touch()
-            
+
         result = await tool.execute(pattern="*.txt", path=str(test_dir))
-        
+
         assert result.success
         assert "Output truncated" in result.content
         assert f"limit reached: {limit} matches" in result.content
-        
+
         # Count lines (excluding the truncation message)
         lines = result.content.splitlines()
         # The last line is the truncation message
-        assert len(lines) == limit + 1 
+        assert len(lines) == limit + 1
         assert lines[-1].startswith("... Output truncated")
 
     def test_compactor_safety_limit(self):
         """Test that ContextCompactor enforces limits on individual messages."""
-        compactor = ContextCompactor(max_tokens=100000)
-        limit = compactor.MAX_MESSAGE_CHARS
-        
-        # Create a message exceeding the limit
-        huge_content = "a" * (limit + 5000)
+        # Use token limit large enough to fit overhead but small enough to test truncation
+        limit_tokens = 300
+        compactor = ContextCompactor(max_tokens=limit_tokens)
+        
+        # Limit will be 0.9 * 300 = 270 tokens
+        # Create a message exceeding the limit 
+        # "word " is 1 token. We want > 270 tokens.
+        huge_content = "word " * 500
         messages = [
             Message(role="system", content="System prompt"),
             Message(role="user", content="Here is a huge message:"),
@@ -70,9 +71,11 @@ class TestContextSafety:
         compacted = compactor.compact(messages)
         
         # Check that the huge message was truncated
+        # With max_tokens=300, limit is 270.
+        # Total tokens should be ~290 < 300. So all messages should be kept.
+        assert len(compacted) == 3
         huge_msg = compacted[2]
         assert len(huge_msg.content) < len(huge_content)
-        assert len(huge_msg.content) <= limit + 200 # approximate buffer for truncation msg
         assert "truncated by safety limit" in huge_msg.content
         
         # Check other messages are untouched
@@ -81,12 +84,11 @@ class TestContextSafety:
 
     async def test_compactor_safety_limit_preserves_tool_calls(self):
         """Test that safety limit preserves tool call structure even if content is truncated."""
-        # Use large max_tokens so compaction logic doesn't drop the message purely due to size
-        # We want to test that enforce_safety_limits runs and preserves tool_calls
-        compactor = ContextCompactor(max_tokens=200000)
-        limit = compactor.MAX_MESSAGE_CHARS
+        # Use token limit large enough to fit overhead
+        limit_tokens = 300
+        compactor = ContextCompactor(max_tokens=limit_tokens)
         
-        huge_content = "b" * (limit + 1000)
+        huge_content = "word " * 500
         
         tool_call = ToolCall(id="call_1", name="test_tool", arguments={})
         

{henchman_ai-0.1.6 → henchman_ai-0.1.7}/tests/test_main.py

@@ -21,7 +21,7 @@ def test_main_module_imports() -> None:
             text=True,
         )
         assert result.returncode == 0
-        assert "0.1.6" in result.stdout
+        assert "0.1.7" in result.stdout
 
 def test_python_m_henchman_help() -> None:
     """Test that python -m henchman --help works."""

{henchman_ai-0.1.6 → henchman_ai-0.1.7}/tests/test_version.py

@@ -13,7 +13,7 @@ def test_version_string_format() -> None:
 
 def test_version_tuple() -> None:
     """Test that version tuple matches version string."""
-    assert VERSION_TUPLE == (0, 1, 6)
+    assert VERSION_TUPLE == (0, 1, 7)
     assert ".".join(str(v) for v in VERSION_TUPLE) == VERSION