code-puppy 0.0.177__tar.gz → 0.0.179__tar.gz

{code_puppy-0.0.177 → code_puppy-0.0.179}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-puppy
-Version: 0.0.177
+Version: 0.0.179
 Summary: Code generation agent
 Project-URL: repository, https://github.com/mpfaffenberger/code_puppy
 Project-URL: HomePage, https://github.com/mpfaffenberger/code_puppy

code_puppy-0.0.179/code_puppy/agents/agent_golang_reviewer.py

@@ -0,0 +1,61 @@
+"""Golang code reviewer agent."""
+
+from .base_agent import BaseAgent
+
+
+class GolangReviewerAgent(BaseAgent):
+    """Golang-focused code reviewer agent."""
+
+    @property
+    def name(self) -> str:
+        return "golang-reviewer"
+
+    @property
+    def display_name(self) -> str:
+        return "Golang Reviewer 🦴"
+
+    @property
+    def description(self) -> str:
+        return "Meticulous reviewer for Go pull requests with idiomatic guidance"
+
+    def get_available_tools(self) -> list[str]:
+        """Reviewers only need read and reasoning helpers."""
+        return [
+            "agent_share_your_reasoning",
+            "list_files",
+            "read_file",
+            "grep",
+        ]
+
+    def get_system_prompt(self) -> str:
+        return """
+You are an expert Golang reviewer puppy. Sniff only the Go code that changed, bark constructive stuff, and keep it playful but razor sharp without name-dropping any specific humans.
+
+Mission profile:
+- Review only tracked `.go` files with real code diffs. If a file is untouched or only whitespace/comments changed, just wag your tail and skip it.
+- Ignore every non-Go file: `.yml`, `.yaml`, `.md`, `.json`, `.txt`, `Dockerfile`, `LICENSE`, `README.md`, etc. If someone tries to sneak one in, roll over and move on.
+- Live by `Effective Go` (https://go.dev/doc/effective_go) and the `Google Go Style Guide` (https://google.github.io/styleguide/go/).
+- Enforce gofmt/goimports cleanliness, make sure go vet and staticcheck would be happy, and flag any missing `//nolint` justifications.
+- You are the guardian of SOLID, DRY, YAGNI, and the Zen of Python (yes, even here). Call out violations with precision.
+
+Per Go file that actually matters:
+1. Give a breezy high-level summary of what changed. No snooze-fests or line-by-line bedtime stories.
+2. Drop targeted, actionable suggestions rooted in idiomatic Go, testing strategy, performance, concurrency safety, and error handling. No fluff or nitpicks unless they break principles.
+3. Sprinkle genuine praise when a change slaps—great naming, clean abstractions, smart concurrency, tests that cover real edge cases.
+
+Review etiquette:
+- Stay concise, organized, and focused on impact. Group similar findings so the reader doesn’t chase their tail.
+- Flag missing tests or weak coverage when it matters. Suggest concrete test names or scenarios.
+- Prefer positive phrasing: "Consider" beats "Don’t". We’re a nice puppy, just ridiculously picky.
+- If everything looks barking good, say so explicitly and call out strengths.
+- Always mention residual risks or assumptions you made when you can’t fully verify something.
+
+Output format (per file with real changes):
+- File header like `file.go:123` when referencing issues. Avoid line ranges.
+- Use bullet points for findings and kudos. Severity order: blockers first, then warnings, then nits, then praise.
+- Close with overall verdict if multiple files: "Ship it", "Needs fixes", or "Mixed bag", plus a short rationale.
+
+You are the Golang review persona for this CLI pack. Be sassy, precise, and wildly helpful.
+- When concurrency primitives show up, double-check for race hazards, context cancellation, and proper error propagation.
+- If performance or allocation pressure might bite, call it out and suggest profiling or benchmarks.
+"""

{code_puppy-0.0.177 → code_puppy-0.0.179}/code_puppy/agents/base_agent.py

@@ -829,15 +829,15 @@ class BaseAgent(ABC):
 
         async def run_agent_task():
             try:
+                self.set_message_history(
+                    self.prune_interrupted_tool_calls(self.get_message_history())
+                )
                 result_ = await pydantic_agent.run(
                     prompt,
                     message_history=self.get_message_history(),
                     usage_limits=usage_limits,
                     **kwargs,
                 )
-                self.set_message_history(
-                    self.prune_interrupted_tool_calls(self.get_message_history())
-                )
                 return result_
             except* UsageLimitExceeded as ule:
                 emit_info(f"Usage limit exceeded: {str(ule)}", group_id=group_id)
@@ -883,10 +883,10 @@ class BaseAgent(ABC):
                         cancelled_exceptions.append(exc)
 
                 collect_cancelled_exceptions(other_error)
-
-                if cancelled_exceptions:
-                    # Re-raise the first CancelledError to propagate cancellation
-                    raise cancelled_exceptions[0]
+            finally:
+                self.set_message_history(
+                    self.prune_interrupted_tool_calls(self.get_message_history())
+                )
 
         # Create the task FIRST
         agent_task = asyncio.create_task(run_agent_task())
@@ -909,7 +909,6 @@ class BaseAgent(ABC):
                         agent_task.cancel()
             except Exception as e:
                 emit_info(f"Shell kill error: {e}")
-                # If shell kill failed, still try to cancel the agent task
                 if not agent_task.done():
                     agent_task.cancel()
             # Don't call the original handler
@@ -923,8 +922,7 @@ class BaseAgent(ABC):
             result = await agent_task
             return result
         except asyncio.CancelledError:
-            # Task was cancelled by our handler
-            raise
+            agent_task.cancel()
         except KeyboardInterrupt:
             # Handle direct keyboard interrupt during await
             if not agent_task.done():
@@ -933,7 +931,6 @@ class BaseAgent(ABC):
                 await agent_task
             except asyncio.CancelledError:
                 pass
-            raise asyncio.CancelledError()
         finally:
             # Restore original signal handler
             if original_handler:

{code_puppy-0.0.177 → code_puppy-0.0.179}/code_puppy/main.py

@@ -383,6 +383,8 @@ async def interactive_mode(message_renderer, initial_command: str = None) -> Non
         if task.strip().lower() in ("clear", "/clear"):
             from code_puppy.messaging import emit_system_message, emit_warning
 
+            agent = get_current_agent()
+            agent.clear_message_history()
             emit_warning("Conversation history cleared!")
             emit_system_message("The agent will not remember previous interactions.\n")
             continue

{code_puppy-0.0.177 → code_puppy-0.0.179}/code_puppy/tui/app.py

@@ -515,6 +515,8 @@ class CodePuppyTUI(App):
         """Clear the chat history."""
         chat_view = self.query_one("#chat-view", ChatView)
         chat_view.clear_messages()
+        agent = get_current_agent()
+        agent.clear_message_history()
         self.add_system_message("Chat history cleared")
 
     def action_show_help(self) -> None:

{code_puppy-0.0.177 → code_puppy-0.0.179}/pyproject.toml

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

code_puppy-0.0.177/code_puppy/tools/browser_control.py

@@ -1,293 +0,0 @@
-"""Browser initialization and control tools."""
-
-from typing import Any, Dict, Optional
-
-from pydantic_ai import RunContext
-
-from code_puppy.messaging import emit_info
-from code_puppy.tools.common import generate_group_id
-
-from .camoufox_manager import get_camoufox_manager
-
-
-async def initialize_browser(
-    headless: bool = False,
-    browser_type: str = "chromium",
-    homepage: str = "https://www.google.com",
-) -> Dict[str, Any]:
-    """Initialize the browser with specified settings."""
-    group_id = generate_group_id("browser_initialize", f"{browser_type}_{homepage}")
-    emit_info(
-        f"[bold white on blue] BROWSER INITIALIZE [/bold white on blue] 🌐 {browser_type} → {homepage}",
-        message_group=group_id,
-    )
-    try:
-        browser_manager = get_camoufox_manager()
-
-        # Configure browser settings
-        browser_manager.headless = headless
-        browser_manager.browser_type = browser_type
-        browser_manager.homepage = homepage
-
-        # Initialize browser
-        await browser_manager.async_initialize()
-
-        # Get page info
-        page = await browser_manager.get_current_page()
-        if page:
-            url = page.url
-            title = await page.title()
-        else:
-            url = "Unknown"
-            title = "Unknown"
-
-        emit_info(
-            "[green]Browser initialized successfully[/green]", message_group=group_id
-        )
-
-        return {
-            "success": True,
-            "browser_type": browser_type,
-            "headless": headless,
-            "homepage": homepage,
-            "current_url": url,
-            "current_title": title,
-        }
-
-    except Exception as e:
-        emit_info(
-            f"[red]Browser initialization failed: {str(e)}[/red]",
-            message_group=group_id,
-        )
-        return {
-            "success": False,
-            "error": str(e),
-            "browser_type": browser_type,
-            "headless": headless,
-        }
-
-
-async def close_browser() -> Dict[str, Any]:
-    """Close the browser and clean up resources."""
-    group_id = generate_group_id("browser_close")
-    emit_info(
-        "[bold white on blue] BROWSER CLOSE [/bold white on blue] 🔒",
-        message_group=group_id,
-    )
-    try:
-        browser_manager = get_camoufox_manager()
-        await browser_manager.close()
-
-        emit_info(
-            "[yellow]Browser closed successfully[/yellow]", message_group=group_id
-        )
-
-        return {"success": True, "message": "Browser closed"}
-
-    except Exception as e:
-        return {"success": False, "error": str(e)}
-
-
-async def get_browser_status() -> Dict[str, Any]:
-    """Get current browser status and information."""
-    group_id = generate_group_id("browser_status")
-    emit_info(
-        "[bold white on blue] BROWSER STATUS [/bold white on blue] 📊",
-        message_group=group_id,
-    )
-    try:
-        browser_manager = get_camoufox_manager()
-
-        if not browser_manager._initialized:
-            return {
-                "success": True,
-                "status": "not_initialized",
-                "browser_type": browser_manager.browser_type,
-                "headless": browser_manager.headless,
-            }
-
-        page = await browser_manager.get_current_page()
-        if page:
-            url = page.url
-            title = await page.title()
-
-            # Get all pages
-            all_pages = await browser_manager.get_all_pages()
-            page_count = len(all_pages)
-        else:
-            url = None
-            title = None
-            page_count = 0
-
-        return {
-            "success": True,
-            "status": "initialized",
-            "browser_type": browser_manager.browser_type,
-            "headless": browser_manager.headless,
-            "current_url": url,
-            "current_title": title,
-            "page_count": page_count,
-        }
-
-    except Exception as e:
-        return {"success": False, "error": str(e)}
-
-
-async def create_new_page(url: Optional[str] = None) -> Dict[str, Any]:
-    """Create a new browser page/tab."""
-    group_id = generate_group_id("browser_new_page", url or "blank")
-    emit_info(
-        f"[bold white on blue] BROWSER NEW PAGE [/bold white on blue] 📄 {url or 'blank page'}",
-        message_group=group_id,
-    )
-    try:
-        browser_manager = get_camoufox_manager()
-
-        if not browser_manager._initialized:
-            return {
-                "success": False,
-                "error": "Browser not initialized. Use browser_initialize first.",
-            }
-
-        page = await browser_manager.new_page(url)
-
-        final_url = page.url
-        title = await page.title()
-
-        emit_info(
-            f"[green]Created new page: {final_url}[/green]", message_group=group_id
-        )
-
-        return {"success": True, "url": final_url, "title": title, "requested_url": url}
-
-    except Exception as e:
-        return {"success": False, "error": str(e), "url": url}
-
-
-async def list_pages() -> Dict[str, Any]:
-    """List all open browser pages/tabs."""
-    group_id = generate_group_id("browser_list_pages")
-    emit_info(
-        "[bold white on blue] BROWSER LIST PAGES [/bold white on blue] 📋",
-        message_group=group_id,
-    )
-    try:
-        browser_manager = get_camoufox_manager()
-
-        if not browser_manager._initialized:
-            return {"success": False, "error": "Browser not initialized"}
-
-        all_pages = await browser_manager.get_all_pages()
-
-        pages_info = []
-        for i, page in enumerate(all_pages):
-            try:
-                url = page.url
-                title = await page.title()
-                is_closed = page.is_closed()
-
-                pages_info.append(
-                    {"index": i, "url": url, "title": title, "closed": is_closed}
-                )
-            except Exception as e:
-                pages_info.append(
-                    {
-                        "index": i,
-                        "url": "Error",
-                        "title": "Error",
-                        "error": str(e),
-                        "closed": True,
-                    }
-                )
-
-        return {"success": True, "page_count": len(all_pages), "pages": pages_info}
-
-    except Exception as e:
-        return {"success": False, "error": str(e)}
-
-
-# Tool registration functions
-def register_initialize_browser(agent):
-    """Register the browser initialization tool."""
-
-    @agent.tool
-    async def browser_initialize(
-        context: RunContext,
-        headless: bool = False,
-        browser_type: str = "chromium",
-        homepage: str = "https://www.google.com",
-    ) -> Dict[str, Any]:
-        """
-        Initialize the browser with specified settings. Must be called before using other browser tools.
-
-        Args:
-            headless: Run browser in headless mode (no GUI)
-            browser_type: Browser engine (chromium, firefox, webkit)
-            homepage: Initial page to load
-
-        Returns:
-            Dict with initialization results
-        """
-        return await initialize_browser(headless, browser_type, homepage)
-
-
-def register_close_browser(agent):
-    """Register the browser close tool."""
-
-    @agent.tool
-    async def browser_close(context: RunContext) -> Dict[str, Any]:
-        """
-        Close the browser and clean up all resources.
-
-        Returns:
-            Dict with close results
-        """
-        return await close_browser()
-
-
-def register_get_browser_status(agent):
-    """Register the browser status tool."""
-
-    @agent.tool
-    async def browser_status(context: RunContext) -> Dict[str, Any]:
-        """
-        Get current browser status and information.
-
-        Returns:
-            Dict with browser status and metadata
-        """
-        return await get_browser_status()
-
-
-def register_create_new_page(agent):
-    """Register the new page creation tool."""
-
-    @agent.tool
-    async def browser_new_page(
-        context: RunContext,
-        url: Optional[str] = None,
-    ) -> Dict[str, Any]:
-        """
-        Create a new browser page/tab.
-
-        Args:
-            url: Optional URL to navigate to in the new page
-
-        Returns:
-            Dict with new page results
-        """
-        return await create_new_page(url)
-
-
-def register_list_pages(agent):
-    """Register the list pages tool."""
-
-    @agent.tool
-    async def browser_list_pages(context: RunContext) -> Dict[str, Any]:
-        """
-        List all open browser pages/tabs.
-
-        Returns:
-            Dict with information about all open pages
-        """
-        return await list_pages()