squidbot 0.1.0__py3-none-any.whl

squidbot/skills.py

@@ -0,0 +1,141 @@
+"""Skills system - load markdown prompts to teach agent behaviors."""
+
+import asyncio
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Optional
+
+import aiofiles
+
+from .config import DATA_DIR
+
+SKILLS_DIR = DATA_DIR / "skills"
+
+
+@dataclass
+class Skill:
+    """A skill loaded from a markdown file."""
+
+    name: str
+    description: str
+    content: str
+    file_path: Path
+    metadata: dict
+
+
+def parse_frontmatter(content: str) -> tuple[dict, str]:
+    """Parse YAML frontmatter from markdown content."""
+    metadata = {}
+    body = content
+
+    if content.startswith("---"):
+        parts = content.split("---", 2)
+        if len(parts) >= 3:
+            frontmatter = parts[1].strip()
+            body = parts[2].strip()
+
+            for line in frontmatter.split("\n"):
+                if ":" in line:
+                    key, value = line.split(":", 1)
+                    metadata[key.strip()] = value.strip()
+
+    return metadata, body
+
+
+async def load_skill(skill_dir: Path) -> Optional[Skill]:
+    """Load a skill from a directory containing SKILL.md."""
+    skill_file = skill_dir / "SKILL.md"
+    if not skill_file.exists():
+        skill_file = skill_dir / "skill.md"
+        if not skill_file.exists():
+            return None
+
+    try:
+        async with aiofiles.open(skill_file, "r", encoding="utf-8") as f:
+            content = await f.read()
+
+        metadata, body = parse_frontmatter(content)
+
+        return Skill(
+            name=metadata.get("name", skill_dir.name),
+            description=metadata.get("description", ""),
+            content=body,
+            file_path=skill_file,
+            metadata=metadata,
+        )
+    except Exception:
+        return None
+
+
+async def load_all_skills(skills_dir: Path = None) -> list[Skill]:
+    """Load all skills from the skills directory."""
+    if skills_dir is None:
+        skills_dir = SKILLS_DIR
+
+    if not skills_dir.exists():
+        return []
+
+    # Load skills concurrently
+    tasks = []
+    for item in skills_dir.iterdir():
+        if item.is_dir():
+            tasks.append(load_skill(item))
+
+    results = await asyncio.gather(*tasks)
+    return [s for s in results if s is not None]
+
+
+def format_skills_for_prompt(skills: list[Skill]) -> str:
+    """Format skills as a prompt section for the LLM."""
+    if not skills:
+        return ""
+
+    lines = ["## Available Skills\n"]
+    for skill in skills:
+        lines.append(f"### {skill.name}")
+        if skill.description:
+            lines.append(f"*{skill.description}*\n")
+        lines.append(skill.content)
+        lines.append("")
+
+    return "\n".join(lines)
+
+
+async def get_skills_context() -> str:
+    """Get all skills formatted for system prompt."""
+    skills = await load_all_skills()
+    return format_skills_for_prompt(skills)
+
+
+async def ensure_skills_dir():
+    """Ensure skills directory exists."""
+    SKILLS_DIR.mkdir(parents=True, exist_ok=True)
+
+
+async def create_example_skill():
+    """Create an example skill if none exist."""
+    await ensure_skills_dir()
+
+    example_dir = SKILLS_DIR / "weather"
+    if example_dir.exists():
+        return
+
+    example_dir.mkdir(parents=True, exist_ok=True)
+    skill_content = """---
+name: weather
+description: Get weather information for a location
+---
+When the user asks about weather:
+
+1. Use the `web_search` tool to search for current weather
+2. Search query format: "weather in {city} today"
+3. Extract the temperature, conditions, and forecast
+4. Present the information in a friendly format
+
+Example:
+User: "What's the weather in Tokyo?"
+→ Search: "weather in Tokyo today"
+→ Response: "It's currently 18°C in Tokyo with partly cloudy skies..."
+"""
+    async with aiofiles.open(example_dir / "SKILL.md", "w") as f:
+        await f.write(skill_content)

squidbot/skills_template/reminder/SKILL.md

@@ -0,0 +1,13 @@
+---
+name: reminder
+description: Set reminders and scheduled tasks
+---
+When user wants to set a reminder:
+
+1. Extract the message and time
+2. Use `cron_create` tool with appropriate delay_minutes or cron_expression
+3. Confirm the reminder was set
+
+Examples:
+- "Remind me in 10 minutes" → delay_minutes=10
+- "Remind me daily at 9am" → cron_expression="0 9 * * *"

squidbot/skills_template/search/SKILL.md

@@ -0,0 +1,11 @@
+---
+name: search
+description: Search the web for information
+---
+When user asks a question requiring current information:
+
+1. Use `web_search` tool with a clear query
+2. Review the results
+3. Synthesize a helpful answer with sources
+
+Always cite sources when providing factual information.

squidbot/skills_template/summarize/SKILL.md

@@ -0,0 +1,14 @@
+---
+name: summarize
+description: Summarize text or web content
+---
+When user asks to summarize something:
+
+1. If given a URL, use `browser_navigate` to visit it
+2. Use `browser_get_text` to extract content
+3. Provide a concise summary with key points
+
+Format:
+- **TL;DR**: One sentence summary
+- **Key Points**: 3-5 bullet points
+- **Details**: Brief elaboration if needed

squidbot/tools/__init__.py

@@ -0,0 +1,100 @@
+"""Tool registry - all available tools for the agent."""
+
+import logging
+
+from .base import Tool
+from .browser import (BrowserClickTool, BrowserGetTextTool,
+                      BrowserNavigateTool, BrowserScreenshotTool,
+                      BrowserSnapshotTool, BrowserTypeTool)
+from .coding import get_coding_tools
+from .cron import CronClearTool, CronCreateTool, CronDeleteTool, CronListTool
+from .memory_tool import (MemoryAddTool, MemoryDeleteTool, MemoryListTool,
+                          MemorySearchTool)
+from .web_search import WebSearchTool
+
+logger = logging.getLogger(__name__)
+
+# Core tools (always available)
+CORE_TOOLS: list[Tool] = [
+    # Memory (SQLite + vector search)
+    MemoryAddTool(),
+    MemorySearchTool(),
+    MemoryListTool(),
+    MemoryDeleteTool(),
+    # Web search
+    WebSearchTool(),
+    # Browser
+    BrowserNavigateTool(),
+    BrowserScreenshotTool(),
+    BrowserSnapshotTool(),
+    BrowserClickTool(),
+    BrowserTypeTool(),
+    BrowserGetTextTool(),
+    # Scheduling
+    CronCreateTool(),
+    CronListTool(),
+    CronDeleteTool(),
+    CronClearTool(),
+    # Coding (Zig + Python)
+    *get_coding_tools(),
+]
+
+# Plugin tools (loaded dynamically)
+_plugin_tools: list[Tool] = []
+_plugins_loaded = False
+
+
+def _load_plugins() -> None:
+    """Load plugins and their tools."""
+    global _plugin_tools, _plugins_loaded
+
+    if _plugins_loaded:
+        return
+
+    try:
+        from ..plugins import get_registry, load_builtin_plugins
+
+        # Load all built-in plugins
+        load_builtin_plugins()
+
+        # Get tools from all plugins
+        registry = get_registry()
+        _plugin_tools = registry.get_all_tools()
+
+        logger.info(f"Loaded {len(_plugin_tools)} tools from plugins")
+
+    except Exception as e:
+        logger.warning(f"Failed to load plugins: {e}")
+        _plugin_tools = []
+
+    _plugins_loaded = True
+
+
+def get_all_tools() -> list[Tool]:
+    """Get all tools including plugin tools."""
+    _load_plugins()
+    return CORE_TOOLS + _plugin_tools
+
+
+# Legacy alias for backward compatibility
+ALL_TOOLS = CORE_TOOLS  # Will be updated after first call to get_all_tools()
+
+
+def get_tool_by_name(name: str) -> Tool | None:
+    """Get a tool by its name."""
+    for tool in get_all_tools():
+        if tool.name == name:
+            return tool
+    return None
+
+
+def get_openai_tools() -> list[dict]:
+    """Get all tools in OpenAI format."""
+    return [tool.to_openai_tool() for tool in get_all_tools()]
+
+
+def reload_plugins() -> None:
+    """Reload all plugins (useful for development)."""
+    global _plugins_loaded
+    _plugins_loaded = False
+    _load_plugins()

squidbot/tools/base.py

@@ -0,0 +1,42 @@
+"""Base tool class and types."""
+
+from abc import ABC, abstractmethod
+from typing import Any
+
+
+class Tool(ABC):
+    """Base class for all tools."""
+
+    @property
+    @abstractmethod
+    def name(self) -> str:
+        """Tool name for OpenAI function calling."""
+        pass
+
+    @property
+    @abstractmethod
+    def description(self) -> str:
+        """Tool description."""
+        pass
+
+    @property
+    @abstractmethod
+    def parameters(self) -> dict:
+        """JSON Schema for tool parameters."""
+        pass
+
+    @abstractmethod
+    async def execute(self, **kwargs) -> Any:
+        """Execute the tool with given parameters."""
+        pass
+
+    def to_openai_tool(self) -> dict:
+        """Convert to OpenAI tool format."""
+        return {
+            "type": "function",
+            "function": {
+                "name": self.name,
+                "description": self.description,
+                "parameters": self.parameters,
+            },
+        }

squidbot/tools/browser.py

@@ -0,0 +1,311 @@
+"""Browser automation tools using Playwright."""
+
+import base64
+from typing import Optional
+
+from playwright.async_api import Browser, Page, async_playwright
+
+from .base import Tool
+
+
+class BrowserManager:
+    """Manages browser instance and pages."""
+
+    _instance: Optional["BrowserManager"] = None
+    _browser: Optional[Browser] = None
+    _page: Optional[Page] = None
+    _playwright = None
+
+    @classmethod
+    async def get_instance(cls) -> "BrowserManager":
+        if cls._instance is None:
+            cls._instance = cls()
+        return cls._instance
+
+    async def get_page(self) -> Page:
+        """Get or create browser page."""
+        if self._browser is None:
+            self._playwright = await async_playwright().start()
+            self._browser = await self._playwright.chromium.launch(headless=True)
+
+        if self._page is None or self._page.is_closed():
+            self._page = await self._browser.new_page()
+
+        return self._page
+
+    async def close(self):
+        """Close browser."""
+        if self._browser:
+            await self._browser.close()
+            self._browser = None
+            self._page = None
+        if self._playwright:
+            await self._playwright.stop()
+            self._playwright = None
+
+
+class BrowserNavigateTool(Tool):
+    """Navigate to a URL."""
+
+    @property
+    def name(self) -> str:
+        return "browser_navigate"
+
+    @property
+    def description(self) -> str:
+        return "Navigate the browser to a specific website URL. USE THIS when you need to visit a specific website (like techcrunch.com, news sites, etc.) to read its actual current content. After navigating, use browser_get_text to read the page content."
+
+    @property
+    def parameters(self) -> dict:
+        return {
+            "type": "object",
+            "properties": {
+                "url": {"type": "string", "description": "URL to navigate to"}
+            },
+            "required": ["url"],
+        }
+
+    async def execute(self, url: str) -> str:
+        try:
+            manager = await BrowserManager.get_instance()
+            page = await manager.get_page()
+            await page.goto(url, wait_until="domcontentloaded")
+            return f"Navigated to: {page.url}\nTitle: {await page.title()}"
+        except Exception as e:
+            return f"Navigation error: {str(e)}"
+
+
+class BrowserScreenshotTool(Tool):
+    """Take a screenshot of the current page."""
+
+    @property
+    def name(self) -> str:
+        return "browser_screenshot"
+
+    @property
+    def description(self) -> str:
+        return "Take a screenshot of the current browser page. Returns base64 encoded image."
+
+    @property
+    def parameters(self) -> dict:
+        return {
+            "type": "object",
+            "properties": {
+                "full_page": {
+                    "type": "boolean",
+                    "description": "Capture full page (default false)",
+                    "default": False,
+                }
+            },
+            "required": [],
+        }
+
+    async def execute(self, full_page: bool = False) -> str:
+        try:
+            import tempfile
+            from datetime import datetime
+
+            manager = await BrowserManager.get_instance()
+            page = await manager.get_page()
+            screenshot = await page.screenshot(full_page=full_page)
+
+            # Save to temp file for Telegram
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            temp_path = tempfile.gettempdir() + f"/squidbot_screenshot_{timestamp}.png"
+            with open(temp_path, "wb") as f:
+                f.write(screenshot)
+
+            # Return special format that server can detect
+            return (
+                f"[SCREENSHOT:{temp_path}] Screenshot saved ({len(screenshot)} bytes)"
+            )
+        except Exception as e:
+            return f"Screenshot error: {str(e)}"
+
+
+class BrowserSnapshotTool(Tool):
+    """Get accessibility tree snapshot of the page."""
+
+    @property
+    def name(self) -> str:
+        return "browser_snapshot"
+
+    @property
+    def description(self) -> str:
+        return "Get a text snapshot of the current page content (accessibility tree). Use this to understand page structure before interacting."
+
+    @property
+    def parameters(self) -> dict:
+        return {"type": "object", "properties": {}, "required": []}
+
+    async def execute(self) -> str:
+        try:
+            manager = await BrowserManager.get_instance()
+            page = await manager.get_page()
+
+            # Get simplified page content
+            content = await page.evaluate(
+                """() => {
+                const walk = (node, depth = 0) => {
+                    let result = [];
+                    const indent = '  '.repeat(depth);
+
+                    if (node.nodeType === Node.TEXT_NODE) {
+                        const text = node.textContent.trim();
+                        if (text) result.push(indent + text);
+                    } else if (node.nodeType === Node.ELEMENT_NODE) {
+                        const tag = node.tagName.toLowerCase();
+                        const role = node.getAttribute('role') || '';
+                        const name = node.getAttribute('aria-label') || node.getAttribute('name') || '';
+                        const href = node.getAttribute('href') || '';
+
+                        let info = tag;
+                        if (role) info += ` [${role}]`;
+                        if (name) info += ` "${name}"`;
+                        if (href && tag === 'a') info += ` -> ${href}`;
+
+                        if (['script', 'style', 'noscript'].includes(tag)) return result;
+
+                        if (['button', 'a', 'input', 'select', 'textarea', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6'].includes(tag)) {
+                            result.push(indent + info);
+                        }
+
+                        for (const child of node.childNodes) {
+                            result = result.concat(walk(child, depth + 1));
+                        }
+                    }
+                    return result;
+                };
+                return walk(document.body).slice(0, 100).join('\\n');
+            }"""
+            )
+
+            title = await page.title()
+            url = page.url
+            return f"Page: {title}\nURL: {url}\n\nContent:\n{content}"
+        except Exception as e:
+            return f"Snapshot error: {str(e)}"
+
+
+class BrowserClickTool(Tool):
+    """Click an element on the page."""
+
+    @property
+    def name(self) -> str:
+        return "browser_click"
+
+    @property
+    def description(self) -> str:
+        return "Click an element on the page by text content or CSS selector."
+
+    @property
+    def parameters(self) -> dict:
+        return {
+            "type": "object",
+            "properties": {
+                "selector": {
+                    "type": "string",
+                    "description": "CSS selector or text to click (e.g., 'button.submit' or 'text=Sign In')",
+                }
+            },
+            "required": ["selector"],
+        }
+
+    async def execute(self, selector: str) -> str:
+        try:
+            manager = await BrowserManager.get_instance()
+            page = await manager.get_page()
+
+            # Try as text selector first if no CSS chars
+            if not any(c in selector for c in ".#[]>+~:"):
+                try:
+                    await page.get_by_text(selector).first.click(timeout=5000)
+                    return f"Clicked element with text: {selector}"
+                except:
+                    pass
+
+            await page.click(selector, timeout=5000)
+            return f"Clicked: {selector}"
+        except Exception as e:
+            return f"Click error: {str(e)}"
+
+
+class BrowserTypeTool(Tool):
+    """Type text into an input field."""
+
+    @property
+    def name(self) -> str:
+        return "browser_type"
+
+    @property
+    def description(self) -> str:
+        return "Type text into an input field."
+
+    @property
+    def parameters(self) -> dict:
+        return {
+            "type": "object",
+            "properties": {
+                "selector": {
+                    "type": "string",
+                    "description": "CSS selector for the input field",
+                },
+                "text": {"type": "string", "description": "Text to type"},
+                "submit": {
+                    "type": "boolean",
+                    "description": "Press Enter after typing (default false)",
+                    "default": False,
+                },
+            },
+            "required": ["selector", "text"],
+        }
+
+    async def execute(self, selector: str, text: str, submit: bool = False) -> str:
+        try:
+            manager = await BrowserManager.get_instance()
+            page = await manager.get_page()
+            await page.fill(selector, text)
+            if submit:
+                await page.press(selector, "Enter")
+            return f"Typed '{text}' into {selector}" + (
+                " and submitted" if submit else ""
+            )
+        except Exception as e:
+            return f"Type error: {str(e)}"
+
+
+class BrowserGetTextTool(Tool):
+    """Get text content from the page."""
+
+    @property
+    def name(self) -> str:
+        return "browser_get_text"
+
+    @property
+    def description(self) -> str:
+        return "Get the actual text content from the current browser page. Use this after browser_navigate to read and extract information from the website. Returns the full page text for summarization or analysis."
+
+    @property
+    def parameters(self) -> dict:
+        return {
+            "type": "object",
+            "properties": {
+                "selector": {
+                    "type": "string",
+                    "description": "CSS selector (optional, defaults to body)",
+                }
+            },
+            "required": [],
+        }
+
+    async def execute(self, selector: str = "body") -> str:
+        try:
+            manager = await BrowserManager.get_instance()
+            page = await manager.get_page()
+            text = await page.inner_text(selector)
+            # Limit output
+            if len(text) > 5000:
+                text = text[:5000] + "\n...(truncated)"
+            return text
+        except Exception as e:
+            return f"Get text error: {str(e)}"