mindbot 0.1.0__tar.gz

mindbot-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 runkezhong
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

mindbot-0.1.0/PKG-INFO

@@ -0,0 +1,71 @@
+Metadata-Version: 2.4
+Name: mindbot
+Version: 0.1.0
+Summary: MindBot - AI Assistant powered by Thryve
+Author: MindBot Team
+License: MIT
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: thryve>=0.1.0
+Requires-Dist: pydantic>=2.0
+Requires-Dist: pydantic-settings>=2.0
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: loguru>=0.7
+Requires-Dist: typer>=0.12
+Requires-Dist: prompt-toolkit>=3.0
+Requires-Dist: rich>=13.0
+Requires-Dist: croniter>=1.4
+Requires-Dist: aiohttp>=3.9
+Dynamic: license-file
+
+# MindBot 开发计划
+
+> 基于 Thryve 的多通道 AI 助手
+
+## 项目愿景
+
+MindBot 是一个开箱即用的多通道 AI 助手。
+
+## 阶段划分
+
+| 阶段 | 内容 | 优先级 |
+|------|------|--------|
+| [阶段一](phase1_core.md) | 项目初始化与核心类 | P0 |
+| [阶段二](phase2_cli.md) | CLI 实现 | P0 |
+| [阶段三](phase3_channels.md) | 通道实现 | P1 |
+| [阶段四](phase4_tools.md) | 工具系统 | P1 |
+| [阶段五](phase5_integration.md) | 完善与集成 | P2 |
+
+## 技术栈
+
+- **核心框架**: Thryve v0.2.0
+- **CLI**: typer + prompt_toolkit + rich
+- **通道**: aiohttp/FastAPI
+- **工具**: 内置 + MCP
+
+## 快速开始
+
+```bash
+# 安装
+pip install mindbot
+
+# 初始化
+mindbot onboard
+
+# 对话
+mindbot chat -m "你好"
+
+# 交互式
+mindbot shell
+
+# 启动服务
+mindbot serve --port 8080
+```

mindbot-0.1.0/README.md

@@ -0,0 +1,43 @@
+# MindBot 开发计划
+
+> 基于 Thryve 的多通道 AI 助手
+
+## 项目愿景
+
+MindBot 是一个开箱即用的多通道 AI 助手。
+
+## 阶段划分
+
+| 阶段 | 内容 | 优先级 |
+|------|------|--------|
+| [阶段一](phase1_core.md) | 项目初始化与核心类 | P0 |
+| [阶段二](phase2_cli.md) | CLI 实现 | P0 |
+| [阶段三](phase3_channels.md) | 通道实现 | P1 |
+| [阶段四](phase4_tools.md) | 工具系统 | P1 |
+| [阶段五](phase5_integration.md) | 完善与集成 | P2 |
+
+## 技术栈
+
+- **核心框架**: Thryve v0.2.0
+- **CLI**: typer + prompt_toolkit + rich
+- **通道**: aiohttp/FastAPI
+- **工具**: 内置 + MCP
+
+## 快速开始
+
+```bash
+# 安装
+pip install mindbot
+
+# 初始化
+mindbot onboard
+
+# 对话
+mindbot chat -m "你好"
+
+# 交互式
+mindbot shell
+
+# 启动服务
+mindbot serve --port 8080
+```

mindbot-0.1.0/pyproject.toml

@@ -0,0 +1,44 @@
+[project]
+name = "mindbot"
+version = "0.1.0"
+description = "MindBot - AI Assistant powered by Thryve"
+authors = [
+    {name = "MindBot Team"}
+]
+readme = "README.md"
+license = {text = "MIT"}
+requires-python = ">=3.10"
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+]
+dependencies = [
+    "thryve>=0.1.0",
+    "pydantic>=2.0",
+    "pydantic-settings>=2.0",
+    "pyyaml>=6.0",
+    "loguru>=0.7",
+    "typer>=0.12",
+    "prompt-toolkit>=3.0",
+    "rich>=13.0",
+    "croniter>=1.4",
+    "aiohttp>=3.9",
+]
+
+[project.scripts]
+mindbot = "mindbot.cli:app"
+
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"

mindbot-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

mindbot-0.1.0/src/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-0.1.0/src/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-0.1.0/src/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-0.1.0/src/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-0.1.0/src/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-0.1.0/src/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-0.1.0/src/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-0.1.0/src/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="")