code-puppy 0.0.83__tar.gz → 0.0.85__tar.gz

{code_puppy-0.0.83 → code_puppy-0.0.85}/PKG-INFO

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

{code_puppy-0.0.83 → code_puppy-0.0.85}/code_puppy/__init__.py

@@ -1,5 +1,6 @@
 try:
     import importlib.metadata
+
     __version__ = importlib.metadata.version("code-puppy")
 except importlib.metadata.PackageNotFoundError:
     __version__ = "0.0.1"

{code_puppy-0.0.83 → code_puppy-0.0.85}/code_puppy/agent.py

@@ -7,7 +7,6 @@ from pydantic_ai.mcp import MCPServerSSE
 
 from code_puppy.agent_prompts import get_system_prompt
 from code_puppy.model_factory import ModelFactory
-from code_puppy.session_memory import SessionMemory
 from code_puppy.state_management import message_history_accumulator
 from code_puppy.tools import register_all_tools
 from code_puppy.tools.common import console
@@ -20,24 +19,16 @@ from code_puppy.tools.common import console
 
 MODELS_JSON_PATH = os.environ.get("MODELS_JSON_PATH", None)
 
-# Puppy rules loader
-PUPPY_RULES_PATH = Path("AGENT.md")
-PUPPY_RULES = None
-
-
-def load_puppy_rules(path=None):
+def load_puppy_rules():
     global PUPPY_RULES
-    rules_path = Path(path) if path else PUPPY_RULES_PATH
-    if rules_path.exists():
-        with open(rules_path, "r") as f:
-            PUPPY_RULES = f.read()
-    else:
-        PUPPY_RULES = None
-
+    puppy_rules_path = Path("AGENT.md")
+    if puppy_rules_path.exists():
+        with open(puppy_rules_path, "r") as f:
+            puppy_rules = f.read()
+            return puppy_rules
 
 # Load at import
-load_puppy_rules()
-
+PUPPY_RULES = load_puppy_rules()
 
 class AgentResponse(pydantic.BaseModel):
     """Represents a response from the agent."""
@@ -50,20 +41,7 @@ class AgentResponse(pydantic.BaseModel):
     )
 
 
-# --- NEW DYNAMIC AGENT LOGIC ---
-_LAST_MODEL_NAME = None
 _code_generation_agent = None
-_session_memory = None
-
-
-def session_memory():
-    """
-    Returns a singleton SessionMemory instance to allow agent and tools to persist and recall context/history.
-    """
-    global _session_memory
-    if _session_memory is None:
-        _session_memory = SessionMemory()
-    return _session_memory
 
 
 def _load_mcp_servers():
@@ -101,16 +79,11 @@ def reload_code_generation_agent():
         instructions=instructions,
         output_type=str,
         retries=3,
-        history_processors=[message_history_accumulator]
+        history_processors=[message_history_accumulator],
     )
     register_all_tools(agent)
     _code_generation_agent = agent
     _LAST_MODEL_NAME = model_name
-    # NEW: Log session event
-    try:
-        session_memory().log_task(f"Agent loaded with model: {model_name}")
-    except Exception:
-        pass
     return _code_generation_agent
 
 

{code_puppy-0.0.83 → code_puppy-0.0.85}/code_puppy/agent_prompts.py

@@ -101,9 +101,7 @@ Important rules:
 
 Your solutions should be production-ready, maintainable, and follow best practices for the chosen language.
 
-Return your final response as a structured output having the following fields:
- * output_message: The final output message to display to the user
- * awaiting_user_input: True if user input is needed to continue the task. If you get an error, you might consider asking the user for help.
+Return your final response as a string output
 """
 
 

{code_puppy-0.0.83 → code_puppy-0.0.85}/code_puppy/command_line/motd.py

@@ -48,4 +48,4 @@ def print_motd(console, force: bool = False) -> bool:
         console.print(MOTD_MESSAGE)
         mark_motd_seen(MOTD_VERSION)
         return True
-    return False
+    return False

{code_puppy-0.0.83 → code_puppy-0.0.85}/code_puppy/main.py

@@ -10,7 +10,7 @@ from rich.syntax import Syntax
 from rich.text import Text
 
 from code_puppy import __version__, state_management
-from code_puppy.agent import get_code_generation_agent, session_memory
+from code_puppy.agent import get_code_generation_agent
 from code_puppy.command_line.prompt_toolkit_completion import (
     get_input_with_combined_completion,
     get_prompt_with_active_model,
@@ -21,7 +21,8 @@ from code_puppy.state_management import get_message_history, set_message_history
 # Initialize rich console for pretty output
 from code_puppy.tools.common import console
 from code_puppy.version_checker import fetch_latest_version
-from code_puppy.message_history_processor import message_history_processor
+from code_puppy.message_history_processor import message_history_processor, prune_interrupted_tool_calls
+
 
 # from code_puppy.tools import *  # noqa: F403
 
@@ -193,13 +194,13 @@ async def interactive_mode(history_file_path: str) -> None:
             try:
                 prettier_code_blocks()
                 local_cancelled = False
+
                 async def run_agent_task():
                     try:
                         agent = get_code_generation_agent()
                         async with agent.run_mcp_servers():
                             return await agent.run(
-                                task,
-                                message_history=get_message_history()
+                                task, message_history=get_message_history()
                             )
                     except Exception as e:
                         console.log("Task failed", e)
@@ -207,20 +208,30 @@ async def interactive_mode(history_file_path: str) -> None:
                 agent_task = asyncio.create_task(run_agent_task())
 
                 import signal
+                from code_puppy.tools import kill_all_running_shell_processes
 
                 original_handler = None
 
+                # Ensure the interrupt handler only acts once per task
+                handled = False
                 def keyboard_interrupt_handler(sig, frame):
                     nonlocal local_cancelled
-                    if not agent_task.done():
-                        set_message_history(
-                            message_history_processor(
-                                get_message_history()
-                            )
-                        )
-                        agent_task.cancel()
-                        local_cancelled = True
-
+                    nonlocal handled
+                    if handled:
+                        return
+                    handled = True
+                    # First, nuke any running shell processes triggered by tools
+                    try:
+                        killed = kill_all_running_shell_processes()
+                        if killed:
+                            console.print(f"[yellow]Cancelled {killed} running shell process(es).[/yellow]")
+                        else:
+                            # Then cancel the agent task
+                            if not agent_task.done():
+                                agent_task.cancel()
+                                local_cancelled = True
+                    except Exception as e:
+                        console.print(f"[dim]Shell kill error: {e}[/dim]")
                 try:
                     original_handler = signal.getsignal(signal.SIGINT)
                     signal.signal(signal.SIGINT, keyboard_interrupt_handler)

{code_puppy-0.0.83 → code_puppy-0.0.85}/code_puppy/message_history_processor.py

@@ -1,30 +1,40 @@
 import json
-import queue
-from typing import List
+from typing import List, Set
 import os
 from pathlib import Path
 
 import pydantic
 import tiktoken
-from pydantic_ai.messages import ModelMessage, ToolCallPart, ToolReturnPart, UserPromptPart, TextPart, ModelRequest, ModelResponse
+from pydantic_ai.messages import (
+    ModelMessage,
+    TextPart,
+    ModelResponse,
+    ModelRequest,
+    ToolCallPart,
+)
 
-from code_puppy.config import get_message_history_limit
 from code_puppy.tools.common import console
 from code_puppy.model_factory import ModelFactory
 from code_puppy.config import get_model_name
 
 # Import summarization agent
 try:
-    from code_puppy.summarization_agent import get_summarization_agent as _get_summarization_agent
+    from code_puppy.summarization_agent import (
+        get_summarization_agent as _get_summarization_agent,
+    )
+
     SUMMARIZATION_AVAILABLE = True
-    
+
     # Make the function available in this module's namespace for mocking
     def get_summarization_agent():
         return _get_summarization_agent()
-        
+
 except ImportError:
     SUMMARIZATION_AVAILABLE = False
-    console.print("[yellow]Warning: Summarization agent not available. Message history will be truncated instead of summarized.[/yellow]")
+    console.print(
+        "[yellow]Warning: Summarization agent not available. Message history will be truncated instead of summarized.[/yellow]"
+    )
+
     def get_summarization_agent():
         return None
 
@@ -40,10 +50,10 @@ def get_tokenizer_for_model(model_name: str):
 def stringify_message_part(part) -> str:
     """
     Convert a message part to a string representation for token estimation or other uses.
-    
+
     Args:
         part: A message part that may contain content or be a tool call
-        
+
     Returns:
         String representation of the message part
     """
@@ -54,7 +64,7 @@ def stringify_message_part(part) -> str:
         result += str(type(part)) + ": "
 
     # Handle content
-    if hasattr(part, 'content') and part.content:
+    if hasattr(part, "content") and part.content:
         # Handle different content types
         if isinstance(part.content, str):
             result = part.content
@@ -64,16 +74,16 @@ def stringify_message_part(part) -> str:
             result = json.dumps(part.content)
         else:
             result = str(part.content)
-    
+
     # Handle tool calls which may have additional token costs
     # If part also has content, we'll process tool calls separately
-    if hasattr(part, 'tool_name') and part.tool_name:
+    if hasattr(part, "tool_name") and part.tool_name:
         # Estimate tokens for tool name and parameters
         tool_text = part.tool_name
         if hasattr(part, "args"):
             tool_text += f" {str(part.args)}"
         result += tool_text
-            
+
     return result
 
 
@@ -84,27 +94,22 @@ def estimate_tokens_for_message(message: ModelMessage) -> int:
     """
     tokenizer = get_tokenizer_for_model(get_model_name())
     total_tokens = 0
-    
+
     for part in message.parts:
         part_str = stringify_message_part(part)
         if part_str:
             tokens = tokenizer.encode(part_str)
             total_tokens += len(tokens)
-            
+
     return max(1, total_tokens)
 
 
 def summarize_messages(messages: List[ModelMessage]) -> ModelMessage:
-
-    # Get the summarization agent
     summarization_agent = get_summarization_agent()
-    message_strings = []
-
+    message_strings: List[str] = []
     for message in messages:
         for part in message.parts:
             message_strings.append(stringify_message_part(part))
-
-
     summary_string = "\n".join(message_strings)
     instructions = (
         "Above I've given you a log of Agentic AI steps that have been taken"
@@ -116,19 +121,53 @@ def summarize_messages(messages: List[ModelMessage]) -> ModelMessage:
         "\n Make sure your result is a bulleted list of all steps and interactions."
     )
     try:
-        # Run the summarization agent
         result = summarization_agent.run_sync(f"{summary_string}\n{instructions}")
-        
-        # Create a new message with the summarized content
-        summarized_parts = [TextPart(result.output)]
-        summarized_message = ModelResponse(parts=summarized_parts)
-        return summarized_message
+        return ModelResponse(parts=[TextPart(result.output)])
     except Exception as e:
         console.print(f"Summarization failed during compaction: {e}")
-        # Return original message if summarization fails
         return None
 
 
+# New: single-message summarization helper used by tests
+# - If the message has a ToolCallPart, return original message (no summarization)
+# - If the message has system/instructions, return original message
+# - Otherwise, summarize and return a new ModelRequest with the summarized content
+# - On any error, return the original message
+
+
+def summarize_message(message: ModelMessage) -> ModelMessage:
+    if not SUMMARIZATION_AVAILABLE:
+        return message
+    try:
+        # If the message looks like a system/instructions message, skip summarization
+        instructions = getattr(message, "instructions", None)
+        if instructions:
+            return message
+        # If any part is a tool call, skip summarization
+        for part in message.parts:
+            if isinstance(part, ToolCallPart) or getattr(part, "tool_name", None):
+                return message
+        # Build prompt from textual content parts
+        content_bits: List[str] = []
+        for part in message.parts:
+            s = stringify_message_part(part)
+            if s:
+                content_bits.append(s)
+        if not content_bits:
+            return message
+        prompt = (
+            "Please summarize the following user message:\n"
+            + "\n".join(content_bits)
+        )
+        agent = get_summarization_agent()
+        result = agent.run_sync(prompt)
+        summarized = ModelRequest([TextPart(result.output)])
+        return summarized
+    except Exception as e:
+        console.print(f"Summarization failed: {e}")
+        return message
+
+
 def get_model_context_length() -> int:
     """
     Get the context length for the currently configured model from models.json
@@ -139,31 +178,84 @@ def get_model_context_length() -> int:
         models_path = Path(__file__).parent / "models.json"
     else:
         models_path = Path(models_path)
-    
+
     model_configs = ModelFactory.load_config(str(models_path))
     model_name = get_model_name()
-    
+
     # Get context length from model config
     model_config = model_configs.get(model_name, {})
     context_length = model_config.get("context_length", 128000)  # Default value
-    
+
     # 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.
+
+    A mismatched tool call id is one that appears in a ToolCall (model/tool request)
+    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
 
-def message_history_processor(messages: List[ModelMessage]) -> List[ModelMessage]:
+    tool_call_ids: Set[str] = set()
+    tool_return_ids: Set[str] = set()
+
+    # 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)
+            if not tool_call_id:
+                continue
+            # 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_ids.add(tool_call_id)
+            else:
+                tool_return_ids.add(tool_call_id)
+
+    mismatched: Set[str] = tool_call_ids.symmetric_difference(tool_return_ids)
+    if not mismatched:
+        return messages
 
+    pruned: List[ModelMessage] = []
+    dropped_count = 0
+    for msg in messages:
+        has_mismatched = False
+        for part in getattr(msg, "parts", []) or []:
+            tcid = getattr(part, "tool_call_id", None)
+            if tcid and tcid in mismatched:
+                has_mismatched = True
+                break
+        if has_mismatched:
+            dropped_count += 1
+            continue
+        pruned.append(msg)
+
+    if dropped_count:
+        console.print(f"[yellow]Pruned {dropped_count} message(s) with mismatched tool_call_id pairs[/yellow]")
+    return pruned
+
+
+def message_history_processor(messages: List[ModelMessage]) -> List[ModelMessage]:
+    # 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()
 
     proportion_used = total_current_tokens / model_max
-    console.print(f"[bold white on blue] Tokens in context: {total_current_tokens}, total model capacity: {model_max}, proportion used: {proportion_used}")
+    console.print(f"""
+[bold white on blue] Tokens in context: {total_current_tokens}, total model capacity: {model_max}, proportion used: {proportion_used}
+""")
 
     if proportion_used > 0.9:
         summary = summarize_messages(messages)
         result_messages = [messages[0], summary]
-        final_token_count = sum(estimate_tokens_for_message(msg) for msg in result_messages)
+        final_token_count = sum(
+            estimate_tokens_for_message(msg) for msg in result_messages
+        )
         console.print(f"Final token count after processing: {final_token_count}")
         return result_messages
-    return messages
+    return messages

{code_puppy-0.0.83 → code_puppy-0.0.85}/code_puppy/model_factory.py

@@ -42,15 +42,17 @@ def build_httpx_proxy(proxy):
     """Build an httpx.Proxy object from a proxy string in format ip:port:username:password"""
     proxy_tokens = proxy.split(":")
     if len(proxy_tokens) != 4:
-        raise ValueError(f"Invalid proxy format: {proxy}. Expected format: ip:port:username:password")
-    
+        raise ValueError(
+            f"Invalid proxy format: {proxy}. Expected format: ip:port:username:password"
+        )
+
     ip, port, username, password = proxy_tokens
     proxy_url = f"http://{ip}:{port}"
     proxy_auth = (username, password)
-    
+
     # Log the proxy being used
     console.log(f"Using proxy: {proxy_url} with username: {username}")
-    
+
     return httpx.Proxy(url=proxy_url, auth=proxy_auth)
 
 
@@ -58,18 +60,22 @@ def get_random_proxy_from_file(file_path):
     """Reads proxy file and returns a random proxy formatted for httpx.AsyncClient"""
     if not os.path.exists(file_path):
         raise ValueError(f"Proxy file '{file_path}' not found.")
-    
+
     with open(file_path, "r") as f:
         proxies = [line.strip() for line in f.readlines() if line.strip()]
-    
+
     if not proxies:
-        raise ValueError(f"Proxy file '{file_path}' is empty or contains only whitespace.")
-    
+        raise ValueError(
+            f"Proxy file '{file_path}' is empty or contains only whitespace."
+        )
+
     selected_proxy = random.choice(proxies)
     try:
         return build_httpx_proxy(selected_proxy)
-    except ValueError as e:
-        console.log(f"Warning: Malformed proxy '{selected_proxy}' found in file '{file_path}', ignoring and continuing without proxy.")
+    except ValueError:
+        console.log(
+            f"Warning: Malformed proxy '{selected_proxy}' found in file '{file_path}', ignoring and continuing without proxy."
+        )
         return None
 
 
@@ -147,13 +153,13 @@ class ModelFactory:
 
         elif model_type == "custom_anthropic":
             url, headers, ca_certs_path, api_key = get_custom_config(model_config)
-            
+
             # Check for proxy configuration
             proxy_file_path = os.environ.get("CODE_PUPPY_PROXIES")
             proxy = None
             if proxy_file_path:
                 proxy = get_random_proxy_from_file(proxy_file_path)
-            
+
             # Only pass proxy to client if it's valid
             client_args = {"headers": headers, "verify": ca_certs_path}
             if proxy is not None:
@@ -223,13 +229,13 @@ class ModelFactory:
 
         elif model_type == "custom_openai":
             url, headers, ca_certs_path, api_key = get_custom_config(model_config)
-            
+
             # Check for proxy configuration
             proxy_file_path = os.environ.get("CODE_PUPPY_PROXIES")
             proxy = None
             if proxy_file_path:
                 proxy = get_random_proxy_from_file(proxy_file_path)
-            
+
             # Only pass proxy to client if it's valid
             client_args = {"headers": headers, "verify": ca_certs_path}
             if proxy is not None:

{code_puppy-0.0.83 → code_puppy-0.0.85}/code_puppy/state_management.py

@@ -1,24 +1,28 @@
 from typing import Any, List
 
-from code_puppy.tools.common import console
 from code_puppy.message_history_processor import message_history_processor
 
 _message_history: List[Any] = []
 
+
 def get_message_history() -> List[Any]:
     return _message_history
 
+
 def set_message_history(history: List[Any]) -> None:
     global _message_history
     _message_history = history
 
+
 def clear_message_history() -> None:
     global _message_history
     _message_history = []
 
+
 def append_to_message_history(message: Any) -> None:
     _message_history.append(message)
 
+
 def extend_message_history(history: List[Any]) -> None:
     _message_history.extend(history)
 
@@ -37,18 +41,18 @@ def hash_message(message):
 
 def message_history_accumulator(messages: List[Any]):
     global _message_history
-    
+
     message_history_hashes = set([hash_message(m) for m in _message_history])
     for msg in messages:
         if hash_message(msg) not in message_history_hashes:
             _message_history.append(msg)
-    
+
     # Apply message history trimming using the main processor
     # This ensures we maintain global state while still managing context limits
     trimmed_messages = message_history_processor(_message_history)
-    
+
     # Update our global state with the trimmed version
     # This preserves the state but keeps us within token limits
     _message_history = trimmed_messages
-    
+
     return _message_history

{code_puppy-0.0.83 → code_puppy-0.0.85}/code_puppy/summarization_agent.py

@@ -1,9 +1,7 @@
 import os
 from pathlib import Path
 
-import pydantic
 from pydantic_ai import Agent
-from pydantic_ai.mcp import MCPServerSSE
 
 from code_puppy.model_factory import ModelFactory
 from code_puppy.tools.common import console
@@ -33,7 +31,7 @@ def reload_summarization_agent():
         else Path(__file__).parent / "models.json"
     )
     model = ModelFactory.get_model(model_name, ModelFactory.load_config(models_path))
-    
+
     # Specialized instructions for summarization
     instructions = """You are a message summarization expert. Your task is to summarize conversation messages 
 while preserving important context and information. The summaries should be concise but capture the essential 
@@ -51,7 +49,7 @@ When summarizing:
         model=model,
         instructions=instructions,
         output_type=str,
-        retries=1  # Fewer retries for summarization
+        retries=1,  # Fewer retries for summarization
     )
     _summarization_agent = agent
     _LAST_MODEL_NAME = model_name

{code_puppy-0.0.83 → code_puppy-0.0.85}/code_puppy/tools/__init__.py

@@ -1,4 +1,7 @@
-from code_puppy.tools.command_runner import register_command_runner_tools
+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