code-puppy 0.0.214__py3-none-any.whl → 0.0.366__py3-none-any.whl

code_puppy/command_line/mcp/add_command.py

@@ -1,183 +0,0 @@
-"""
-MCP Add Command - Adds new MCP servers from JSON configuration or wizard.
-"""
-
-import json
-import logging
-import os
-from typing import List, Optional
-
-from code_puppy.messaging import emit_info
-from code_puppy.tui_state import is_tui_mode
-
-from .base import MCPCommandBase
-from .wizard_utils import run_interactive_install_wizard
-
-# Configure logging
-logger = logging.getLogger(__name__)
-
-
-class AddCommand(MCPCommandBase):
-    """
-    Command handler for adding MCP servers.
-
-    Adds new MCP servers from JSON configuration or interactive wizard.
-    """
-
-    def execute(self, args: List[str], group_id: Optional[str] = None) -> None:
-        """
-        Add a new MCP server from JSON configuration or launch wizard.
-
-        Usage:
-            /mcp add                    - Launch interactive wizard
-            /mcp add <json>             - Add server from JSON config
-
-        Example JSON:
-            /mcp add {"name": "test", "type": "stdio", "command": "echo", "args": ["hello"]}
-
-        Args:
-            args: Command arguments - JSON config or empty for wizard
-            group_id: Optional message group ID for grouping related messages
-        """
-        if group_id is None:
-            group_id = self.generate_group_id()
-
-        # Check if in TUI mode and guide user to use Ctrl+T instead
-        if is_tui_mode() and not args:
-            emit_info(
-                "💡 In TUI mode, press Ctrl+T to open the MCP Install Wizard",
-                message_group=group_id,
-            )
-            emit_info(
-                "   The wizard provides a better interface for browsing and installing MCP servers.",
-                message_group=group_id,
-            )
-            return
-
-        try:
-            if args:
-                # Parse JSON from arguments
-                json_str = " ".join(args)
-
-                try:
-                    config_dict = json.loads(json_str)
-                except json.JSONDecodeError as e:
-                    emit_info(f"Invalid JSON: {e}", message_group=group_id)
-                    emit_info(
-                        "Usage: /mcp add <json> or /mcp add (for wizard)",
-                        message_group=group_id,
-                    )
-                    emit_info(
-                        'Example: /mcp add {"name": "test", "type": "stdio", "command": "echo"}',
-                        message_group=group_id,
-                    )
-                    return
-
-                # Validate required fields
-                if "name" not in config_dict:
-                    emit_info("Missing required field: 'name'", message_group=group_id)
-                    return
-                if "type" not in config_dict:
-                    emit_info("Missing required field: 'type'", message_group=group_id)
-                    return
-
-                # Add the server
-                success = self._add_server_from_json(config_dict, group_id)
-
-                if success:
-                    # Reload MCP servers
-                    try:
-                        from code_puppy.agent import reload_mcp_servers
-
-                        reload_mcp_servers()
-                    except ImportError:
-                        pass
-
-                    emit_info(
-                        "Use '/mcp list' to see all servers", message_group=group_id
-                    )
-
-            else:
-                # No arguments - launch interactive wizard with server templates
-                success = run_interactive_install_wizard(self.manager, group_id)
-
-                if success:
-                    # Reload the agent to pick up new server
-                    try:
-                        from code_puppy.agent import reload_mcp_servers
-
-                        reload_mcp_servers()
-                    except ImportError:
-                        pass
-
-        except ImportError as e:
-            logger.error(f"Failed to import: {e}")
-            emit_info("Required module not available", message_group=group_id)
-        except Exception as e:
-            logger.error(f"Error in add command: {e}")
-            emit_info(f"[red]Error adding server: {e}[/red]", message_group=group_id)
-
-    def _add_server_from_json(self, config_dict: dict, group_id: str) -> bool:
-        """
-        Add a server from JSON configuration.
-
-        Args:
-            config_dict: Server configuration dictionary
-            group_id: Message group ID
-
-        Returns:
-            True if successful, False otherwise
-        """
-        try:
-            from code_puppy.config import MCP_SERVERS_FILE
-            from code_puppy.mcp_.managed_server import ServerConfig
-
-            # Extract required fields
-            name = config_dict.pop("name")
-            server_type = config_dict.pop("type")
-            enabled = config_dict.pop("enabled", True)
-
-            # Everything else goes into config
-            server_config = ServerConfig(
-                id=f"{name}_{hash(name)}",
-                name=name,
-                type=server_type,
-                enabled=enabled,
-                config=config_dict,  # Remaining fields are server-specific config
-            )
-
-            # Register the server
-            server_id = self.manager.register_server(server_config)
-
-            if not server_id:
-                emit_info(f"Failed to add server '{name}'", message_group=group_id)
-                return False
-
-            emit_info(
-                f"✅ Added server '{name}' (ID: {server_id})", message_group=group_id
-            )
-
-            # Save to mcp_servers.json for persistence
-            if os.path.exists(MCP_SERVERS_FILE):
-                with open(MCP_SERVERS_FILE, "r") as f:
-                    data = json.load(f)
-                    servers = data.get("mcp_servers", {})
-            else:
-                servers = {}
-                data = {"mcp_servers": servers}
-
-            # Add new server
-            servers[name] = config_dict.copy()
-            servers[name]["type"] = server_type
-
-            # Save back
-            os.makedirs(os.path.dirname(MCP_SERVERS_FILE), exist_ok=True)
-            with open(MCP_SERVERS_FILE, "w") as f:
-                json.dump(data, f, indent=2)
-
-            return True
-
-        except Exception as e:
-            logger.error(f"Error adding server from JSON: {e}")
-            emit_info(f"[red]Failed to add server: {e}[/red]", message_group=group_id)
-            return False

code_puppy/messaging/spinner/textual_spinner.py

@@ -1,106 +0,0 @@
-"""
-Textual spinner implementation for TUI mode.
-"""
-
-from textual.widgets import Static
-
-from .spinner_base import SpinnerBase
-
-
-class TextualSpinner(Static):
-    """A textual spinner widget based on the SimpleSpinnerWidget."""
-
-    # Use the frames from SpinnerBase
-    FRAMES = SpinnerBase.FRAMES
-
-    def __init__(self, **kwargs):
-        """Initialize the textual spinner."""
-        super().__init__("", **kwargs)
-        self._frame_index = 0
-        self._is_spinning = False
-        self._timer = None
-        self._paused = False
-        self._previous_state = ""
-
-        # Register this spinner for global management
-        from . import register_spinner
-
-        register_spinner(self)
-
-    def start_spinning(self):
-        """Start the spinner animation using Textual's timer system."""
-        if not self._is_spinning:
-            self._is_spinning = True
-            self._frame_index = 0
-            self.update_frame_display()
-            # Start the animation timer using Textual's timer system
-            self._timer = self.set_interval(0.10, self.update_frame_display)
-
-    def stop_spinning(self):
-        """Stop the spinner animation."""
-        self._is_spinning = False
-        if self._timer:
-            self._timer.stop()
-            self._timer = None
-        self.update("")
-
-        # Unregister this spinner from global management
-        from . import unregister_spinner
-
-        unregister_spinner(self)
-
-    def update_frame(self):
-        """Update to the next frame."""
-        if self._is_spinning:
-            self._frame_index = (self._frame_index + 1) % len(self.FRAMES)
-
-    def update_frame_display(self):
-        """Update the display with the current frame."""
-        if self._is_spinning:
-            self.update_frame()
-            current_frame = self.FRAMES[self._frame_index]
-
-            # Check if we're awaiting user input to determine which message to show
-            from code_puppy.tools.command_runner import is_awaiting_user_input
-
-            if is_awaiting_user_input():
-                # Show waiting message when waiting for user input
-                message = SpinnerBase.WAITING_MESSAGE
-            else:
-                # Show thinking message during normal processing
-                message = SpinnerBase.THINKING_MESSAGE
-
-            context_info = SpinnerBase.get_context_info()
-            context_segment = (
-                f" [bold white]{context_info}[/bold white]" if context_info else ""
-            )
-
-            self.update(
-                f"[bold cyan]{message}[/bold cyan][bold cyan]{current_frame}[/bold cyan]{context_segment}"
-            )
-
-    def pause(self):
-        """Pause the spinner animation temporarily."""
-        if self._is_spinning and self._timer and not self._paused:
-            self._paused = True
-            self._timer.pause()
-            # Store current state but don't clear it completely
-            self._previous_state = self.renderable
-            self.update("")
-
-    def resume(self):
-        """Resume a paused spinner animation."""
-        # Check if we should show a spinner - don't resume if waiting for user input
-        from code_puppy.tools.command_runner import is_awaiting_user_input
-
-        if is_awaiting_user_input():
-            return  # Don't resume if waiting for user input
-
-        if self._is_spinning and self._timer and self._paused:
-            self._paused = False
-            self._timer.resume()
-            # Restore previous state instead of immediately updating display
-            if self._previous_state:
-                self.update(self._previous_state)
-            else:
-                self.update_frame_display()

code_puppy/tools/browser/camoufox_manager.py

@@ -1,216 +0,0 @@
-"""Camoufox browser manager - privacy-focused Firefox automation."""
-
-from pathlib import Path
-from typing import Optional
-
-import camoufox
-from camoufox.addons import DefaultAddons
-from camoufox.exceptions import CamoufoxNotInstalled, UnsupportedVersion
-from camoufox.locale import ALLOW_GEOIP, download_mmdb
-from camoufox.pkgman import CamoufoxFetcher, camoufox_path
-from playwright.async_api import Browser, BrowserContext, Page
-
-
-from code_puppy.messaging import emit_info
-
-
-class CamoufoxManager:
-    """Singleton browser manager for Camoufox (privacy-focused Firefox) automation."""
-
-    _instance: Optional["CamoufoxManager"] = None
-    _browser: Optional[Browser] = None
-    _context: Optional[BrowserContext] = None
-    _initialized: bool = False
-
-    def __new__(cls):
-        if cls._instance is None:
-            cls._instance = super().__new__(cls)
-        return cls._instance
-
-    def __init__(self):
-        # Only initialize once
-        if hasattr(self, "_init_done"):
-            return
-        self._init_done = True
-
-        self.headless = False
-        self.homepage = "https://www.google.com"
-        # Camoufox-specific settings
-        self.geoip = True  # Enable GeoIP spoofing
-        self.block_webrtc = True  # Block WebRTC for privacy
-        self.humanize = True  # Add human-like behavior
-
-        # Persistent profile directory for consistent browser state across runs
-        self.profile_dir = self._get_profile_directory()
-
-    @classmethod
-    def get_instance(cls) -> "CamoufoxManager":
-        """Get the singleton instance."""
-        if cls._instance is None:
-            cls._instance = cls()
-        return cls._instance
-
-    def _get_profile_directory(self) -> Path:
-        """Get or create the persistent profile directory.
-
-        Returns a Path object pointing to ~/.code_puppy/camoufox_profile
-        where browser data (cookies, history, bookmarks, etc.) will be stored.
-        """
-        profile_path = Path.home() / ".code_puppy" / "camoufox_profile"
-        profile_path.mkdir(parents=True, exist_ok=True)
-        return profile_path
-
-    async def async_initialize(self) -> None:
-        """Initialize Camoufox browser."""
-        if self._initialized:
-            return
-
-        try:
-            emit_info("[yellow]Initializing Camoufox (privacy Firefox)...[/yellow]")
-
-            # Ensure Camoufox binary and dependencies are fetched before launching
-            await self._prefetch_camoufox()
-
-            await self._initialize_camoufox()
-            emit_info(
-                "[green]✅ Camoufox initialized successfully (privacy-focused Firefox)[/green]"
-            )
-            self._initialized = True
-
-        except Exception:
-            await self._cleanup()
-            raise
-
-    async def _initialize_camoufox(self) -> None:
-        """Try to start Camoufox with the configured privacy settings."""
-        emit_info(f"[cyan]📁 Using persistent profile: {self.profile_dir}[/cyan]")
-
-        camoufox_instance = camoufox.AsyncCamoufox(
-            headless=self.headless,
-            block_webrtc=self.block_webrtc,
-            humanize=self.humanize,
-            exclude_addons=list(DefaultAddons),
-            persistent_context=True,
-            user_data_dir=str(self.profile_dir),
-            addons=[],
-        )
-
-        self._browser = camoufox_instance.browser
-        # Use persistent storage directory for browser context
-        # This ensures cookies, localStorage, history, etc. persist across runs
-        if not self._initialized:
-            self._context = await camoufox_instance.start()
-            self._initialized = True
-            # Do not auto-open a page here to avoid duplicate windows/tabs.
-
-    async def get_current_page(self) -> Optional[Page]:
-        """Get the currently active page. Lazily creates one if none exist."""
-        if not self._initialized or not self._context:
-            await self.async_initialize()
-
-        if not self._context:
-            return None
-
-        pages = self._context.pages
-        if pages:
-            return pages[0]
-
-        # Lazily create a new blank page without navigation
-        return await self._context.new_page()
-
-    async def new_page(self, url: Optional[str] = None) -> Page:
-        """Create a new page and optionally navigate to URL."""
-        if not self._initialized:
-            await self.async_initialize()
-
-        page = await self._context.new_page()
-        if url:
-            await page.goto(url)
-        return page
-
-    async def _prefetch_camoufox(self) -> None:
-        """Prefetch Camoufox binary and dependencies."""
-        emit_info(
-            "[cyan]🔍 Ensuring Camoufox binary and dependencies are up-to-date...[/cyan]"
-        )
-
-        needs_install = False
-        try:
-            camoufox_path(download_if_missing=False)
-            emit_info("[cyan]🗃️ Using cached Camoufox installation[/cyan]")
-        except (CamoufoxNotInstalled, FileNotFoundError):
-            emit_info("[cyan]📥 Camoufox not found, installing fresh copy[/cyan]")
-            needs_install = True
-        except UnsupportedVersion:
-            emit_info("[cyan]♻️ Camoufox update required, reinstalling[/cyan]")
-            needs_install = True
-
-        if needs_install:
-            CamoufoxFetcher().install()
-
-        # Fetch GeoIP database if enabled
-        if ALLOW_GEOIP:
-            download_mmdb()
-
-        emit_info("[cyan]📦 Camoufox dependencies ready[/cyan]")
-
-    async def close_page(self, page: Page) -> None:
-        """Close a specific page."""
-        await page.close()
-
-    async def get_all_pages(self) -> list[Page]:
-        """Get all open pages."""
-        if not self._context:
-            return []
-        return self._context.pages
-
-    async def _cleanup(self) -> None:
-        """Clean up browser resources and save persistent state."""
-        try:
-            # Save browser state before closing (cookies, localStorage, etc.)
-            if self._context:
-                try:
-                    storage_state_path = self.profile_dir / "storage_state.json"
-                    await self._context.storage_state(path=str(storage_state_path))
-                    emit_info(
-                        f"[green]💾 Browser state saved to {storage_state_path}[/green]"
-                    )
-                except Exception as e:
-                    emit_info(
-                        f"[yellow]Warning: Could not save storage state: {e}[/yellow]"
-                    )
-
-                await self._context.close()
-                self._context = None
-            if self._browser:
-                await self._browser.close()
-                self._browser = None
-            self._initialized = False
-        except Exception as e:
-            emit_info(f"[yellow]Warning during cleanup: {e}[/yellow]")
-
-    async def close(self) -> None:
-        """Close the browser and clean up resources."""
-        await self._cleanup()
-        emit_info("[yellow]Camoufox browser closed[/yellow]")
-
-    def __del__(self):
-        """Ensure cleanup on object destruction."""
-        # Note: Can't use async in __del__, so this is just a fallback
-        if self._initialized:
-            import asyncio
-
-            try:
-                loop = asyncio.get_event_loop()
-                if loop.is_running():
-                    loop.create_task(self._cleanup())
-                else:
-                    loop.run_until_complete(self._cleanup())
-            except Exception:
-                pass  # Best effort cleanup
-
-
-# Convenience function for getting the singleton instance
-def get_camoufox_manager() -> CamoufoxManager:
-    """Get the singleton CamoufoxManager instance."""
-    return CamoufoxManager.get_instance()

code_puppy/tools/browser/vqa_agent.py

@@ -1,70 +0,0 @@
-"""Utilities for running visual question-answering via pydantic-ai."""
-
-from __future__ import annotations
-
-from functools import lru_cache
-
-from pydantic import BaseModel, Field
-from pydantic_ai import Agent, BinaryContent
-
-from code_puppy.config import get_use_dbos, get_vqa_model_name
-from code_puppy.model_factory import ModelFactory
-
-
-class VisualAnalysisResult(BaseModel):
-    """Structured response from the VQA agent."""
-
-    answer: str
-    confidence: float = Field(ge=0.0, le=1.0)
-    observations: str
-
-
-@lru_cache(maxsize=1)
-def _load_vqa_agent(model_name: str) -> Agent[None, VisualAnalysisResult]:
-    """Create a cached agent instance for visual analysis."""
-    models_config = ModelFactory.load_config()
-    model = ModelFactory.get_model(model_name, models_config)
-
-    instructions = (
-        "You are a visual analysis specialist. Answer the user's question about the provided image. "
-        "Always respond using the structured schema: answer, confidence (0-1 float), observations. "
-        "Confidence reflects how certain you are about the answer. Observations should include useful, concise context."
-    )
-
-    vqa_agent = Agent(
-        model=model,
-        instructions=instructions,
-        output_type=VisualAnalysisResult,
-        retries=2,
-    )
-
-    if get_use_dbos():
-        from pydantic_ai.durable_exec.dbos import DBOSAgent
-
-        dbos_agent = DBOSAgent(vqa_agent, name="vqa-agent")
-        return dbos_agent
-
-    return vqa_agent
-
-
-def _get_vqa_agent() -> Agent[None, VisualAnalysisResult]:
-    """Return a cached VQA agent configured with the current model."""
-    model_name = get_vqa_model_name()
-    # lru_cache keyed by model_name ensures refresh when configuration changes
-    return _load_vqa_agent(model_name)
-
-
-def run_vqa_analysis(
-    question: str,
-    image_bytes: bytes,
-    media_type: str = "image/png",
-) -> VisualAnalysisResult:
-    """Execute the VQA agent synchronously against screenshot bytes."""
-    agent = _get_vqa_agent()
-    result = agent.run_sync(
-        [
-            question,
-            BinaryContent(data=image_bytes, media_type=media_type),
-        ]
-    )
-    return result.output

code_puppy/tui/__init__.py

@@ -1,10 +0,0 @@
-"""
-Code Puppy TUI package.
-
-This package provides a modern Text User Interface for Code Puppy using the Textual framework.
-It maintains compatibility with existing functionality while providing an enhanced user experience.
-"""
-
-from .app import CodePuppyTUI, run_textual_ui
-
-__all__ = ["CodePuppyTUI", "run_textual_ui"]