mindbot 0.1.0__py3-none-any.whl

mindbot/__init__.py

@@ -0,0 +1,26 @@
+"""MindBot - AI Assistant powered by Thryve."""
+
+__version__ = "0.1.0"
+
+__logo__ = """
+╔════════════════════════════════════╗
+║            MindBot                ║
+╚════════════════════════════════════╝
+"""
+
+from mindbot.core.bot import MindBot
+from mindbot.core.config import MindConfig
+from mindbot.bus import MessageBus, InboundMessage, OutboundMessage
+from mindbot.channels import BaseChannel, ChannelManager
+
+__all__ = [
+    "MindBot",
+    "MindConfig",
+    "MessageBus",
+    "InboundMessage",
+    "OutboundMessage",
+    "BaseChannel",
+    "ChannelManager",
+    "__version__",
+    "__logo__",
+]

mindbot/__main__.py

@@ -0,0 +1,6 @@
+"""Entry point for running mindbot as a module: python -m mindbot"""
+
+from mindbot.cli import app
+
+if __name__ == "__main__":
+    app()

mindbot/bus/__init__.py

@@ -0,0 +1,10 @@
+"""Message bus for channel-agent communication."""
+
+from mindbot.bus.events import InboundMessage, OutboundMessage
+from mindbot.bus.queue import MessageBus
+
+__all__ = [
+    "InboundMessage",
+    "OutboundMessage",
+    "MessageBus",
+]

mindbot/bus/events.py

@@ -0,0 +1,35 @@
+"""Event types for the message bus."""
+
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import Any
+
+
+@dataclass
+class InboundMessage:
+    """Message received from a chat channel."""
+
+    channel: str  # telegram, discord, http, cli
+    sender_id: str  # User identifier
+    chat_id: str  # Chat/channel identifier
+    content: str  # Message text
+    timestamp: datetime = field(default_factory=datetime.now)
+    media: list[str] = field(default_factory=list)  # Media URLs
+    metadata: dict[str, Any] = field(default_factory=dict)  # Channel-specific data
+
+    @property
+    def session_key(self) -> str:
+        """Unique key for session identification."""
+        return f"{self.channel}:{self.chat_id}"
+
+
+@dataclass
+class OutboundMessage:
+    """Message to send to a chat channel."""
+
+    channel: str
+    chat_id: str
+    content: str
+    reply_to: str | None = None
+    media: list[str] = field(default_factory=list)
+    metadata: dict[str, Any] = field(default_factory=dict)

mindbot/bus/queue.py

@@ -0,0 +1,80 @@
+"""Async message queue for decoupled channel-agent communication."""
+
+import asyncio
+from typing import Callable, Awaitable
+
+from loguru import logger
+
+from mindbot.bus.events import InboundMessage, OutboundMessage
+
+
+class MessageBus:
+    """Async message bus that decouples chat channels from the agent core.
+
+    Channels push messages to the inbound queue, and the agent processes
+    them and pushes responses to the outbound queue.
+    """
+
+    def __init__(self):
+        self.inbound: asyncio.Queue[InboundMessage] = asyncio.Queue()
+        self.outbound: asyncio.Queue[OutboundMessage] = asyncio.Queue()
+        self._outbound_subscribers: dict[str, list[Callable[[OutboundMessage], Awaitable[None]]]] = {}
+        self._running = False
+
+    async def publish_inbound(self, msg: InboundMessage) -> None:
+        """Publish a message from a channel to the agent."""
+        await self.inbound.put(msg)
+
+    async def consume_inbound(self) -> InboundMessage:
+        """Consume the next inbound message (blocks until available)."""
+        return await self.inbound.get()
+
+    async def publish_outbound(self, msg: OutboundMessage) -> None:
+        """Publish a response from the agent to channels."""
+        await self.outbound.put(msg)
+
+    async def consume_outbound(self) -> OutboundMessage:
+        """Consume the next outbound message (blocks until available)."""
+        return await self.outbound.get()
+
+    def subscribe_outbound(
+        self,
+        channel: str,
+        callback: Callable[[OutboundMessage], Awaitable[None]]
+    ) -> None:
+        """Subscribe to outbound messages for a specific channel."""
+        if channel not in self._outbound_subscribers:
+            self._outbound_subscribers[channel] = []
+        self._outbound_subscribers[channel].append(callback)
+
+    async def dispatch_outbound(self) -> None:
+        """Dispatch outbound messages to subscribed channels.
+
+        Run this as a background task.
+        """
+        self._running = True
+        while self._running:
+            try:
+                msg = await asyncio.wait_for(self.outbound.get(), timeout=1.0)
+                subscribers = self._outbound_subscribers.get(msg.channel, [])
+                for callback in subscribers:
+                    try:
+                        await callback(msg)
+                    except Exception as e:
+                        logger.error(f"Error dispatching to {msg.channel}: {e}")
+            except asyncio.TimeoutError:
+                continue
+
+    def stop(self) -> None:
+        """Stop the dispatcher loop."""
+        self._running = False
+
+    @property
+    def inbound_size(self) -> int:
+        """Number of pending inbound messages."""
+        return self.inbound.qsize()
+
+    @property
+    def outbound_size(self) -> int:
+        """Number of pending outbound messages."""
+        return self.outbound.qsize()

mindbot/channels/__init__.py

@@ -0,0 +1,11 @@
+"""Chat channels for MindBot."""
+
+from mindbot.channels.base import BaseChannel
+from mindbot.channels.manager import ChannelManager
+from mindbot.channels.feishu import FeishuChannel
+
+__all__ = [
+    "BaseChannel",
+    "ChannelManager",
+    "FeishuChannel",
+]

mindbot/channels/base.py

@@ -0,0 +1,121 @@
+"""Base channel interface for chat platforms."""
+
+from abc import ABC, abstractmethod
+from typing import Any
+
+from loguru import logger
+
+from mindbot.bus.events import InboundMessage, OutboundMessage
+from mindbot.bus.queue import MessageBus
+
+
+class BaseChannel(ABC):
+    """Abstract base class for chat channel implementations.
+
+    Each channel (Telegram, Discord, etc.) should implement this interface
+    to integrate with the mindbot message bus.
+    """
+
+    name: str = "base"
+
+    def __init__(self, config: Any, bus: MessageBus):
+        """Initialize the channel.
+
+        Args:
+            config: Channel-specific configuration.
+            bus: The message bus for communication.
+        """
+        self.config = config
+        self.bus = bus
+        self._running = False
+
+    @abstractmethod
+    async def start(self) -> None:
+        """Start the channel and begin listening for messages.
+
+        This should be a long-running async task that:
+        1. Connects to the chat platform
+        2. Listens for incoming messages
+        3. Forwards messages to the bus via _handle_message()
+        """
+        pass
+
+    @abstractmethod
+    async def stop(self) -> None:
+        """Stop the channel and clean up resources."""
+        pass
+
+    @abstractmethod
+    async def send(self, msg: OutboundMessage) -> None:
+        """Send a message through this channel.
+
+        Args:
+            msg: The message to send.
+        """
+        pass
+
+    def is_allowed(self, sender_id: str) -> bool:
+        """Check if a sender is allowed to use this bot.
+
+        Args:
+            sender_id: The sender's identifier.
+
+        Returns:
+            True if allowed, False otherwise.
+        """
+        allow_list = getattr(self.config, "allow_from", [])
+
+        # If no allow list, allow everyone
+        if not allow_list:
+            return True
+
+        sender_str = str(sender_id)
+        if sender_str in allow_list:
+            return True
+        if "|" in sender_str:
+            for part in sender_str.split("|"):
+                if part and part in allow_list:
+                    return True
+        return False
+
+    async def _handle_message(
+        self,
+        sender_id: str,
+        chat_id: str,
+        content: str,
+        media: list[str] | None = None,
+        metadata: dict[str, Any] | None = None
+    ) -> None:
+        """Handle an incoming message from the chat platform.
+
+        This method checks permissions and forwards to the bus.
+
+        Args:
+            sender_id: The sender's identifier.
+            chat_id: The chat/channel identifier.
+            content: Message text content.
+            media: Optional list of media URLs.
+            metadata: Optional channel-specific metadata.
+        """
+        if not self.is_allowed(sender_id):
+            logger.warning(
+                f"Access denied for sender {sender_id} on channel {self.name}. "
+                f"Add them to allow_from list in config to grant access."
+            )
+            return
+
+        msg = InboundMessage(
+            channel=self.name,
+            sender_id=str(sender_id),
+            chat_id=str(chat_id),
+            content=content,
+            media=media or [],
+            metadata=metadata or {}
+        )
+
+        await self.bus.publish_inbound(msg)
+
+    @property
+    def is_running(self) -> bool:
+        """Check if the channel is running."""
+        return self._running

mindbot/channels/cli.py

@@ -0,0 +1,71 @@
+"""CLI channel for MindBot."""
+
+import asyncio
+from typing import Any
+
+from loguru import logger
+
+from mindbot.bus.events import OutboundMessage
+from mindbot.bus.queue import MessageBus
+from mindbot.channels.base import BaseChannel
+
+
+class CLIChannel(BaseChannel):
+    """CLI (stdin/stdout) channel for interactive terminal use.
+
+    This channel handles interactive command-line conversations.
+    """
+
+    name: str = "cli"
+
+    def __init__(self, config: Any, bus: MessageBus):
+        super().__init__(config, bus)
+        self._input_task: asyncio.Task | None = None
+
+    async def start(self) -> None:
+        """Start the CLI channel."""
+        self._running = True
+        self._input_task = asyncio.create_task(self._read_input())
+        logger.info("CLI channel started")
+
+    async def stop(self) -> None:
+        """Stop the CLI channel."""
+        self._running = False
+        if self._input_task:
+            self._input_task.cancel()
+            try:
+                await self._input_task
+            except asyncio.CancelledError:
+                pass
+        logger.info("CLI channel stopped")
+
+    async def _read_input(self) -> None:
+        """Read input from stdin and send to message bus."""
+        loop = asyncio.get_event_loop()
+
+        while self._running:
+            try:
+                # Read line from stdin
+                line = await loop.run_in_executor(None, input, ">>> ")
+
+                if not line.strip():
+                    continue
+
+                if line.strip().lower() in ["exit", "quit", "bye"]:
+                    break
+
+                await self._handle_message(
+                    sender_id="cli_user",
+                    chat_id="cli",
+                    content=line.strip(),
+                    metadata={"session_id": "default"}
+                )
+
+            except EOFError:
+                break
+            except Exception as e:
+                logger.error(f"Error reading CLI input: {e}")
+
+    async def send(self, msg: OutboundMessage) -> None:
+        """Send a message to stdout."""
+        print(f"\n{msg.content}\n>>> ", end="")