code-puppy 0.0.81__tar.gz → 0.0.82__tar.gz

{code_puppy-0.0.81 → code_puppy-0.0.82}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-puppy
-Version: 0.0.81
+Version: 0.0.82
 Summary: Code generation agent
 Author: Michael Pfaffenberger
 License: MIT
@@ -20,13 +20,14 @@ Requires-Dist: json-repair>=0.46.2
 Requires-Dist: logfire>=0.7.1
 Requires-Dist: pathspec>=0.11.0
 Requires-Dist: prompt-toolkit>=3.0.38
-Requires-Dist: pydantic-ai>=0.4.8
+Requires-Dist: pydantic-ai>=0.7.2
 Requires-Dist: pydantic>=2.4.0
 Requires-Dist: pytest-cov>=6.1.1
 Requires-Dist: python-dotenv>=1.0.0
 Requires-Dist: rapidfuzz>=3.13.0
 Requires-Dist: rich>=13.4.2
 Requires-Dist: ruff>=0.11.11
+Requires-Dist: tiktoken>=0.11.0
 Requires-Dist: tree-sitter-language-pack>=0.8.0
 Requires-Dist: tree-sitter-typescript>=0.23.2
 Description-Content-Type: text/markdown
@@ -136,22 +137,10 @@ code-puppy "write me a C++ hello world program in /tmp/main.cpp then compile it
 
 This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
 
-## Puppy Rules
-Puppy rules allow you to define and enforce coding standards and styles that your code should comply with. These rules can cover various aspects such as formatting, naming conventions, and even design guidelines.
+## Agent Rules
+We support AGENT.md files for defining coding standards and styles that your code should comply with. These rules can cover various aspects such as formatting, naming conventions, and even design guidelines.
 
-### Example of a Puppy Rule
-For instance, if you want to ensure that your application follows a specific design guideline, like using a dark mode theme with teal accents, you can define a puppy rule like this:
-
-```plaintext
-# Puppy Rule: Dark Mode with Teal Accents
-
-  - theme: dark
-  - accent-color: teal
-  - background-color: #121212
-  - text-color: #e0e0e0
-
-Ensure that all components follow these color schemes to promote consistency in design.
-```
+For examples and more information about agent rules, visit [https://agent.md](https://agent.md)
 
 ## Using MCP Servers for External Tools
 

{code_puppy-0.0.81 → code_puppy-0.0.82}/README.md

@@ -103,22 +103,10 @@ code-puppy "write me a C++ hello world program in /tmp/main.cpp then compile it
 
 This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
 
-## Puppy Rules
-Puppy rules allow you to define and enforce coding standards and styles that your code should comply with. These rules can cover various aspects such as formatting, naming conventions, and even design guidelines.
+## Agent Rules
+We support AGENT.md files for defining coding standards and styles that your code should comply with. These rules can cover various aspects such as formatting, naming conventions, and even design guidelines.
 
-### Example of a Puppy Rule
-For instance, if you want to ensure that your application follows a specific design guideline, like using a dark mode theme with teal accents, you can define a puppy rule like this:
-
-```plaintext
-# Puppy Rule: Dark Mode with Teal Accents
-
-  - theme: dark
-  - accent-color: teal
-  - background-color: #121212
-  - text-color: #e0e0e0
-
-Ensure that all components follow these color schemes to promote consistency in design.
-```
+For examples and more information about agent rules, visit [https://agent.md](https://agent.md)
 
 ## Using MCP Servers for External Tools
 

code_puppy-0.0.82/code_puppy/__init__.py

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

{code_puppy-0.0.81 → code_puppy-0.0.82}/code_puppy/agent.py

@@ -21,7 +21,7 @@ from code_puppy.tools.common import console
 MODELS_JSON_PATH = os.environ.get("MODELS_JSON_PATH", None)
 
 # Puppy rules loader
-PUPPY_RULES_PATH = Path(".puppy_rules")
+PUPPY_RULES_PATH = Path("AGENT.md")
 PUPPY_RULES = None
 
 

code_puppy-0.0.82/code_puppy/message_history_processor.py

@@ -0,0 +1,169 @@
+import json
+import queue
+from typing import List
+import os
+from pathlib import Path
+
+import pydantic
+import tiktoken
+from pydantic_ai.messages import ModelMessage, ToolCallPart, ToolReturnPart, UserPromptPart, TextPart, ModelRequest, ModelResponse
+
+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
+    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]")
+    def get_summarization_agent():
+        return None
+
+
+def get_tokenizer_for_model(model_name: str):
+    """
+    Always use cl100k_base tokenizer regardless of model type.
+    This is a simple approach that works reasonably well for most models.
+    """
+    return tiktoken.get_encoding("cl100k_base")
+
+
+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
+    """
+    result = ""
+    if hasattr(part, "part_kind"):
+        result += part.part_kind + ": "
+    else:
+        result += str(type(part)) + ": "
+
+    # Handle content
+    if hasattr(part, 'content') and part.content:
+        # Handle different content types
+        if isinstance(part.content, str):
+            result = part.content
+        elif isinstance(part.content, pydantic.BaseModel):
+            result = json.dumps(part.content.model_dump())
+        elif isinstance(part.content, dict):
+            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:
+        # 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
+
+
+def estimate_tokens_for_message(message: ModelMessage) -> int:
+    """
+    Estimate the number of tokens in a message using tiktoken with cl100k_base encoding.
+    This is more accurate than character-based estimation.
+    """
+    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 = []
+
+    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"
+        " as well as user queries, etc. Summarize the contents of these steps."
+        " The high level details should remain but the bulk of the content from tool-call"
+        " responses should be compacted and summarized. For example if you see a tool-call"
+        " reading a file, and the file contents are large, then in your summary you might just"
+        " write: * used read_file on space_invaders.cpp - contents removed."
+        "\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
+    except Exception as e:
+        console.print(f"Summarization failed during compaction: {e}")
+        # Return original message if summarization fails
+        return None
+
+
+def get_model_context_length() -> int:
+    """
+    Get the context length for the currently configured model from models.json
+    """
+    # Load model configuration
+    models_path = os.environ.get("MODELS_JSON_PATH")
+    if not models_path:
+        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 message_history_processor(messages: List[ModelMessage]) -> List[ModelMessage]:
+
+    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}")
+
+    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)
+        console.print(f"Final token count after processing: {final_token_count}")
+        return result_messages
+    return messages

{code_puppy-0.0.81 → code_puppy-0.0.82}/code_puppy/models.json

@@ -1,45 +1,59 @@
 {
-  "gemini-2.5-flash-preview-05-20": {
-    "type": "gemini",
-    "name": "gemini-2.5-flash-preview-05-20"
-  },
-  "gpt-4.1": {
-    "type": "openai",
-    "name": "gpt-4.1"
-  },
-  "gpt-4.1-mini": {
-    "type": "openai",
-    "name": "gpt-4.1-mini"
-  },
   "gpt-5": {
     "type": "openai",
-    "name": "gpt-5"
+    "name": "gpt-5",
+    "context_length": 400000
   },
-  "gpt-4.1-nano": {
-    "type": "openai",
-    "name": "gpt-4.1-nano"
+  "Cerebras-Qwen3-Coder-480b": {
+    "type": "custom_openai",
+    "name": "qwen-3-coder-480b",
+    "custom_endpoint": {
+      "url": "https://api.cerebras.ai/v1",
+      "api_key": "$CEREBRAS_API_KEY"
+    },
+    "context_length": 131072
   },
-  "o3": {
-    "type": "openai",
-    "name": "o3"
+  "Cerebras-Qwen3-235b-a22b-instruct-2507": {
+    "type": "custom_openai",
+    "name": "qwen-3-235b-a22b-instruct-2507",
+    "custom_endpoint": {
+      "url": "https://api.cerebras.ai/v1",
+      "api_key": "$CEREBRAS_API_KEY"
+    },
+    "context_length": 64000
   },
-  "gpt-4.1-custom": {
+  "Cerebras-gpt-oss-120b": {
     "type": "custom_openai",
-    "name": "gpt-4.1-custom",
+    "name": "gpt-oss-120b",
     "custom_endpoint": {
-      "url": "https://my.cute.endpoint:8080",
-      "headers": {
-        "X-Api-Key": "$OPENAI_API_KEY"
-      },
-      "ca_certs_path": "/path/to/cert.pem"
-    }
+      "url": "https://api.cerebras.ai/v1",
+      "api_key": "$CEREBRAS_API_KEY"
+    },
+    "context_length": 131072
   },
-  "ollama-llama3.3": {
+  "Cerebras-Qwen-3-32b": {
     "type": "custom_openai",
-    "name": "llama3.3",
+    "name": "qwen-3-32b",
     "custom_endpoint": {
-      "url": "http://localhost:11434/v1"
-    }
+      "url": "https://api.cerebras.ai/v1",
+      "api_key": "$CEREBRAS_API_KEY"
+    },
+    "context_length": 65536
+  },
+  "o3": {
+    "type": "openai",
+    "name": "o3",
+    "context_length": 200000
+  },
+  "gemini-2.5-flash-preview-05-20": {
+    "type": "gemini",
+    "name": "gemini-2.5-flash-preview-05-20",
+    "context_length": 1048576
+  },
+  "gpt-4.1": {
+    "type": "openai",
+    "name": "gpt-4.1",
+    "context_length": 1000000
   },
   "Qwen/Qwen3-235B-A22B-fp8-tput": {
     "type": "custom_openai",
@@ -47,65 +61,51 @@
     "custom_endpoint": {
       "url": "https://api.together.xyz/v1",
       "api_key": "$TOGETHER_API_KEY"
-    }
-  },
-  "grok-3-mini-fast": {
-    "type": "custom_openai",
-    "name": "grok-3-mini-fast",
-    "custom_endpoint": {
-      "url": "https://api.x.ai/v1",
-      "api_key": "$XAI_API_KEY"
-    }
+    },
+    "context_length": 64000
   },
   "openrouter": {
     "type": "openrouter",
     "name": "meta-llama/llama-4-maverick:free",
-    "api_key": "$OPENROUTER_API_KEY"
+    "api_key": "$OPENROUTER_API_KEY",
+    "context_length": 131072
   },
   "azure-gpt-4.1": {
     "type": "azure_openai",
     "name": "gpt-4.1",
     "api_version": "2024-12-01-preview",
     "api_key": "$AZURE_OPENAI_API_KEY",
-    "azure_endpoint": "$AZURE_OPENAI_ENDPOINT"
+    "azure_endpoint": "$AZURE_OPENAI_ENDPOINT",
+    "context_length": 128000
   },
-  "Llama-4-Scout-17B-16E-Instruct": {
-    "type": "azure_openai",
-    "name": "Llama-4-Scout-17B-16E-Instruct",
-    "api_version": "2024-12-01-preview",
-    "api_key": "$AZURE_OPENAI_API_KEY",
-    "azure_endpoint": "$AZURE_OPENAI_ENDPOINT"
-  },
-  "Cerebras-Qwen3-Coder-480b": {
-    "type": "custom_openai",
-    "name": "qwen-3-coder-480b",
-    "custom_endpoint": {
-      "url": "https://api.cerebras.ai/v1",
-      "api_key": "$CEREBRAS_API_KEY"
-    }
+   "gpt-4.1-mini": {
+    "type": "openai",
+    "name": "gpt-4.1-mini",
+    "context_length": 128000
   },
-  "Cerebras-Qwen3-235b-a22b-instruct-2507": {
-    "type": "custom_openai",
-    "name": "qwen-3-235b-a22b-instruct-2507",
-    "custom_endpoint": {
-      "url": "https://api.cerebras.ai/v1",
-      "api_key": "$CEREBRAS_API_KEY"
-    }
+  "gpt-4.1-nano": {
+    "type": "openai",
+    "name": "gpt-4.1-nano",
+    "context_length": 128000
   },
-  "Cerebras-gpt-oss-120b": {
+  "gpt-4.1-custom": {
     "type": "custom_openai",
-    "name": "gpt-oss-120b",
+    "name": "gpt-4.1-custom",
     "custom_endpoint": {
-      "url": "https://api.cerebras.ai/v1",
-      "api_key": "$CEREBRAS_API_KEY"
-    }
+      "url": "https://my.cute.endpoint:8080",
+      "headers": {
+        "X-Api-Key": "$OPENAI_API_KEY"
+      },
+      "ca_certs_path": "/path/to/cert.pem"
+    },
+    "context_length": 128000
   },
-  "Cerebras-Qwen-3-32b": {
+  "ollama-llama3.3": {
     "type": "custom_openai",
-    "name": "qwen-3-32b",
+    "name": "llama3.3",
     "custom_endpoint": {
-      "url": "https://api.cerebras.ai/v1",
-      "api_key": "$CEREBRAS_API_KEY"
-    }
+      "url": "http://localhost:11434/v1"
+    },
+    "context_length": 8192
   }
 }

{code_puppy-0.0.81 → code_puppy-0.0.82}/code_puppy/state_management.py

@@ -1,6 +1,7 @@
 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] = []
 
@@ -35,8 +36,19 @@ 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)
-    return messages
+    
+    # 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.82/code_puppy/summarization_agent.py

@@ -0,0 +1,72 @@
+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
+
+# Environment variables used in this module:
+# - MODELS_JSON_PATH: Optional path to a custom models.json configuration file.
+#                     If not set, uses the default file in the package directory.
+# - MODEL_NAME: The model to use for code generation. Defaults to "gpt-4o".
+#               Must match a key in the models.json configuration.
+
+MODELS_JSON_PATH = os.environ.get("MODELS_JSON_PATH", None)
+
+_LAST_MODEL_NAME = None
+_summarization_agent = None
+
+
+def reload_summarization_agent():
+    """Create a specialized agent for summarizing messages when context limit is reached."""
+    global _summarization_agent, _LAST_MODEL_NAME
+    from code_puppy.config import get_model_name
+
+    model_name = get_model_name()
+    console.print(f"[bold cyan]Loading Summarization Model: {model_name}[/bold cyan]")
+    models_path = (
+        Path(MODELS_JSON_PATH)
+        if MODELS_JSON_PATH
+        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 
+content and intent of the original messages. This is to help manage token usage in a conversation history 
+while maintaining context for the AI to continue the conversation effectively.
+
+When summarizing:
+1. Keep summary brief but informative
+2. Preserve key information and decisions
+3. Keep any important technical details
+4. Don't summarize the system message
+5. Make sure all tool calls and responses are summarized, as they are vital"""
+
+    agent = Agent(
+        model=model,
+        instructions=instructions,
+        output_type=str,
+        retries=1  # Fewer retries for summarization
+    )
+    _summarization_agent = agent
+    _LAST_MODEL_NAME = model_name
+    return _summarization_agent
+
+
+def get_summarization_agent(force_reload=False):
+    """
+    Retrieve the summarization agent with the currently set MODEL_NAME.
+    Forces a reload if the model has changed, or if force_reload is passed.
+    """
+    global _summarization_agent, _LAST_MODEL_NAME
+    from code_puppy.config import get_model_name
+
+    model_name = get_model_name()
+    if _summarization_agent is None or _LAST_MODEL_NAME != model_name or force_reload:
+        return reload_summarization_agent()
+    return _summarization_agent

{code_puppy-0.0.81 → code_puppy-0.0.82}/code_puppy/tools/command_runner.py

@@ -164,21 +164,19 @@ def run_shell_command(
 
 class ReasoningOutput(BaseModel):
     success: bool = True
-    reasoning: str = ""
-    next_steps: str = ""
 
 
 def share_your_reasoning(
-    context: RunContext, reasoning: str, next_steps: str = None
+    context: RunContext, reasoning: str, next_steps: str | None = None
 ) -> ReasoningOutput:
     console.print("\n[bold white on purple] AGENT REASONING [/bold white on purple]")
     console.print("[bold cyan]Current reasoning:[/bold cyan]")
     console.print(Markdown(reasoning))
-    if next_steps and next_steps.strip():
+    if next_steps is not None and next_steps.strip():
         console.print("\n[bold cyan]Planned next steps:[/bold cyan]")
         console.print(Markdown(next_steps))
     console.print("[dim]" + "-" * 60 + "[/dim]\n")
-    return ReasoningOutput(**{"success": True, "reasoning": reasoning, "next_steps": next_steps})
+    return ReasoningOutput(**{"success": True})
 
 
 def register_command_runner_tools(agent):
@@ -190,6 +188,6 @@ def register_command_runner_tools(agent):
 
     @agent.tool
     def agent_share_your_reasoning(
-        context: RunContext, reasoning: str, next_steps: str = None
+        context: RunContext, reasoning: str, next_steps: str | None = None
     ) -> ReasoningOutput:
         return share_your_reasoning(context, reasoning, next_steps)

{code_puppy-0.0.81 → code_puppy-0.0.82}/code_puppy/tools/file_modifications.py

@@ -58,12 +58,21 @@ def _delete_snippet_from_file(
     diff_text = ""
     try:
         if not os.path.exists(file_path) or not os.path.isfile(file_path):
-            return {"error": f"File '{file_path}' does not exist.", "diff": diff_text}
+            return {
+                "success": False,
+                "path": file_path,
+                "message": f"File '{file_path}' does not exist.",
+                "changed": False,
+                "diff": diff_text,
+            }
         with open(file_path, "r", encoding="utf-8") as f:
             original = f.read()
         if snippet not in original:
             return {
-                "error": f"Snippet not found in file '{file_path}'.",
+                "success": False,
+                "path": file_path,
+                "message": f"Snippet not found in file '{file_path}'.",
+                "changed": False,
                 "diff": diff_text,
             }
         modified = original.replace(snippet, "")
@@ -317,7 +326,13 @@ def _delete_file(context: RunContext, file_path: str = "") -> Dict[str, Any]:
     file_path = os.path.abspath(file_path)
     try:
         if not os.path.exists(file_path) or not os.path.isfile(file_path):
-            res = {"error": f"File '{file_path}' does not exist.", "diff": ""}
+            res = {
+                "success": False,
+                "path": file_path,
+                "message": f"File '{file_path}' does not exist.",
+                "changed": False,
+                "diff": "",
+            }
         else:
             with open(file_path, "r", encoding="utf-8") as f:
                 original = f.read()
@@ -340,7 +355,13 @@ def _delete_file(context: RunContext, file_path: str = "") -> Dict[str, Any]:
             }
     except Exception as exc:
         _log_error("Unhandled exception in delete_file", exc)
-        res = {"error": str(exc), "diff": ""}
+        res = {
+            "success": False,
+            "path": file_path,
+            "message": str(exc),
+            "changed": False,
+            "diff": "",
+        }
     _print_diff(res.get("diff", ""))
     return res
 

{code_puppy-0.0.81 → code_puppy-0.0.82}/code_puppy/tools/file_operations.py

@@ -41,11 +41,11 @@ def _list_files(
             f"[bold red]Error:[/bold red] Directory '{directory}' does not exist"
         )
         console.print("[dim]" + "-" * 60 + "[/dim]\n")
-        return ListFileOutput(files=[ListedFile(**{"error": f"Directory '{directory}' does not exist"})])
+        return ListFileOutput(files=[ListedFile(path=None, type=None, full_path=None, depth=None)])
     if not os.path.isdir(directory):
         console.print(f"[bold red]Error:[/bold red] '{directory}' is not a directory")
         console.print("[dim]" + "-" * 60 + "[/dim]\n")
-        return ListFileOutput(files=[ListedFile(**{"error": f"'{directory}' is not a directory"})])
+        return ListFileOutput(files=[ListedFile(path=None, type=None, full_path=None, depth=None)])
     folder_structure = {}
     file_list = []
     for root, dirs, files in os.walk(directory):
@@ -266,22 +266,26 @@ def _grep(
             f"[green]Found {len(matches)} match(es) for '{search_string}' in {directory}[/green]"
         )
 
-    return GrepOutput(matches=[])
+    return GrepOutput(matches=matches)
+
+
+def list_files(
+    context: RunContext, directory: str = ".", recursive: bool = True
+) -> ListFileOutput:
+    return _list_files(context, directory, recursive)
+
+
+def read_file(context: RunContext, file_path: str = "") -> ReadFileOutput:
+    return _read_file(context, file_path)
+
+
+def grep(
+    context: RunContext, search_string: str = "", directory: str = "."
+) -> GrepOutput:
+    return _grep(context, search_string, directory)
 
 
 def register_file_operations_tools(agent):
-    @agent.tool
-    def list_files(
-        context: RunContext, directory: str = ".", recursive: bool = True
-    ) -> ListFileOutput:
-        return _list_files(context, directory, recursive)
-
-    @agent.tool
-    def read_file(context: RunContext, file_path: str = "") -> ReadFileOutput:
-        return _read_file(context, file_path)
-
-    @agent.tool
-    def grep(
-        context: RunContext, search_string: str = "", directory: str = "."
-    ) -> GrepOutput:
-        return _grep(context, search_string, directory)
+    agent.tool(list_files)
+    agent.tool(read_file)
+    agent.tool(grep)

{code_puppy-0.0.81 → code_puppy-0.0.82}/pyproject.toml

@@ -4,12 +4,12 @@ build-backend = "hatchling.build"
 
 [project]
 name = "code-puppy"
-version = "0.0.81"
+version = "0.0.82"
 description = "Code generation agent"
 readme = "README.md"
 requires-python = ">=3.10"
 dependencies = [
-    "pydantic-ai>=0.4.8",
+    "pydantic-ai>=0.7.2",
     "httpx>=0.24.1",
     "rich>=13.4.2",
     "logfire>=0.7.1",
@@ -25,6 +25,7 @@ dependencies = [
     "json-repair>=0.46.2",
     "tree-sitter-language-pack>=0.8.0",
     "tree-sitter-typescript>=0.23.2",
+    "tiktoken>=0.11.0",
 ]
 dev-dependencies = [
     "pytest>=8.3.4",

code_puppy-0.0.81/code_puppy/__init__.py

@@ -1,3 +0,0 @@
-import importlib.metadata
-
-__version__ = importlib.metadata.version("code-puppy")

code_puppy-0.0.81/code_puppy/message_history_processor.py

@@ -1,78 +0,0 @@
-import queue
-from typing import List
-
-from pydantic_ai.messages import ModelMessage, ToolCallPart, ToolReturnPart
-
-from code_puppy.config import get_message_history_limit
-from code_puppy.tools.common import console
-
-
-def message_history_processor(messages: List[ModelMessage]) -> List[ModelMessage]:
-    """
-    Truncate message history to manage token usage while preserving context.
-
-    This implementation:
-    - Uses the configurable message_history_limit from puppy.cfg (defaults to 40)
-    - Preserves system messages at the beginning
-    - Maintains tool call/response pairs together
-    - Follows PydanticAI best practices for message ordering
-
-    Args:
-        messages: List of ModelMessage objects from conversation history
-
-    Returns:
-        Truncated list of ModelMessage objects
-    """
-    if not messages:
-        return messages
-
-    # Get the configurable limit from puppy.cfg
-    max_messages = get_message_history_limit()
-    # If we have max_messages or fewer, no truncation needed
-    if len(messages) <= max_messages:
-        return messages
-
-    console.print(
-        f"Truncating message history to manage token usage: {max_messages}"
-    )
-    result = []
-    result.append(messages[0])  # this is the system prompt
-    remaining_messages_to_fill = max_messages - 1
-    stack = queue.LifoQueue()
-    count = 0
-    tool_call_parts = set()
-    tool_return_parts = set()
-    for message in reversed(messages):
-        stack.put(message)
-        count += 1
-        if count >= remaining_messages_to_fill:
-            break
-
-    while not stack.empty():
-        item = stack.get()
-        for part in item.parts:
-            if hasattr(part, "tool_call_id") and part.tool_call_id:
-                if isinstance(part, ToolCallPart):
-                    tool_call_parts.add(part.tool_call_id)
-                if isinstance(part, ToolReturnPart):
-                    tool_return_parts.add(part.tool_call_id)
-
-        result.append(item)
-
-    missmatched_tool_call_ids = (tool_call_parts.union(tool_return_parts)) - (
-        tool_call_parts.intersection(tool_return_parts)
-    )
-    # trust...
-    final_result = result
-    if missmatched_tool_call_ids:
-        final_result = []
-        for msg in result:
-            is_missmatched = False
-            for part in msg.parts:
-                if hasattr(part, "tool_call_id"):
-                    if part.tool_call_id in missmatched_tool_call_ids:
-                        is_missmatched = True
-            if is_missmatched:
-                continue
-            final_result.append(msg)
-    return final_result