code-puppy 0.0.75__tar.gz → 0.0.76__tar.gz

{code_puppy-0.0.75 → code_puppy-0.0.76}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-puppy
-Version: 0.0.75
+Version: 0.0.76
 Summary: Code generation agent
 Author: Michael Pfaffenberger
 License: MIT
@@ -20,7 +20,7 @@ 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.3.2
+Requires-Dist: pydantic-ai>=0.4.8
 Requires-Dist: pydantic>=2.4.0
 Requires-Dist: pytest-cov>=6.1.1
 Requires-Dist: python-dotenv>=1.0.0

{code_puppy-0.0.75 → code_puppy-0.0.76}/code_puppy/agent.py

@@ -74,7 +74,7 @@ def _load_mcp_servers():
         url = conf.get("url")
         if url:
             console.print(f"Registering MCP Server - {url}")
-            servers.append(MCPServerSSE(url))
+            servers.append(MCPServerSSE(url=url))
     return servers
 
 
@@ -100,13 +100,11 @@ def reload_code_generation_agent():
     if PUPPY_RULES:
         instructions += f"\n{PUPPY_RULES}"
 
-    mcp_servers = _load_mcp_servers()
     agent = Agent(
         model=model,
         instructions=instructions,
-        output_type=AgentResponse,
+        output_type=str,
         retries=3,
-        mcp_servers=mcp_servers,
     )
     register_all_tools(agent)
     _code_generation_agent = agent

code_puppy-0.0.76/code_puppy/command_line/motd.py

@@ -0,0 +1,49 @@
+"""
+MOTD (Message of the Day) feature for code-puppy.
+Stores seen versions in ~/.puppy_cfg/motd.txt.
+"""
+
+import os
+
+MOTD_VERSION = "20250802"
+MOTD_MESSAGE = """
+/¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯\\
+|   🐾  Happy Sat-urday, Aug 2, 2025!                       |
+|                                                           |
+|   Biscuit the code puppy is on full zoomie mode!          |
+|   Major paws-up: We now integrate Cerebras Qwen3 Coder    |
+|   480b! YES, that’s 480 billion parameters of tail-wagging|
+|   code speed. It’s so fast, even my fetch can’t keep up!  |
+|                                                           |
+|   • Take stretch breaks – you’ll need ‘em!                |
+|   • DRY your code, but keep your pup hydrated.            |
+|   • If you hit a bug, treat yourself for finding it!      |
+|                                                           |
+|   Today: sniff, code, roll over, and let Cerebras Qwen3   |
+|   Coder 480b do the heavy lifting. Fire up a ~motd anytime|
+|   you need some puppy hype!                               |
+\___________________________________________________________/
+"""
+MOTD_TRACK_FILE = os.path.expanduser("~/.puppy_cfg/motd.txt")
+
+
+def has_seen_motd(version: str) -> bool:
+    if not os.path.exists(MOTD_TRACK_FILE):
+        return False
+    with open(MOTD_TRACK_FILE, "r") as f:
+        seen_versions = {line.strip() for line in f if line.strip()}
+    return version in seen_versions
+
+
+def mark_motd_seen(version: str):
+    os.makedirs(os.path.dirname(MOTD_TRACK_FILE), exist_ok=True)
+    with open(MOTD_TRACK_FILE, "a") as f:
+        f.write(f"{version}\n")
+
+
+def print_motd(console, force: bool = False) -> bool:
+    if force or not has_seen_motd(MOTD_VERSION):
+        console.print(MOTD_MESSAGE)
+        mark_motd_seen(MOTD_VERSION)
+        return True
+    return False

{code_puppy-0.0.75 → code_puppy-0.0.76}/code_puppy/main.py

@@ -69,19 +69,7 @@ async def main():
                 async with agent.run_mcp_servers():
                     response = await agent.run(command)
                 agent_response = response.output
-                console.print(agent_response.output_message)
-                # Log to session memory
-                session_memory().log_task(
-                    f"Command executed: {command}",
-                    extras={
-                        "output": agent_response.output_message,
-                        "awaiting_user_input": agent_response.awaiting_user_input,
-                    },
-                )
-                if agent_response.awaiting_user_input:
-                    console.print(
-                        "[bold red]The agent requires further input. Interactive mode is recommended for such tasks."
-                    )
+                console.print(agent_response)
                 break
         except AttributeError as e:
             console.print(f"[bold red]AttributeError:[/bold red] {str(e)}")
@@ -215,15 +203,8 @@ async def interactive_mode(history_file_path: str) -> None:
                     result = await agent.run(task, message_history=message_history)
                 # Get the structured response
                 agent_response = result.output
-                console.print(agent_response.output_message)
+                console.print(agent_response)
                 # Log to session memory
-                session_memory().log_task(
-                    f"Interactive task: {task}",
-                    extras={
-                        "output": agent_response.output_message,
-                        "awaiting_user_input": agent_response.awaiting_user_input,
-                    },
-                )
 
                 # Update message history but apply filters & limits
                 new_msgs = result.new_messages()
@@ -273,11 +254,6 @@ async def interactive_mode(history_file_path: str) -> None:
                     message_history = truncated
                 # --- END GROUP-AWARE TRUNCATION LOGIC ---
 
-                if agent_response and agent_response.awaiting_user_input:
-                    console.print(
-                        "\n[bold yellow]\u26a0 Agent needs your input to continue.[/bold yellow]"
-                    )
-
                 # Show context status
                 console.print(
                     f"[dim]Context: {len(message_history)} messages in history[/dim]\n"

{code_puppy-0.0.75 → code_puppy-0.0.76}/code_puppy/model_factory.py

@@ -11,6 +11,7 @@ from pydantic_ai.models.openai import OpenAIModel
 from pydantic_ai.providers.anthropic import AnthropicProvider
 from pydantic_ai.providers.google_gla import GoogleGLAProvider
 from pydantic_ai.providers.openai import OpenAIProvider
+from pydantic_ai.providers.openrouter import OpenRouterProvider
 
 # Environment variables used in this module:
 # - GEMINI_API_KEY: API key for Google's Gemini models. Required when using Gemini models.
@@ -173,6 +174,16 @@ class ModelFactory:
             model = OpenAIModel(model_name=model_config["name"], provider=provider)
             setattr(model, "provider", provider)
             return model
-
+        elif model_type == "openrouter":
+            api_key = None
+            if "api_key" in model_config:
+                if model_config["api_key"].startswith("$"):
+                    api_key = os.environ.get(model_config["api_key"][1:])
+                else:
+                    api_key = model_config["api_key"]
+            provider = OpenRouterProvider(api_key=api_key)
+            model_name = model_config.get("name")
+            model = OpenAIModel(model_name, provider=provider)
+            return model
         else:
             raise ValueError(f"Unsupported model type: {model_type}")

{code_puppy-0.0.75 → code_puppy-0.0.76}/code_puppy/models.json

@@ -37,9 +37,9 @@
       "url": "http://localhost:11434/v1"
     }
   },
-  "meta-llama/Llama-3.3-70B-Instruct-Turbo": {
+  "Qwen/Qwen3-235B-A22B-fp8-tput": {
     "type": "custom_openai",
-    "name": "meta-llama/Llama-3.3-70B-Instruct-Turbo",
+    "name": "Qwen/Qwen3-235B-A22B-fp8-tput",
     "custom_endpoint": {
       "url": "https://api.together.xyz/v1",
       "api_key": "$TOGETHER_API_KEY"
@@ -53,6 +53,11 @@
       "api_key": "$XAI_API_KEY"
     }
   },
+  "openrouter": {
+    "type": "openrouter",
+    "name": "meta-llama/llama-4-maverick:free",
+    "api_key": "$OPENROUTER_API_KEY"
+  },
   "azure-gpt-4.1": {
     "type": "azure_openai",
     "name": "gpt-4.1",
@@ -66,5 +71,13 @@
     "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"
+    }
   }
 }

{code_puppy-0.0.75 → code_puppy-0.0.76}/code_puppy/tools/__init__.py

@@ -1,12 +1,11 @@
 from code_puppy.tools.command_runner import register_command_runner_tools
 from code_puppy.tools.file_modifications import register_file_modifications_tools
 from code_puppy.tools.file_operations import register_file_operations_tools
-from code_puppy.tools.web_search import register_web_search_tools
 
 
 def register_all_tools(agent):
     """Register all available tools to the provided agent."""
+
     register_file_operations_tools(agent)
     register_file_modifications_tools(agent)
     register_command_runner_tools(agent)
-    register_web_search_tools(agent)

{code_puppy-0.0.75 → code_puppy-0.0.76}/code_puppy/tools/command_runner.py

@@ -2,6 +2,7 @@ import subprocess
 import time
 from typing import Any, Dict
 
+from pydantic import BaseModel
 from pydantic_ai import RunContext
 from rich.markdown import Markdown
 from rich.syntax import Syntax
@@ -9,12 +10,22 @@ from rich.syntax import Syntax
 from code_puppy.tools.common import console
 
 
+class ShellCommandOutput(BaseModel):
+    success: bool
+    command: str | None
+    error: str | None = ""
+    stdout: str | None
+    stderr: str | None
+    exit_code: int | None
+    execution_time: float | None
+    timeout: bool | None = False
+
 def run_shell_command(
     context: RunContext, command: str, cwd: str = None, timeout: int = 60
-) -> Dict[str, Any]:
+) -> ShellCommandOutput:
     if not command or not command.strip():
         console.print("[bold red]Error:[/bold red] Command cannot be empty")
-        return {"error": "Command cannot be empty"}
+        return ShellCommandOutput(**{"success": False, "error": "Command cannot be empty"})
     console.print(
         f"\n[bold white on blue] SHELL COMMAND [/bold white on blue] \U0001f4c2 [bold green]$ {command}[/bold green]"
     )
@@ -30,11 +41,11 @@ def run_shell_command(
             console.print(
                 "[bold yellow]Command execution canceled by user.[/bold yellow]"
             )
-            return {
+            return ShellCommandOutput(**{
                 "success": False,
                 "command": command,
                 "error": "User canceled command execution",
-            }
+            })
     try:
         start_time = time.time()
         process = subprocess.Popen(
@@ -84,7 +95,7 @@ def run_shell_command(
                     "[bold yellow]This command produced no output at all![/bold yellow]"
                 )
             console.print("[dim]" + "-" * 60 + "[/dim]\n")
-            return {
+            return ShellCommandOutput(**{
                 "success": exit_code == 0,
                 "command": command,
                 "stdout": stdout,
@@ -92,7 +103,7 @@ def run_shell_command(
                 "exit_code": exit_code,
                 "execution_time": execution_time,
                 "timeout": False,
-            }
+            })
         except subprocess.TimeoutExpired:
             process.kill()
             stdout, stderr = process.communicate()
@@ -123,7 +134,7 @@ def run_shell_command(
                 f"[bold red]⏱ Command timed out after {timeout} seconds[/bold red] [dim](ran for {execution_time:.2f}s)[/dim]"
             )
             console.print("[dim]" + "-" * 60 + "[/dim]\n")
-            return {
+            return ShellCommandOutput(**{
                 "success": False,
                 "command": command,
                 "stdout": stdout[-1000:],
@@ -132,7 +143,7 @@ def run_shell_command(
                 "execution_time": execution_time,
                 "timeout": True,
                 "error": f"Command timed out after {timeout} seconds",
-            }
+            })
     except Exception as e:
         console.print_exception(show_locals=True)
         console.print("[dim]" + "-" * 60 + "[/dim]\n")
@@ -141,7 +152,7 @@ def run_shell_command(
             stdout = None
         if "stderr" not in locals():
             stderr = None
-        return {
+        return ShellCommandOutput(**{
             "success": False,
             "command": command,
             "error": f"Error executing command: {str(e)}",
@@ -149,12 +160,17 @@ def run_shell_command(
             "stderr": stderr[-1000:] if stderr else None,
             "exit_code": -1,
             "timeout": False,
-        }
+        })
+
+class ReasoningOutput(BaseModel):
+    success: bool = True
+    reasoning: str = ""
+    next_steps: str = ""
 
 
 def share_your_reasoning(
     context: RunContext, reasoning: str, next_steps: str = None
-) -> Dict[str, Any]:
+) -> 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))
@@ -162,18 +178,18 @@ def share_your_reasoning(
         console.print("\n[bold cyan]Planned next steps:[/bold cyan]")
         console.print(Markdown(next_steps))
     console.print("[dim]" + "-" * 60 + "[/dim]\n")
-    return {"success": True, "reasoning": reasoning, "next_steps": next_steps}
+    return ReasoningOutput(**{"success": True, "reasoning": reasoning, "next_steps": next_steps})
 
 
 def register_command_runner_tools(agent):
     @agent.tool
     def agent_run_shell_command(
         context: RunContext, command: str, cwd: str = None, timeout: int = 60
-    ) -> Dict[str, Any]:
+    ) -> ShellCommandOutput:
         return run_shell_command(context, command, cwd, timeout)
 
     @agent.tool
     def agent_share_your_reasoning(
         context: RunContext, reasoning: str, next_steps: str = None
-    ) -> Dict[str, Any]:
+    ) -> ReasoningOutput:
         return share_your_reasoning(context, reasoning, next_steps)

{code_puppy-0.0.75 → code_puppy-0.0.76}/code_puppy/tools/file_modifications.py

@@ -17,6 +17,7 @@ import traceback
 from typing import Any, Dict, List
 
 from json_repair import repair_json
+from pydantic import BaseModel
 from pydantic_ai import RunContext
 
 from code_puppy.tools.common import _find_best_window, console
@@ -311,7 +312,7 @@ def _edit_file(context: RunContext, path: str, diff: str) -> Dict[str, Any]:
         }
 
 
-def _delete_file(context: RunContext, file_path: str) -> Dict[str, Any]:
+def _delete_file(context: RunContext, file_path: str = "") -> Dict[str, Any]:
     console.log(f"🗑️ Deleting file [bold red]{file_path}[/bold red]")
     file_path = os.path.abspath(file_path)
     try:
@@ -344,13 +345,21 @@ def _delete_file(context: RunContext, file_path: str) -> Dict[str, Any]:
     return res
 
 
+class EditFileOutput(BaseModel):
+    success: bool | None
+    file_path: str | None
+    message: str | None
+    changed: bool | None
+    diff: str | None
+
+
 def register_file_modifications_tools(agent):
     """Attach file-editing tools to *agent* with mandatory diff rendering."""
 
     @agent.tool(retries=5)
-    def edit_file(context: RunContext, path: str, diff: str) -> Dict[str, Any]:
-        return _edit_file(context, path, diff)
+    def edit_file(context: RunContext, path: str = "", diff: str = "") -> EditFileOutput:
+        return EditFileOutput(**_edit_file(context, path, diff))
 
     @agent.tool(retries=5)
-    def delete_file(context: RunContext, file_path: str) -> Dict[str, Any]:
-        return _delete_file(context, file_path)
+    def delete_file(context: RunContext, file_path: str = "") -> EditFileOutput:
+        return EditFileOutput(**_delete_file(context, file_path))

{code_puppy-0.0.75 → code_puppy-0.0.76}/code_puppy/tools/file_operations.py

@@ -3,6 +3,7 @@
 import os
 from typing import Any, Dict, List
 
+from pydantic import BaseModel, StrictStr, StrictInt
 from pydantic_ai import RunContext
 
 from code_puppy.tools.common import console
@@ -13,9 +14,21 @@ from code_puppy.tools.common import console
 from code_puppy.tools.common import should_ignore_path
 
 
+class ListedFile(BaseModel):
+    path: str | None
+    type: str | None
+    size: int = 0
+    full_path: str | None
+    depth: int | None
+
+
+class ListFileOutput(BaseModel):
+    files: List[ListedFile]
+
+
 def _list_files(
     context: RunContext, directory: str = ".", recursive: bool = True
-) -> List[Dict[str, Any]]:
+) -> ListFileOutput:
     results = []
     directory = os.path.abspath(directory)
     console.print("\n[bold white on blue] DIRECTORY LISTING [/bold white on blue]")
@@ -28,11 +41,11 @@ def _list_files(
             f"[bold red]Error:[/bold red] Directory '{directory}' does not exist"
         )
         console.print("[dim]" + "-" * 60 + "[/dim]\n")
-        return [{"error": f"Directory '{directory}' does not exist"}]
+        return ListFileOutput(files=[ListedFile(**{"error": f"Directory '{directory}' does not exist"})])
     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 [{"error": f"'{directory}' is not a directory"}]
+        return ListFileOutput(files=[ListedFile(**{"error": f"'{directory}' is not a directory"})])
     folder_structure = {}
     file_list = []
     for root, dirs, files in os.walk(directory):
@@ -44,13 +57,13 @@ def _list_files(
         if rel_path:
             dir_path = os.path.join(directory, rel_path)
             results.append(
-                {
+                ListedFile(**{
                     "path": rel_path,
                     "type": "directory",
                     "size": 0,
                     "full_path": dir_path,
                     "depth": depth,
-                }
+                })
             )
             folder_structure[rel_path] = {
                 "path": rel_path,
@@ -71,7 +84,7 @@ def _list_files(
                     "full_path": file_path,
                     "depth": depth,
                 }
-                results.append(file_info)
+                results.append(ListedFile(**file_info))
                 file_list.append(file_info)
             except (FileNotFoundError, PermissionError):
                 continue
@@ -119,74 +132,81 @@ def _list_files(
 
     if results:
         files = sorted(
-            [f for f in results if f["type"] == "file"], key=lambda x: x["path"]
+            [f for f in results if f.type == "file"], key=lambda x: x.path
         )
         console.print(
             f"\U0001f4c1 [bold blue]{os.path.basename(directory) or directory}[/bold blue]"
         )
-    all_items = sorted(results, key=lambda x: x["path"])
+    all_items = sorted(results, key=lambda x: x.path)
     parent_dirs_with_content = set()
     for i, item in enumerate(all_items):
-        if item["type"] == "directory" and not item["path"]:
+        if item.type == "directory" and not item.path:
             continue
-        if os.sep in item["path"]:
-            parent_path = os.path.dirname(item["path"])
+        if os.sep in item.path:
+            parent_path = os.path.dirname(item.path)
             parent_dirs_with_content.add(parent_path)
-        depth = item["path"].count(os.sep) + 1 if item["path"] else 0
+        depth = item.path.count(os.sep) + 1 if item.path else 0
         prefix = ""
         for d in range(depth):
             if d == depth - 1:
                 prefix += "\u2514\u2500\u2500 "
             else:
                 prefix += "    "
-        name = os.path.basename(item["path"]) or item["path"]
-        if item["type"] == "directory":
+        name = os.path.basename(item.path) or item.path
+        if item.type == "directory":
             console.print(f"{prefix}\U0001f4c1 [bold blue]{name}/[/bold blue]")
         else:
-            icon = get_file_icon(item["path"])
-            size_str = format_size(item["size"])
+            icon = get_file_icon(item.path)
+            size_str = format_size(item.size)
             console.print(
                 f"{prefix}{icon} [green]{name}[/green] [dim]({size_str})[/dim]"
             )
     else:
         console.print("[yellow]Directory is empty[/yellow]")
-    dir_count = sum(1 for item in results if item["type"] == "directory")
-    file_count = sum(1 for item in results if item["type"] == "file")
-    total_size = sum(item["size"] for item in results if item["type"] == "file")
+    dir_count = sum(1 for item in results if item.type == "directory")
+    file_count = sum(1 for item in results if item.type == "file")
+    total_size = sum(item.size for item in results if item.type == "file")
     console.print("\n[bold cyan]Summary:[/bold cyan]")
     console.print(
         f"\U0001f4c1 [blue]{dir_count} directories[/blue], \U0001f4c4 [green]{file_count} files[/green] [dim]({format_size(total_size)} total)[/dim]"
     )
     console.print("[dim]" + "-" * 60 + "[/dim]\n")
-    return results
+    return ListFileOutput(files=results)
 
 
-def _read_file(context: RunContext, file_path: str) -> Dict[str, Any]:
+class ReadFileOutput(BaseModel):
+    content: str | None
+
+def _read_file(context: RunContext, file_path: str) -> ReadFileOutput:
     file_path = os.path.abspath(file_path)
     console.print(
         f"\n[bold white on blue] READ FILE [/bold white on blue] \U0001f4c2 [bold cyan]{file_path}[/bold cyan]"
     )
     console.print("[dim]" + "-" * 60 + "[/dim]")
     if not os.path.exists(file_path):
-        return {"error": f"File '{file_path}' does not exist"}
+        return ReadFileOutput(content=f"File '{file_path}' does not exist")
     if not os.path.isfile(file_path):
-        return {"error": f"'{file_path}' is not a file"}
+        return ReadFileOutput(content=f"'{file_path}' is not a file")
     try:
         with open(file_path, "r", encoding="utf-8") as f:
             content = f.read()
-        return {
-            "content": content,
-            "path": file_path,
-            "total_lines": len(content.splitlines()),
-        }
+        return ReadFileOutput(content=content)
     except Exception as exc:
-        return {"error": str(exc)}
+        return ReadFileOutput(content="FILE NOT FOUND")
+
+
+class MatchInfo(BaseModel):
+    file_path: str | None
+    line_number: int | None
+    line_content: str | None
 
+class GrepOutput(BaseModel):
+    matches: List[MatchInfo]
 
 def _grep(
     context: RunContext, search_string: str, directory: str = "."
-) -> List[Dict[str, Any]]:
-    matches: List[Dict[str, Any]] = []
+) -> GrepOutput:
+    matches: List[MatchInfo] = []
     directory = os.path.abspath(directory)
     console.print(
         f"\n[bold white on blue] GREP [/bold white on blue] \U0001f4c2 [bold cyan]{directory}[/bold cyan] [dim]for '{search_string}'[/dim]"
@@ -209,11 +229,11 @@ def _grep(
                 with open(file_path, "r", encoding="utf-8", errors="ignore") as fh:
                     for line_number, line_content in enumerate(fh, 1):
                         if search_string in line_content:
-                            match_info = {
+                            match_info = MatchInfo(**{
                                 "file_path": file_path,
                                 "line_number": line_number,
                                 "line_content": line_content.strip(),
-                            }
+                            })
                             matches.append(match_info)
                             # console.print(
                             #     f"[green]Match:[/green] {file_path}:{line_number} - {line_content.strip()}"
@@ -222,7 +242,7 @@ def _grep(
                                 console.print(
                                     "[yellow]Limit of 200 matches reached. Stopping search.[/yellow]"
                                 )
-                                return matches
+                                return GrepOutput(matches=matches)
             except FileNotFoundError:
                 console.print(
                     f"[yellow]File not found (possibly a broken symlink): {file_path}[/yellow]"
@@ -246,54 +266,22 @@ def _grep(
             f"[green]Found {len(matches)} match(es) for '{search_string}' in {directory}[/green]"
         )
 
-    return matches
-
-
-# Exported top-level functions for direct import by tests and other code
-
-
-def list_files(context, directory=".", recursive=True):
-    return _list_files(context, directory, recursive)
-
-
-def read_file(context, file_path):
-    return _read_file(context, file_path)
-
-
-def grep(context, search_string, directory="."):
-    return _grep(context, search_string, directory)
+    return GrepOutput(matches=[])
 
 
 def register_file_operations_tools(agent):
     @agent.tool
     def list_files(
         context: RunContext, directory: str = ".", recursive: bool = True
-    ) -> List[Dict[str, Any]]:
+    ) -> ListFileOutput:
         return _list_files(context, directory, recursive)
 
     @agent.tool
-    def read_file(context: RunContext, file_path: str) -> Dict[str, Any]:
+    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 = "."
-    ) -> List[Dict[str, Any]]:
+        context: RunContext, search_string: str = "", directory: str = "."
+    ) -> GrepOutput:
         return _grep(context, search_string, directory)
-
-    @agent.tool
-    def code_map(context: RunContext, directory: str = ".") -> str:
-        """Generate a code map for the specified directory.
-           This will have a list of all function / class names and nested structure
-        Args:
-            context: The context object.
-            directory: The directory to generate the code map for.
-
-        Returns:
-            A string containing the code map.
-        """
-        console.print("[bold white on blue] CODE MAP [/bold white on blue]")
-        from code_puppy.tools.ts_code_map import make_code_map
-
-        result = make_code_map(directory, ignore_tests=True)
-        return result

{code_puppy-0.0.75 → code_puppy-0.0.76}/pyproject.toml

@@ -4,12 +4,12 @@ build-backend = "hatchling.build"
 
 [project]
 name = "code-puppy"
-version = "0.0.75"
+version = "0.0.76"
 description = "Code generation agent"
 readme = "README.md"
 requires-python = ">=3.10"
 dependencies = [
-    "pydantic-ai>=0.3.2",
+    "pydantic-ai>=0.4.8",
     "httpx>=0.24.1",
     "rich>=13.4.2",
     "logfire>=0.7.1",

code_puppy-0.0.75/code_puppy/command_line/motd.py

@@ -1,57 +0,0 @@
-"""
-MOTD (Message of the Day) feature for code-puppy.
-Stores seen versions in ~/.puppy_cfg/motd.txt.
-"""
-
-import os
-
-MOTD_VERSION = "20240621"
-MOTD_MESSAGE = """
-June 21th, 2025 - 🚀 Woof-tastic news! Code Puppy now supports **MCP (Model Context Protocol) servers** for EXTREME PUPPY POWER!!!!.
-
-You can now connect plugins like doc search, Context7 integration, and more by simply dropping their info in your `~/.code_puppy/mcp_servers.json`. I’ll bark at remote docs or wrangle code tools for you—no extra fetches needed.
-
-Setup is easy:
-1. Add your MCP config to `~/.code_puppy/mcp_servers.json`.
-2. Fire up something like Context7, or any MCP server you want.
-3. Ask me to search docs, analyze, and more.
-
-The following example will let code_puppy use Context7! 
-Example config (+ more details in the README): 
-
-{
-  "mcp_servers": {
-     "context7": { 
-        "url": "https://mcp.context7.com/sse"
-     }
-  }
-}
-
-I fetch docs and power-ups via those servers. If you break stuff, please file an issue—bonus treat for reproducible bugs! 🦴
-
-This message-of-the-day won’t bug you again unless you run ~motd. Stay fluffy!
-
-"""
-MOTD_TRACK_FILE = os.path.expanduser("~/.puppy_cfg/motd.txt")
-
-
-def has_seen_motd(version: str) -> bool:
-    if not os.path.exists(MOTD_TRACK_FILE):
-        return False
-    with open(MOTD_TRACK_FILE, "r") as f:
-        seen_versions = {line.strip() for line in f if line.strip()}
-    return version in seen_versions
-
-
-def mark_motd_seen(version: str):
-    os.makedirs(os.path.dirname(MOTD_TRACK_FILE), exist_ok=True)
-    with open(MOTD_TRACK_FILE, "a") as f:
-        f.write(f"{version}\n")
-
-
-def print_motd(console, force: bool = False) -> bool:
-    if force or not has_seen_motd(MOTD_VERSION):
-        console.print(MOTD_MESSAGE)
-        mark_motd_seen(MOTD_VERSION)
-        return True
-    return False

code_puppy-0.0.75/code_puppy/tools/web_search.py

@@ -1,32 +0,0 @@
-from typing import Dict
-
-import requests
-from pydantic_ai import RunContext
-
-
-def register_web_search_tools(agent):
-    @agent.tool
-    def grab_json_from_url(context: RunContext, url: str) -> Dict:
-        from code_puppy.tools.common import console
-
-        try:
-            response = requests.get(url)
-            response.raise_for_status()
-            ct = response.headers.get("Content-Type")
-            if "json" not in str(ct):
-                console.print(
-                    f"[bold red]Error:[/bold red] Response from {url} is not JSON (got {ct})"
-                )
-                return {"error": f"Response from {url} is not of type application/json"}
-            json_data = response.json()
-            if isinstance(json_data, list) and len(json_data) > 1000:
-                console.print("[yellow]Result list truncated to 1000 items[/yellow]")
-                return json_data[:1000]
-            if not json_data:
-                console.print("[yellow]No data found for URL:[/yellow]", url)
-            else:
-                console.print(f"[green]Successfully fetched JSON from:[/green] {url}")
-            return json_data
-        except Exception as exc:
-            console.print(f"[bold red]Error:[/bold red] {exc}")
-            return {"error": str(exc)}