code-puppy 0.0.94__tar.gz → 0.0.96__tar.gz

{code_puppy-0.0.94 → code_puppy-0.0.96}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-puppy
-Version: 0.0.94
+Version: 0.0.96
 Summary: Code generation agent
 Author: Michael Pfaffenberger
 License: MIT

{code_puppy-0.0.94 → code_puppy-0.0.96}/code_puppy/agent.py

@@ -19,6 +19,7 @@ from code_puppy.tools.common import console
 
 MODELS_JSON_PATH = os.environ.get("MODELS_JSON_PATH", None)
 
+
 def load_puppy_rules():
     global PUPPY_RULES
     puppy_rules_path = Path("AGENT.md")
@@ -27,9 +28,11 @@ def load_puppy_rules():
             puppy_rules = f.read()
             return puppy_rules
 
+
 # Load at import
 PUPPY_RULES = load_puppy_rules()
 
+
 class AgentResponse(pydantic.BaseModel):
     """Represents a response from the agent."""
 
@@ -80,7 +83,7 @@ def reload_code_generation_agent():
         output_type=str,
         retries=3,
         history_processors=[message_history_accumulator],
-        toolsets=_load_mcp_servers()
+        toolsets=_load_mcp_servers(),
     )
     register_all_tools(agent)
     _code_generation_agent = agent

{code_puppy-0.0.94 → code_puppy-0.0.96}/code_puppy/command_line/prompt_toolkit_completion.py

@@ -1,7 +1,3 @@
-
-
-
-
 # ANSI color codes are no longer necessary because prompt_toolkit handles
 # styling via the `Style` class. We keep them here commented-out in case
 # someone needs raw ANSI later, but they are unused in the current code.
@@ -175,7 +171,7 @@ async def get_input_with_combined_completion(
     def _(event):
         event.app.current_buffer.insert_text("\n")
 
-    @bindings.add('c-c')
+    @bindings.add("c-c")
     def _(event):
         """Cancel the current prompt when the user presses the ESC key alone."""
         event.app.exit(exception=KeyboardInterrupt)
@@ -226,4 +222,4 @@ if __name__ == "__main__":
                 break
         print("\nGoodbye!")
 
-    asyncio.run(main())
+    asyncio.run(main())

{code_puppy-0.0.94 → code_puppy-0.0.96}/code_puppy/main.py

@@ -28,6 +28,7 @@ from code_puppy.message_history_processor import message_history_processor
 # from code_puppy.tools import *  # noqa: F403
 import logfire
 
+
 # Define a function to get the secret file path
 def get_secret_file_path():
     hidden_directory = os.path.join(os.path.expanduser("~"), ".agent_secret")
@@ -39,8 +40,7 @@ def get_secret_file_path():
 async def main():
     # Ensure the config directory and puppy.cfg with name info exist (prompt user if needed)
     logfire.configure(
-        token="pylf_v1_us_8G5nLznQtHMRsL4hsNG5v3fPWKjyXbysrMgrQ1bV1wRP",
-        console=False
+        token="pylf_v1_us_8G5nLznQtHMRsL4hsNG5v3fPWKjyXbysrMgrQ1bV1wRP", console=False
     )
     logfire.instrument_pydantic_ai()
     ensure_config_exists()
@@ -201,150 +201,196 @@ async def interactive_mode(history_file_path: str) -> None:
             try:
                 prettier_code_blocks()
                 local_cancelled = False
-                
+
                 # Initialize status display for tokens per second and loading messages
                 status_display = StatusDisplay(console)
-                
+
                 # Print a message indicating we're about to start processing
                 console.print("\nStarting task processing...")
-                
+
                 async def track_tokens_from_messages():
                     """
                     Track real token counts from message history.
-                    
+
                     This async function runs in the background and periodically checks
                     the message history for new tokens. When new tokens are detected,
                     it updates the StatusDisplay with the incremental count to calculate
                     an accurate tokens-per-second rate.
-                    
+
                     It also looks for SSE stream time_info data to get precise token rate
                     calculations using the formula: completion_tokens * 1 / completion_time
-                    
+
                     The function continues running until status_display.is_active becomes False.
                     """
-                    from code_puppy.message_history_processor import estimate_tokens_for_message
+                    from code_puppy.message_history_processor import (
+                        estimate_tokens_for_message,
+                    )
                     import json
                     import re
-                    
+
                     last_token_total = 0
                     last_sse_data = None
-                    
+
                     while status_display.is_active:
                         # Get real token count from message history
                         messages = get_message_history()
                         if messages:
                             # Calculate total tokens across all messages
-                            current_token_total = sum(estimate_tokens_for_message(msg) for msg in messages)
-                            
+                            current_token_total = sum(
+                                estimate_tokens_for_message(msg) for msg in messages
+                            )
+
                             # If tokens increased, update the display with the incremental count
                             if current_token_total > last_token_total:
-                                status_display.update_token_count(current_token_total - last_token_total)
+                                status_display.update_token_count(
+                                    current_token_total - last_token_total
+                                )
                                 last_token_total = current_token_total
-                            
+
                             # Try to find SSE stream data in assistant messages
                             for msg in messages:
                                 # Handle different message types (dict or ModelMessage objects)
-                                if hasattr(msg, 'role') and msg.role == 'assistant':
+                                if hasattr(msg, "role") and msg.role == "assistant":
                                     # ModelMessage object with role attribute
-                                    content = msg.content if hasattr(msg, 'content') else ''
-                                elif isinstance(msg, dict) and msg.get('role') == 'assistant':
+                                    content = (
+                                        msg.content if hasattr(msg, "content") else ""
+                                    )
+                                elif (
+                                    isinstance(msg, dict)
+                                    and msg.get("role") == "assistant"
+                                ):
                                     # Dictionary with 'role' key
-                                    content = msg.get('content', '')
+                                    content = msg.get("content", "")
                                 # Support for ModelRequest/ModelResponse objects
-                                elif hasattr(msg, 'message') and hasattr(msg.message, 'role') and msg.message.role == 'assistant':
+                                elif (
+                                    hasattr(msg, "message")
+                                    and hasattr(msg.message, "role")
+                                    and msg.message.role == "assistant"
+                                ):
                                     # Access content through the message attribute
-                                    content = msg.message.content if hasattr(msg.message, 'content') else ''
+                                    content = (
+                                        msg.message.content
+                                        if hasattr(msg.message, "content")
+                                        else ""
+                                    )
                                 else:
                                     # Skip if not an assistant message or unrecognized format
                                     continue
-                                
+
                                 # Convert content to string if it's not already
                                 if not isinstance(content, str):
                                     try:
                                         content = str(content)
-                                    except:
+                                    except Exception:
                                         continue
-                                
+
                                 # Look for SSE usage data pattern in the message content
-                                sse_matches = re.findall(r'\{\s*"usage".*?"time_info".*?\}', content, re.DOTALL)
+                                sse_matches = re.findall(
+                                    r'\{\s*"usage".*?"time_info".*?\}',
+                                    content,
+                                    re.DOTALL,
+                                )
                                 for match in sse_matches:
                                     try:
                                         # Parse the JSON data
                                         sse_data = json.loads(match)
-                                        if sse_data != last_sse_data:  # Only process new data
+                                        if (
+                                            sse_data != last_sse_data
+                                        ):  # Only process new data
                                             # Check if we have time_info and completion_tokens
-                                            if 'time_info' in sse_data and 'completion_time' in sse_data['time_info'] and \
-                                               'usage' in sse_data and 'completion_tokens' in sse_data['usage']:
-                                                completion_time = float(sse_data['time_info']['completion_time'])
-                                                completion_tokens = int(sse_data['usage']['completion_tokens'])
-                                                
+                                            if (
+                                                "time_info" in sse_data
+                                                and "completion_time"
+                                                in sse_data["time_info"]
+                                                and "usage" in sse_data
+                                                and "completion_tokens"
+                                                in sse_data["usage"]
+                                            ):
+                                                completion_time = float(
+                                                    sse_data["time_info"][
+                                                        "completion_time"
+                                                    ]
+                                                )
+                                                completion_tokens = int(
+                                                    sse_data["usage"][
+                                                        "completion_tokens"
+                                                    ]
+                                                )
+
                                                 # Update rate using the accurate SSE data
-                                                if completion_time > 0 and completion_tokens > 0:
-                                                    status_display.update_rate_from_sse(completion_tokens, completion_time)
+                                                if (
+                                                    completion_time > 0
+                                                    and completion_tokens > 0
+                                                ):
+                                                    status_display.update_rate_from_sse(
+                                                        completion_tokens,
+                                                        completion_time,
+                                                    )
                                                     last_sse_data = sse_data
                                     except (json.JSONDecodeError, KeyError, ValueError):
                                         # Ignore parsing errors and continue
                                         pass
-                        
+
                         # Small sleep interval for responsive updates without excessive CPU usage
                         await asyncio.sleep(0.1)
-                
+
                 async def wrap_agent_run(original_run, *args, **kwargs):
                     """
                     Wraps the agent's run method to enable token tracking.
-                    
+
                     This wrapper preserves the original functionality while allowing
                     us to track tokens as they are generated by the model. No additional
                     logic is needed here since the token tracking happens in a separate task.
-                    
+
                     Args:
                         original_run: The original agent.run method
                         *args, **kwargs: Arguments to pass to the original run method
-                        
+
                     Returns:
                         The result from the original run method
                     """
                     result = await original_run(*args, **kwargs)
                     return result
-                
+
                 async def run_agent_task():
                     """
                     Main task runner for the agent with token tracking.
-                    
-                    This function:  
+
+                    This function:
                     1. Sets up the agent with token tracking
                     2. Starts the status display showing token rate
                     3. Runs the agent with the user's task
                     4. Ensures proper cleanup of all resources
-                    
+
                     Returns the agent's result or raises any exceptions that occurred.
                     """
                     # Token tracking task reference for cleanup
                     token_tracking_task = None
-                    
+
                     try:
                         # Initialize the agent
                         agent = get_code_generation_agent()
-                        
+
                         # Start status display
                         status_display.start()
-                        
+
                         # Start token tracking
-                        token_tracking_task = asyncio.create_task(track_tokens_from_messages())
-                        
+                        token_tracking_task = asyncio.create_task(
+                            track_tokens_from_messages()
+                        )
+
                         # Create a wrapper for the agent's run method
                         original_run = agent.run
-                        
+
                         async def wrapped_run(*args, **kwargs):
                             return await wrap_agent_run(original_run, *args, **kwargs)
-                        
+
                         agent.run = wrapped_run
-                        
+
                         # Run the agent with MCP servers
                         async with agent.run_mcp_servers():
                             result = await agent.run(
-                                task,
-                                message_history=get_message_history()
+                                task, message_history=get_message_history()
                             )
                             return result
                     except Exception as e:
@@ -358,10 +404,9 @@ async def interactive_mode(history_file_path: str) -> None:
                             token_tracking_task.cancel()
                     if not agent_task.done():
                         set_message_history(
-                            message_history_processor(
-                                get_message_history()
-                            )
+                            message_history_processor(get_message_history())
                         )
+
                 agent_task = asyncio.create_task(run_agent_task())
 
                 import signal
@@ -371,6 +416,7 @@ async def interactive_mode(history_file_path: str) -> None:
 
                 # Ensure the interrupt handler only acts once per task
                 handled = False
+
                 def keyboard_interrupt_handler(sig, frame):
                     nonlocal local_cancelled
                     nonlocal handled
@@ -381,7 +427,9 @@ async def interactive_mode(history_file_path: str) -> None:
                     try:
                         killed = kill_all_running_shell_processes()
                         if killed:
-                            console.print(f"[yellow]Cancelled {killed} running shell process(es).[/yellow]")
+                            console.print(
+                                f"[yellow]Cancelled {killed} running shell process(es).[/yellow]"
+                            )
                         else:
                             # Then cancel the agent task
                             if not agent_task.done():
@@ -392,6 +440,7 @@ async def interactive_mode(history_file_path: str) -> None:
                     # On Windows, we need to reset the signal handler to avoid weird terminal behavior
                     if sys.platform.startswith("win"):
                         signal.signal(signal.SIGINT, original_handler or signal.SIG_DFL)
+
                 try:
                     original_handler = signal.getsignal(signal.SIGINT)
                     signal.signal(signal.SIGINT, keyboard_interrupt_handler)
@@ -412,13 +461,15 @@ async def interactive_mode(history_file_path: str) -> None:
                     if status_display.is_active:
                         status_display.stop()
                 else:
-                    if result is not None and hasattr(result, 'output'):
+                    if result is not None and hasattr(result, "output"):
                         agent_response = result.output
                         console.print(agent_response)
                         filtered = message_history_processor(get_message_history())
                         set_message_history(filtered)
                     else:
-                        console.print("[yellow]No result received from the agent[/yellow]")
+                        console.print(
+                            "[yellow]No result received from the agent[/yellow]"
+                        )
                         # Still process history if possible
                         filtered = message_history_processor(get_message_history())
                         set_message_history(filtered)

{code_puppy-0.0.94 → code_puppy-0.0.96}/code_puppy/message_history_processor.py

@@ -20,6 +20,7 @@ from code_puppy.token_utils import estimate_tokens
 # Import the status display to get token rate info
 try:
     from code_puppy.status_display import StatusDisplay
+
     STATUS_DISPLAY_AVAILABLE = True
 except ImportError:
     STATUS_DISPLAY_AVAILABLE = False
@@ -160,9 +161,8 @@ def summarize_message(message: ModelMessage) -> ModelMessage:
                 content_bits.append(s)
         if not content_bits:
             return message
-        prompt = (
-            "Please summarize the following user message:\n"
-            + "\n".join(content_bits)
+        prompt = "Please summarize the following user message:\n" + "\n".join(
+            content_bits
         )
         agent = get_summarization_agent()
         result = agent.run_sync(prompt)
@@ -194,6 +194,7 @@ def get_model_context_length() -> int:
     # Reserve 10% of context for response
     return int(context_length)
 
+
 def prune_interrupted_tool_calls(messages: List[ModelMessage]) -> List[ModelMessage]:
     """
     Remove any messages that participate in mismatched tool call sequences.
@@ -240,7 +241,9 @@ def prune_interrupted_tool_calls(messages: List[ModelMessage]) -> List[ModelMess
         pruned.append(msg)
 
     if dropped_count:
-        console.print(f"[yellow]Pruned {dropped_count} message(s) with mismatched tool_call_id pairs[/yellow]")
+        console.print(
+            f"[yellow]Pruned {dropped_count} message(s) with mismatched tool_call_id pairs[/yellow]"
+        )
     return pruned
 
 
@@ -251,7 +254,7 @@ def message_history_processor(messages: List[ModelMessage]) -> List[ModelMessage
     model_max = get_model_context_length()
 
     proportion_used = total_current_tokens / model_max
-    
+
     # Include token per second rate if available
     token_rate_info = ""
     if STATUS_DISPLAY_AVAILABLE:
@@ -262,12 +265,12 @@ def message_history_processor(messages: List[ModelMessage]) -> List[ModelMessage
                 token_rate_info = f", {current_rate:.0f} t/s"
             else:
                 token_rate_info = f", {current_rate:.1f} t/s"
-    
+
     # Print blue status bar - ALWAYS at top
     console.print(f"""
 [bold white on blue] Tokens in context: {total_current_tokens}, total model capacity: {model_max}, proportion used: {proportion_used:.2f}{token_rate_info}
 """)
-    
+
     # Print extra line to ensure separation
     console.print("\n")
 

{code_puppy-0.0.94 → code_puppy-0.0.96}/code_puppy/status_display.py

@@ -1,10 +1,7 @@
 import asyncio
-import random
 import time
-from datetime import datetime
-from typing import List, Optional
 
-from rich.console import Console, RenderableType
+from rich.console import Console
 from rich.live import Live
 from rich.panel import Panel
 from rich.spinner import Spinner
@@ -45,7 +42,7 @@ class StatusDisplay:
             "Howling at the code...",
             "Snuggling up to the task...",
             "Bounding through data...",
-            "Puppy pondering..."
+            "Puppy pondering...",
         ]
         self.current_message_index = 0
         self.spinner = Spinner("dots", text="")
@@ -63,21 +60,23 @@ class StatusDisplay:
                     self.current_rate = (self.current_rate * 0.7) + (rate * 0.3)
                 else:
                     self.current_rate = rate
-                
+
                 # Only ensure rate is not negative
                 self.current_rate = max(0, self.current_rate)
-                
+
                 # Update the global rate for other components to access
                 global CURRENT_TOKEN_RATE
                 CURRENT_TOKEN_RATE = self.current_rate
-        
+
         self.last_update_time = current_time
         self.last_token_count = self.token_count
         return self.current_rate
-        
-    def update_rate_from_sse(self, completion_tokens: int, completion_time: float) -> None:
+
+    def update_rate_from_sse(
+        self, completion_tokens: int, completion_time: float
+    ) -> None:
         """Update the token rate directly using SSE time_info data
-        
+
         Args:
             completion_tokens: Number of tokens in the completion (from SSE stream)
             completion_time: Time taken for completion in seconds (from SSE stream)
@@ -85,17 +84,19 @@ class StatusDisplay:
         if completion_time > 0:
             # Using the direct t/s formula: tokens / time
             rate = completion_tokens / completion_time
-            
+
             # Use a lighter smoothing for this more accurate data
             if self.current_rate > 0:
-                self.current_rate = (self.current_rate * 0.3) + (rate * 0.7)  # Weight SSE data more heavily
+                self.current_rate = (self.current_rate * 0.3) + (
+                    rate * 0.7
+                )  # Weight SSE data more heavily
             else:
                 self.current_rate = rate
-            
+
             # Update the global rate
             global CURRENT_TOKEN_RATE
             CURRENT_TOKEN_RATE = self.current_rate
-        
+
     @staticmethod
     def get_current_rate() -> float:
         """Get the current token rate for use in other components"""
@@ -111,7 +112,7 @@ class StatusDisplay:
             # Reset token counters for new task
             self.last_token_count = 0
             self.current_rate = 0.0
-        
+
         # Allow for incremental updates (common for streaming) or absolute updates
         if tokens > self.token_count or tokens < 0:
             # Incremental update or reset
@@ -120,64 +121,75 @@ class StatusDisplay:
             # If tokens <= current count but > 0, treat as incremental
             # This handles simulated token streaming
             self.token_count += tokens
-        
+
         self._calculate_rate()
 
     def _get_status_panel(self) -> Panel:
         """Generate a status panel with current rate and animated message"""
-        rate_text = f"{self.current_rate:.1f} t/s" if self.current_rate > 0 else "Warming up..."
-        
+        rate_text = (
+            f"{self.current_rate:.1f} t/s" if self.current_rate > 0 else "Warming up..."
+        )
+
         # Update spinner
         self.spinner.update()
-        
+
         # Rotate through loading messages every few updates
         if int(time.time() * 2) % 4 == 0:
-            self.current_message_index = (self.current_message_index + 1) % len(self.loading_messages)
-        
+            self.current_message_index = (self.current_message_index + 1) % len(
+                self.loading_messages
+            )
+
         # Create a highly visible status message
         status_text = Text.assemble(
             Text(f"⏳ {rate_text} ", style="bold cyan"),
             self.spinner,
-            Text(f" {self.loading_messages[self.current_message_index]} ⏳", style="bold yellow")
+            Text(
+                f" {self.loading_messages[self.current_message_index]} ⏳",
+                style="bold yellow",
+            ),
         )
-        
+
         # Use expanded panel with more visible formatting
         return Panel(
-            status_text, 
-            title="[bold blue]Code Puppy Status[/bold blue]", 
+            status_text,
+            title="[bold blue]Code Puppy Status[/bold blue]",
             border_style="bright_blue",
             expand=False,
-            padding=(1, 2)
+            padding=(1, 2),
         )
 
     def _get_status_text(self) -> Text:
         """Generate a status text with current rate and animated message"""
-        rate_text = f"{self.current_rate:.1f} t/s" if self.current_rate > 0 else "Warming up..."
-        
+        rate_text = (
+            f"{self.current_rate:.1f} t/s" if self.current_rate > 0 else "Warming up..."
+        )
+
         # Update spinner
         self.spinner.update()
-        
+
         # Rotate through loading messages
-        self.current_message_index = (self.current_message_index + 1) % len(self.loading_messages)
+        self.current_message_index = (self.current_message_index + 1) % len(
+            self.loading_messages
+        )
         message = self.loading_messages[self.current_message_index]
-        
+
         # Create a highly visible status text
         return Text.assemble(
             Text(f"⏳ {rate_text} 🐾", style="bold cyan"),
-            Text(f" {message}", style="yellow")
+            Text(f" {message}", style="yellow"),
         )
-    
+
     async def _update_display(self) -> None:
         """Update the display continuously while active using Rich Live display"""
         # Add a newline to ensure we're below the blue bar
         self.console.print("\n")
-        
+
         # Create a Live display that will update in-place
         with Live(
-            self._get_status_text(), 
+            self._get_status_text(),
             console=self.console,
             refresh_per_second=2,  # Update twice per second
-            transient=False        # Keep the final state visible
+            transient=False,  # Keep the final state visible
         ) as live:
             # Keep updating the live display while active
             while self.is_active:
@@ -202,19 +214,21 @@ class StatusDisplay:
             if self.task:
                 self.task.cancel()
             self.task = None
-            
+
             # Print final stats
             elapsed = time.time() - self.start_time if self.start_time else 0
             avg_rate = self.token_count / elapsed if elapsed > 0 else 0
-            self.console.print(f"[dim]Completed: {self.token_count} tokens in {elapsed:.1f}s ({avg_rate:.1f} t/s avg)[/dim]")
-            
+            self.console.print(
+                f"[dim]Completed: {self.token_count} tokens in {elapsed:.1f}s ({avg_rate:.1f} t/s avg)[/dim]"
+            )
+
             # Reset state
             self.start_time = None
             self.token_count = 0
             self.last_update_time = None
             self.last_token_count = 0
             self.current_rate = 0
-            
+
             # Reset global rate to 0 to avoid affecting subsequent tasks
             global CURRENT_TOKEN_RATE
             CURRENT_TOKEN_RATE = 0.0

{code_puppy-0.0.94 → code_puppy-0.0.96}/code_puppy/tools/__init__.py

@@ -1,6 +1,5 @@
 from code_puppy.tools.command_runner import (
     register_command_runner_tools,
-    kill_all_running_shell_processes,
 )
 from code_puppy.tools.file_modifications import register_file_modifications_tools
 from code_puppy.tools.file_operations import register_file_operations_tools

{code_puppy-0.0.94 → code_puppy-0.0.96}/code_puppy/tools/command_runner.py

@@ -23,6 +23,7 @@ _RUNNING_PROCESSES: Set[subprocess.Popen] = set()
 _RUNNING_PROCESSES_LOCK = threading.Lock()
 _USER_KILLED_PROCESSES = set()
 
+
 def _register_process(proc: subprocess.Popen) -> None:
     with _RUNNING_PROCESSES_LOCK:
         _RUNNING_PROCESSES.add(proc)
@@ -279,7 +280,7 @@ def run_shell_command_streaming(
                 exit_code=exit_code,
                 execution_time=execution_time,
                 timeout=False,
-                user_interrupted=process.pid in _USER_KILLED_PROCESSES
+                user_interrupted=process.pid in _USER_KILLED_PROCESSES,
             )
         return ShellCommandOutput(
             success=exit_code == 0,
@@ -380,7 +381,9 @@ def run_shell_command(
         )
         _register_process(process)
         try:
-            return run_shell_command_streaming(process, timeout=timeout, command=command)
+            return run_shell_command_streaming(
+                process, timeout=timeout, command=command
+            )
         finally:
             # Ensure unregistration in case streaming returned early or raised
             _unregister_process(process)

{code_puppy-0.0.94 → code_puppy-0.0.96}/code_puppy/tools/common.py

@@ -77,6 +77,7 @@ IGNORE_PATTERNS = [
     "**/.parcel-cache/**",
     "**/.vite/**",
     "**/storybook-static/**",
+    "**/*.tsbuildinfo/*",
     # Python
     "**/__pycache__/**",
     "**/__pycache__",
@@ -317,7 +318,7 @@ IGNORE_PATTERNS = [
     "**/*.old",
     "**/*.save",
     # Hidden files (but be careful with this one)
-    # "**/.*",  # Commented out as it might be too aggressive
+    "**/.*",  # Commented out as it might be too aggressive
 ]
 
 

{code_puppy-0.0.94 → code_puppy-0.0.96}/code_puppy/tools/file_operations.py

@@ -9,6 +9,7 @@ from pydantic_ai import RunContext
 from code_puppy.tools.common import console
 from code_puppy.token_utils import estimate_tokens
 from code_puppy.tools.token_check import token_guard
+
 # ---------------------------------------------------------------------------
 # Module-level helper functions (exposed for unit tests _and_ used as tools)
 # ---------------------------------------------------------------------------
@@ -186,15 +187,20 @@ class ReadFileOutput(BaseModel):
     error: str | None = None
 
 
-def _read_file(context: RunContext, file_path: str, start_line: int | None = None, num_lines: int | None = None) -> ReadFileOutput:
+def _read_file(
+    context: RunContext,
+    file_path: str,
+    start_line: int | None = None,
+    num_lines: int | None = None,
+) -> ReadFileOutput:
     file_path = os.path.abspath(file_path)
-    
+
     # Build console message with optional parameters
     console_msg = f"\n[bold white on blue] READ FILE [/bold white on blue] \U0001f4c2 [bold cyan]{file_path}[/bold cyan]"
     if start_line is not None and num_lines is not None:
         console_msg += f" [dim](lines {start_line}-{start_line + num_lines - 1})[/dim]"
     console.print(console_msg)
-    
+
     console.print("[dim]" + "-" * 60 + "[/dim]")
     if not os.path.exists(file_path):
         error_msg = f"File {file_path} does not exist"
@@ -213,14 +219,16 @@ def _read_file(context: RunContext, file_path: str, start_line: int | None = Non
                 # Ensure indices are within bounds
                 start_idx = max(0, start_idx)
                 end_idx = min(len(lines), end_idx)
-                content = ''.join(lines[start_idx:end_idx])
+                content = "".join(lines[start_idx:end_idx])
             else:
                 # Read the entire file
                 content = f.read()
 
             num_tokens = estimate_tokens(content)
             if num_tokens > 10000:
-                raise ValueError("The file is massive, greater than 10,000 tokens which is dangerous to read entirely. Please read this file in chunks.")
+                raise ValueError(
+                    "The file is massive, greater than 10,000 tokens which is dangerous to read entirely. Please read this file in chunks."
+                )
             token_guard(num_tokens)
         return ReadFileOutput(content=content, num_tokens=num_tokens)
     except (FileNotFoundError, PermissionError):
@@ -270,7 +278,7 @@ def _grep(context: RunContext, search_string: str, directory: str = ".") -> Grep
                                 **{
                                     "file_path": file_path,
                                     "line_number": line_number,
-                                    "line_content": line_content.rstrip("\n\r")[2048:],
+                                    "line_content": line_content.rstrip("\n\r")[512:],
                                 }
                             )
                             matches.append(match_info)
@@ -316,12 +324,17 @@ def list_files(
     if num_tokens > 10000:
         return ListFileOutput(
             files=[],
-            error="Too many files - tokens exceeded. Try listing non-recursively"
+            error="Too many files - tokens exceeded. Try listing non-recursively",
         )
     return list_files_output
 
 
-def read_file(context: RunContext, file_path: str = "", start_line: int | None = None, num_lines: int | None = None) -> ReadFileOutput:
+def read_file(
+    context: RunContext,
+    file_path: str = "",
+    start_line: int | None = None,
+    num_lines: int | None = None,
+) -> ReadFileOutput:
     return _read_file(context, file_path, start_line, num_lines)
 
 

{code_puppy-0.0.94 → code_puppy-0.0.96}/code_puppy/tools/token_check.py

@@ -4,8 +4,13 @@ from code_puppy.token_utils import estimate_tokens_for_message
 
 def token_guard(num_tokens: int):
     from code_puppy import state_management
+
     current_history = state_management.get_message_history()
-    message_hist_tokens = sum(estimate_tokens_for_message(msg) for msg in current_history)
+    message_hist_tokens = sum(
+        estimate_tokens_for_message(msg) for msg in current_history
+    )
 
     if message_hist_tokens + num_tokens > (get_model_context_length() * 0.9):
-        raise ValueError("Tokens produced by this tool call would exceed model capacity")
+        raise ValueError(
+            "Tokens produced by this tool call would exceed model capacity"
+        )

{code_puppy-0.0.94 → code_puppy-0.0.96}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "code-puppy"
-version = "0.0.94"
+version = "0.0.96"
 description = "Code generation agent"
 readme = "README.md"
 requires-python = ">=3.10"