squidbot 0.1.0__py3-none-any.whl

squidbot/__init__.py

@@ -0,0 +1,5 @@
+"""
+SquidBot - Autonomous AI agent with Telegram, tool chaining, skills, and proactive messaging.
+"""
+
+__version__ = "0.1.0"

squidbot/agent.py

@@ -0,0 +1,263 @@
+"""Core autonomous agent loop with tool chaining."""
+
+import asyncio
+import json
+import logging
+from typing import Any
+
+from openai import AsyncOpenAI
+
+from .character import get_character_prompt
+from .config import DATA_DIR, OPENAI_API_KEY, OPENAI_MODEL
+from .memory_db import get_memory_context
+from .skills import get_skills_context
+from .tools import get_openai_tools, get_tool_by_name
+
+logger = logging.getLogger(__name__)
+
+# Initialize OpenAI client
+client = AsyncOpenAI(api_key=OPENAI_API_KEY)
+
+# Base system prompt (DATA_DIR will be injected at runtime)
+BASE_SYSTEM_PROMPT_TEMPLATE = """You are an autonomous AI agent with access to tools. You can:
+- Remember information using memory tools (with semantic search)
+- Search the web for current information (web_search)
+- Browse specific websites using Playwright browser tools
+- Take screenshots of websites (browser_screenshot)
+- Schedule reminders and recurring tasks (cron_create)
+- Write and run Zig/Python code in the coding workspace (code_write, code_run)
+
+CRITICAL: You MUST use tools to perform actions. NEVER pretend or claim to have done something without actually calling the tool. If asked to visit a website, you MUST call browser_navigate. If asked to take a screenshot, you MUST call browser_screenshot.
+
+============================================================
+SECURITY RESTRICTIONS - STRICTLY ENFORCED
+============================================================
+
+WORKSPACE BOUNDARY:
+- Your workspace is: {squidbot_home}
+- You may ONLY access files and folders within this directory
+- NEVER attempt to access, read, or write files outside this directory
+- NEVER access system directories like /etc, /var, /usr, /home, ~/, or any path outside your workspace
+
+CONFIDENTIAL DATA - NEVER EXPOSE OR TRANSMIT:
+- Private keys (any format: PEM, hex, base64)
+- Mnemonics / seed phrases (12, 24 word recovery phrases)
+- .env files or environment variables containing secrets
+- API keys, tokens, or credentials
+- Passwords or authentication secrets
+- Wallet files or keystore files
+- SSH keys (id_rsa, id_ed25519, etc.)
+- SSL/TLS certificates and private keys
+- Database connection strings with credentials
+- Shell config files (~/.zshrc, ~/.bashrc, ~/.bash_profile, ~/.profile)
+- Any file containing "private", "secret", "key", "mnemonic", "seed" in sensitive context
+- Git credentials (~/.git-credentials, ~/.gitconfig with tokens)
+- Cloud credentials (~/.aws/*, ~/.gcloud/*, ~/.azure/*)
+
+IF ASKED TO EXPOSE CONFIDENTIAL DATA:
+- Politely REFUSE the request
+- Explain that exposing such data would be a security risk
+- NEVER include confidential data in responses, logs, or memory storage
+- NEVER transmit confidential data via web searches or browser tools
+
+============================================================
+
+Available Browser Tools:
+- browser_navigate: Open a URL in the browser (REQUIRED before any other browser action)
+- browser_get_text: Get the text content of the current page
+- browser_screenshot: Take a screenshot of the current page (returns image file)
+- browser_snapshot: Get accessibility tree of the page
+- browser_click: Click an element on the page
+- browser_type: Type text into an input field
+
+Available Coding Tools:
+- code_write: Write Zig (.zig) or Python (.py) code to workspace
+- code_read: Read code from workspace
+- code_run: Execute Zig or Python files
+- code_list: List projects and files
+- code_delete: Delete files or projects
+- zig_build: Build Zig projects
+- zig_test: Run Zig tests
+- python_test: Run Python tests with pytest
+
+IMPORTANT - Tool Selection:
+- To visit a website: MUST call browser_navigate first
+- To take a screenshot: MUST call browser_navigate, then browser_screenshot
+- To read page content: MUST call browser_navigate, then browser_get_text
+- For general searches: use web_search
+- To write code: use code_write with project name and filename
+
+When given a task, use the appropriate tools. Do NOT say you did something unless you actually called the tool.
+"""
+
+
+def get_base_system_prompt() -> str:
+    """Get base system prompt with DATA_DIR injected."""
+    return BASE_SYSTEM_PROMPT_TEMPLATE.format(squidbot_home=str(DATA_DIR))
+
+
+async def build_system_prompt() -> str:
+    """Build the complete system prompt with character, skills, and memory."""
+    parts = [get_base_system_prompt()]
+
+    # Add character/personality
+    character_prompt = await get_character_prompt()
+    if character_prompt:
+        parts.append(character_prompt)
+
+    # Add skills
+    skills_context = await get_skills_context()
+    if skills_context:
+        parts.append(skills_context)
+
+    # Add memory context
+    memory_context = await get_memory_context()
+    if memory_context:
+        parts.append(memory_context)
+
+    return "\n\n".join(parts)
+
+
+async def execute_tool(name: str, arguments: dict) -> str:
+    """Execute a tool by name with given arguments."""
+    tool = get_tool_by_name(name)
+    if not tool:
+        return f"Error: Unknown tool '{name}'"
+
+    try:
+        result = await tool.execute(**arguments)
+        return str(result)
+    except Exception as e:
+        logger.exception(f"Tool execution error: {name}")
+        return f"Error executing {name}: {str(e)}"
+
+
+async def run_agent(
+    user_message: str, history: list[dict] | None = None, max_iterations: int = 10
+) -> str:
+    """
+    Run the autonomous agent loop.
+
+    The agent will:
+    1. Send message to LLM
+    2. If LLM returns tool calls, execute them
+    3. Add results to history and loop back to step 1
+    4. If LLM returns text, return it (loop ends)
+
+    Args:
+        user_message: The user's input message
+        history: Optional conversation history
+        max_iterations: Maximum tool-calling iterations (safety limit)
+
+    Returns:
+        The agent's final text response
+    """
+    if history is None:
+        history = []
+
+    # Build system prompt with character, skills, and memory
+    system_prompt = await build_system_prompt()
+
+    # Prepare messages
+    messages = [
+        {"role": "system", "content": system_prompt},
+        *history,
+        {"role": "user", "content": user_message},
+    ]
+
+    # Get tools
+    tools = get_openai_tools()
+
+    iteration = 0
+    while iteration < max_iterations:
+        iteration += 1
+        logger.info(f"Agent iteration {iteration}")
+
+        # Call OpenAI
+        response = await client.chat.completions.create(
+            model=OPENAI_MODEL, messages=messages, tools=tools, tool_choice="auto"
+        )
+
+        assistant_message = response.choices[0].message
+
+        # Check if we have tool calls
+        if assistant_message.tool_calls:
+            # Add assistant message to history
+            messages.append(
+                {
+                    "role": "assistant",
+                    "content": assistant_message.content or "",
+                    "tool_calls": [
+                        {
+                            "id": tc.id,
+                            "type": "function",
+                            "function": {
+                                "name": tc.function.name,
+                                "arguments": tc.function.arguments,
+                            },
+                        }
+                        for tc in assistant_message.tool_calls
+                    ],
+                }
+            )
+
+            # Execute tools in parallel
+            tool_tasks = []
+            for tc in assistant_message.tool_calls:
+                name = tc.function.name
+                try:
+                    args = json.loads(tc.function.arguments)
+                except json.JSONDecodeError:
+                    args = {}
+
+                logger.info(f"Executing tool: {name} with args: {args}")
+                tool_tasks.append((tc.id, name, execute_tool(name, args)))
+
+            # Gather results
+            results = await asyncio.gather(*[t[2] for t in tool_tasks])
+
+            # Add tool results to messages
+            for (tool_call_id, tool_name, _), result in zip(tool_tasks, results):
+                logger.info(f"Tool {tool_name} result: {result[:200]}...")
+                messages.append(
+                    {"role": "tool", "tool_call_id": tool_call_id, "content": result}
+                )
+
+            # Continue loop - send results back to LLM
+            continue
+
+        else:
+            # No tool calls - we have a final response
+            final_response = assistant_message.content or ""
+            logger.info(f"Agent complete after {iteration} iterations")
+            return final_response
+
+    # Max iterations reached
+    logger.warning(f"Agent hit max iterations ({max_iterations})")
+    return "I apologize, but I've reached the maximum number of steps for this task. Here's what I've done so far - please let me know if you'd like me to continue."
+
+
+async def run_agent_with_history(
+    user_message: str, session_history: list[dict]
+) -> tuple[str, list[dict]]:
+    """
+    Run agent and return updated history.
+
+    Args:
+        user_message: User input
+        session_history: Existing session history
+
+    Returns:
+        Tuple of (response, updated_history)
+    """
+    response = await run_agent(user_message, session_history)
+
+    # Update history with this exchange
+    session_history.append({"role": "user", "content": user_message})
+    session_history.append({"role": "assistant", "content": response})
+
+    # Keep history manageable (last 20 exchanges)
+    if len(session_history) > 40:
+        session_history = session_history[-40:]
+
+    return response, session_history

squidbot/channels.py

@@ -0,0 +1,271 @@
+"""
+Channel Abstraction - Unified interface for messaging platforms.
+
+Provides a common interface for sending messages to different channels
+(Telegram, WhatsApp, Discord, etc.).
+"""
+
+import asyncio
+import logging
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from typing import Any, Awaitable, Callable
+
+from .session import ChannelType, DeliveryContext
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class MessagePayload:
+    """Unified message payload for all channels."""
+
+    text: str
+    media_paths: list[str] | None = None  # Paths to images/files
+    reply_to_id: str | None = None
+    metadata: dict[str, Any] | None = None
+
+
+class ChannelAdapter(ABC):
+    """Abstract base class for channel adapters."""
+
+    channel_type: ChannelType
+
+    @abstractmethod
+    async def send_message(
+        self,
+        context: DeliveryContext,
+        payload: MessagePayload,
+    ) -> bool:
+        """Send a message to the channel. Returns True on success."""
+        pass
+
+    @abstractmethod
+    async def send_typing(self, context: DeliveryContext) -> None:
+        """Send typing indicator to the channel."""
+        pass
+
+    def supports_media(self) -> bool:
+        """Whether this channel supports media attachments."""
+        return self.channel_type.supports_media
+
+    def max_message_length(self) -> int:
+        """Maximum message length for this channel."""
+        return self.channel_type.max_message_length
+
+    def split_message(self, text: str) -> list[str]:
+        """Split a long message into chunks that fit the channel limit."""
+        max_len = self.max_message_length()
+        if max_len == 0 or len(text) <= max_len:
+            return [text]
+
+        chunks = []
+        while text:
+            if len(text) <= max_len:
+                chunks.append(text)
+                break
+            # Try to split at newline
+            split_idx = text.rfind("\n", 0, max_len)
+            if split_idx == -1 or split_idx < max_len // 2:
+                # No good newline, split at max length
+                split_idx = max_len
+            chunks.append(text[:split_idx])
+            text = text[split_idx:].lstrip("\n")
+        return chunks
+
+
+class TelegramAdapter(ChannelAdapter):
+    """Telegram channel adapter."""
+
+    channel_type = ChannelType.TELEGRAM
+
+    def __init__(self, bot: Any):
+        self.bot = bot
+
+    async def send_message(
+        self,
+        context: DeliveryContext,
+        payload: MessagePayload,
+    ) -> bool:
+        try:
+            chat_id = int(context.recipient_id)
+
+            # Send text in chunks if needed
+            for chunk in self.split_message(payload.text):
+                await self.bot.send_message(chat_id=chat_id, text=chunk)
+
+            # Send media if any
+            if payload.media_paths:
+                import os
+
+                for path in payload.media_paths:
+                    if os.path.exists(path):
+                        with open(path, "rb") as f:
+                            await self.bot.send_photo(chat_id=chat_id, photo=f)
+
+            return True
+        except Exception as e:
+            logger.error(f"Failed to send Telegram message: {e}")
+            return False
+
+    async def send_typing(self, context: DeliveryContext) -> None:
+        try:
+            chat_id = int(context.recipient_id)
+            await self.bot.send_chat_action(chat_id=chat_id, action="typing")
+        except Exception as e:
+            logger.warning(f"Failed to send typing indicator: {e}")
+
+
+class TCPAdapter(ChannelAdapter):
+    """TCP client channel adapter."""
+
+    channel_type = ChannelType.TCP
+
+    def __init__(
+        self,
+        get_writer: Callable[[str], asyncio.StreamWriter | None],
+    ):
+        self._get_writer = get_writer
+
+    async def send_message(
+        self,
+        context: DeliveryContext,
+        payload: MessagePayload,
+    ) -> bool:
+        import json
+
+        writer = self._get_writer(context.recipient_id)
+        if not writer:
+            return False
+
+        try:
+            notification = {"status": "notification", "response": payload.text}
+            data = json.dumps(notification) + "\n"
+            writer.write(data.encode())
+            await writer.drain()
+            return True
+        except Exception as e:
+            logger.error(f"Failed to send TCP message: {e}")
+            return False
+
+    async def send_typing(self, context: DeliveryContext) -> None:
+        # TCP clients don't support typing indicators
+        pass
+
+
+class WhatsAppAdapter(ChannelAdapter):
+    """WhatsApp channel adapter (placeholder for future implementation)."""
+
+    channel_type = ChannelType.WHATSAPP
+
+    def __init__(self, client: Any = None):
+        self.client = client
+
+    async def send_message(
+        self,
+        context: DeliveryContext,
+        payload: MessagePayload,
+    ) -> bool:
+        # TODO: Implement WhatsApp sending via WhatsApp Business API
+        logger.warning("WhatsApp adapter not yet implemented")
+        return False
+
+    async def send_typing(self, context: DeliveryContext) -> None:
+        # TODO: Implement WhatsApp typing indicator
+        pass
+
+
+class DiscordAdapter(ChannelAdapter):
+    """Discord channel adapter (placeholder for future implementation)."""
+
+    channel_type = ChannelType.DISCORD
+
+    def __init__(self, client: Any = None):
+        self.client = client
+
+    async def send_message(
+        self,
+        context: DeliveryContext,
+        payload: MessagePayload,
+    ) -> bool:
+        # TODO: Implement Discord sending via Discord.py
+        logger.warning("Discord adapter not yet implemented")
+        return False
+
+    async def send_typing(self, context: DeliveryContext) -> None:
+        # TODO: Implement Discord typing indicator
+        pass
+
+
+class SlackAdapter(ChannelAdapter):
+    """Slack channel adapter (placeholder for future implementation)."""
+
+    channel_type = ChannelType.SLACK
+
+    def __init__(self, client: Any = None):
+        self.client = client
+
+    async def send_message(
+        self,
+        context: DeliveryContext,
+        payload: MessagePayload,
+    ) -> bool:
+        # TODO: Implement Slack sending via Slack SDK
+        logger.warning("Slack adapter not yet implemented")
+        return False
+
+    async def send_typing(self, context: DeliveryContext) -> None:
+        # TODO: Implement Slack typing indicator
+        pass
+
+
+class ChannelRouter:
+    """Routes messages to the appropriate channel adapter."""
+
+    def __init__(self):
+        self._adapters: dict[ChannelType, ChannelAdapter] = {}
+
+    def register(self, adapter: ChannelAdapter) -> None:
+        """Register a channel adapter."""
+        self._adapters[adapter.channel_type] = adapter
+        logger.info(f"Registered channel adapter: {adapter.channel_type}")
+
+    def get_adapter(self, channel: ChannelType) -> ChannelAdapter | None:
+        """Get the adapter for a channel type."""
+        return self._adapters.get(channel)
+
+    async def send(
+        self,
+        context: DeliveryContext,
+        payload: MessagePayload,
+    ) -> bool:
+        """Send a message via the appropriate channel."""
+        adapter = self.get_adapter(context.channel)
+        if not adapter:
+            logger.error(f"No adapter registered for channel: {context.channel}")
+            return False
+        return await adapter.send_message(context, payload)
+
+    async def broadcast(
+        self,
+        contexts: list[DeliveryContext],
+        payload: MessagePayload,
+    ) -> dict[str, bool]:
+        """Broadcast a message to multiple contexts."""
+        results = {}
+        for ctx in contexts:
+            key = f"{ctx.channel}:{ctx.recipient_id}"
+            results[key] = await self.send(ctx, payload)
+        return results
+
+
+# Global channel router instance
+_channel_router: ChannelRouter | None = None
+
+
+def get_channel_router() -> ChannelRouter:
+    """Get the global channel router instance."""
+    global _channel_router
+    if _channel_router is None:
+        _channel_router = ChannelRouter()
+    return _channel_router

squidbot/character.py

@@ -0,0 +1,83 @@
+"""AI Character/Personality configuration."""
+
+import os
+from pathlib import Path
+
+import aiofiles
+
+from .config import DATA_DIR
+
+# Character configuration from environment
+CHARACTER_NAME = os.environ.get("CHARACTER_NAME", "Assistant")
+CHARACTER_PERSONA = os.environ.get("CHARACTER_PERSONA", "")
+CHARACTER_STYLE = os.environ.get("CHARACTER_STYLE", "helpful, friendly, concise")
+
+# Optional character file
+CHARACTER_FILE = DATA_DIR / "CHARACTER.md"
+
+
+async def load_character_file() -> str:
+    """Load character definition from file if exists."""
+    if CHARACTER_FILE.exists():
+        try:
+            async with aiofiles.open(CHARACTER_FILE, "r", encoding="utf-8") as f:
+                return await f.read()
+        except Exception:
+            pass
+    return ""
+
+
+async def get_character_prompt() -> str:
+    """Build character prompt section."""
+    parts = []
+
+    # Name
+    if CHARACTER_NAME and CHARACTER_NAME != "Assistant":
+        parts.append(f"Your name is {CHARACTER_NAME}.")
+
+    # Persona from env
+    if CHARACTER_PERSONA:
+        parts.append(CHARACTER_PERSONA)
+
+    # Style
+    if CHARACTER_STYLE:
+        parts.append(f"Communication style: {CHARACTER_STYLE}")
+
+    # Character file content
+    file_content = await load_character_file()
+    if file_content:
+        parts.append(file_content)
+
+    if not parts:
+        return ""
+
+    return "## Character\n" + "\n".join(parts)
+
+
+async def create_example_character():
+    """Create an example CHARACTER.md if it doesn't exist."""
+    if CHARACTER_FILE.exists():
+        return
+
+    example = """# Character Definition
+
+You are a helpful AI assistant with the following traits:
+
+## Personality
+- Friendly and approachable
+- Patient and thorough
+- Honest about limitations
+
+## Communication Style
+- Clear and concise responses
+- Use examples when helpful
+- Ask clarifying questions when needed
+
+## Knowledge Areas
+- General knowledge
+- Programming and technology
+- Problem solving
+"""
+    CHARACTER_FILE.parent.mkdir(parents=True, exist_ok=True)
+    async with aiofiles.open(CHARACTER_FILE, "w") as f:
+        await f.write(example)