botable-dev 0.3.1__py3-none-any.whl

botable/prompts.py

@@ -0,0 +1,137 @@
+"""
+System prompts for Botable CLI bot generation.
+
+Adapted from generator/llm_integration/constants.py for standalone CLI use.
+Uses aiogram patterns (MIT license) — see Phase 6.3.
+"""
+from __future__ import annotations
+
+# ── Bot generation system prompt ─────────────────────────────────────────────
+
+SYSTEM_PROMPT = """\
+You are a Python Telegram bot code generator.
+
+# Design guidelines:
+- Write code for a single main.py file
+- Write simple, maintainable, production-ready code
+- Use best practices and clean structure
+
+# Critical requirements:
+- Generate ONLY Python code without any markdown formatting (no ```python blocks)
+- All comments must be in English using # syntax
+- Use aiogram library (version 3.x, async-native)
+- Use AsyncOpenAI client with model 'gpt-4o-mini' when AI features are needed
+- Use the language specified by the user for bot messages (default: English)
+- Use dotenv for environment variable loading
+- ALL environment variables MUST come from .env via os.getenv()
+
+# ⚠️ CRITICAL ASYNC/AWAIT RULES:
+1. ALL handler functions MUST use 'async def'
+2. ALL calls to async methods MUST use 'await':
+   - await message.answer(...)
+   - await ai_client.chat.completions.create(...)
+   - await client.get(...) with httpx.AsyncClient
+3. For HTTP requests use 'httpx' (async), NOT 'requests'
+
+# aiogram code structure:
+```python
+import os
+import asyncio
+from dotenv import load_dotenv
+from aiogram import Bot, Dispatcher, types, F
+from aiogram.filters import Command
+
+load_dotenv()
+
+TELEGRAM_BOT_TOKEN = os.getenv("TELEGRAM_BOT_TOKEN")
+if not TELEGRAM_BOT_TOKEN:
+    raise ValueError("TELEGRAM_BOT_TOKEN not found in .env")
+
+bot = Bot(token=TELEGRAM_BOT_TOKEN)
+dp = Dispatcher()
+
+@dp.message(Command("start"))
+async def start(message: types.Message) -> None:
+    await message.answer("Hello!")
+
+@dp.message(F.text)
+async def handle_message(message: types.Message) -> None:
+    await message.answer(f"You said: {message.text}")
+
+async def main() -> None:
+    await dp.start_polling(bot)
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+# When AI features are needed:
+```python
+from openai import AsyncOpenAI
+
+OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
+if not OPENAI_API_KEY:
+    raise ValueError("OPENAI_API_KEY not found in .env")
+
+ai_client = AsyncOpenAI(api_key=OPENAI_API_KEY)
+
+@dp.message(F.text)
+async def handle_message(message: types.Message) -> None:
+    completion = await ai_client.chat.completions.create(
+        model="gpt-4o-mini",
+        messages=[{"role": "user", "content": message.text}]
+    )
+    await message.answer(completion.choices[0].message.content)
+```
+
+# For callback queries and inline keyboards:
+```python
+from aiogram.types import InlineKeyboardMarkup, InlineKeyboardButton
+
+@dp.callback_query(F.data == "action")
+async def handle_callback(callback: types.CallbackQuery) -> None:
+    await callback.answer()
+    await callback.message.answer("Action processed!")
+```
+
+# For FSM (conversation states):
+```python
+from aiogram.fsm.state import State, StatesGroup
+from aiogram.fsm.context import FSMContext
+
+class Form(StatesGroup):
+    name = State()
+    email = State()
+
+@dp.message(Command("form"))
+async def cmd_form(message: types.Message, state: FSMContext) -> None:
+    await state.set_state(Form.name)
+    await message.answer("What is your name?")
+
+@dp.message(Form.name)
+async def process_name(message: types.Message, state: FSMContext) -> None:
+    await state.update_data(name=message.text)
+    await state.set_state(Form.email)
+    await message.answer("What is your email?")
+```
+
+IMPORTANT: Generate ONLY Python code. No markdown, no explanations.
+Use HTML parse_mode (not Markdown) for formatted messages.
+"""
+
+# ── Requirements generation prompt ───────────────────────────────────────────
+
+REQUIREMENTS_PROMPT = """\
+Given the following bot description, list ONLY the Python package names \
+needed (one per line, no versions, no comments).
+
+Always include:
+- aiogram
+- python-dotenv
+
+Only add 'openai' if the bot uses AI/LLM features.
+Only add 'httpx' if the bot makes external HTTP requests.
+Do NOT include standard library modules.
+
+Bot description: {description}
+"""

botable/runner.py

@@ -0,0 +1,333 @@
+"""
+Local bot runner for Botable CLI.
+
+Manages the bot subprocess lifecycle:
+- Creates/reuses a virtual environment
+- Installs requirements
+- Launches bot as a subprocess
+- Captures and displays stdout/stderr
+- Handles graceful shutdown (Ctrl+C)
+"""
+from __future__ import annotations
+
+import os
+import signal
+import subprocess
+import sys
+import time
+from pathlib import Path
+from typing import Optional
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.text import Text
+
+from botable.ui import success, error, info, warn
+
+console = Console()
+
+
+class BotRunner:
+    """Manages a bot subprocess with venv and live output."""
+
+    def __init__(self, project_root: Path):
+        self.project_root = project_root
+        self.venv_dir = project_root / ".venv"
+        self.python = self.venv_dir / "bin" / "python"
+        self.pip = self.venv_dir / "bin" / "pip"
+        self.process: Optional[subprocess.Popen] = None
+        self._shutting_down = False
+
+    # ── Venv management ──────────────────────────────────────────────────
+
+    def ensure_venv(self) -> bool:
+        """Create virtual environment if not exists."""
+        if self.venv_dir.exists() and self.python.exists():
+            return True
+
+        info("Creating virtual environment...")
+        try:
+            subprocess.run(
+                [sys.executable, "-m", "venv", str(self.venv_dir)],
+                check=True,
+                capture_output=True,
+                text=True,
+            )
+            success("Virtual environment created")
+            return True
+        except subprocess.CalledProcessError as e:
+            error(f"Failed to create venv: {e.stderr}")
+            return False
+
+    def install_requirements(self) -> bool:
+        """Install requirements.txt into the venv."""
+        req_file = self.project_root / "requirements.txt"
+        if not req_file.exists():
+            warn("No requirements.txt found — skipping dependency install")
+            return True
+
+        info("Installing dependencies...")
+        try:
+            result = subprocess.run(
+                [str(self.pip), "install", "-q", "-r", str(req_file)],
+                capture_output=True,
+                text=True,
+                timeout=120,
+            )
+            if result.returncode != 0:
+                error(f"pip install failed:\n{result.stderr[:500]}")
+                return False
+
+            # Count installed packages
+            pkgs = [l.strip() for l in req_file.read_text().splitlines() if l.strip() and not l.startswith("#")]
+            success(f"Dependencies installed ({len(pkgs)} packages)")
+            return True
+        except subprocess.TimeoutExpired:
+            error("pip install timed out (120s)")
+            return False
+
+    # ── Bot process management ───────────────────────────────────────────
+
+    def start(self) -> bool:
+        """Launch the bot as a subprocess."""
+        main_py = self.project_root / "main.py"
+        if not main_py.exists():
+            error("No [cyan]main.py[/] found. Run [cyan]botable generate[/] first.")
+            return False
+
+        # Set up environment: inherit current env + load .env vars
+        env = os.environ.copy()
+        env_file = self.project_root / ".env"
+        if env_file.exists():
+            for line in env_file.read_text().splitlines():
+                line = line.strip()
+                if line and not line.startswith("#") and "=" in line:
+                    key, _, value = line.partition("=")
+                    # Strip surrounding quotes
+                    value = value.strip().strip("'\"")
+                    env[key.strip()] = value
+
+        try:
+            self.process = subprocess.Popen(
+                [str(self.python), str(main_py)],
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                cwd=str(self.project_root),
+                env=env,
+                text=True,
+                bufsize=1,  # Line buffered
+            )
+            return True
+        except Exception as e:
+            error(f"Failed to start bot: {e}")
+            return False
+
+    def stop(self) -> None:
+        """Gracefully stop the bot subprocess."""
+        if self.process is None:
+            return
+
+        self._shutting_down = True
+
+        try:
+            self.process.send_signal(signal.SIGTERM)
+            try:
+                self.process.wait(timeout=5)
+            except subprocess.TimeoutExpired:
+                self.process.kill()
+                self.process.wait(timeout=2)
+        except (ProcessLookupError, OSError):
+            pass
+
+        self.process = None
+
+    def is_running(self) -> bool:
+        """Check if the bot process is still running."""
+        if self.process is None:
+            return False
+        return self.process.poll() is None
+
+    # ── Live output display ──────────────────────────────────────────────
+
+    def run_with_output(self) -> int:
+        """Run the bot and display output until exit or Ctrl+C.
+
+        Returns the bot's exit code.
+        """
+        import selectors
+
+        if self.process is None:
+            return 1
+
+        console.print()
+        console.print(
+            Panel(
+                "[bold green]🤖 Bot running![/] Press [bold yellow]Ctrl+C[/] to stop.",
+                border_style="green",
+                padding=(0, 2),
+            )
+        )
+        console.print()
+
+        # Use selectors for non-blocking I/O on stdout/stderr
+        sel = selectors.DefaultSelector()
+        sel.register(self.process.stdout, selectors.EVENT_READ)
+        sel.register(self.process.stderr, selectors.EVENT_READ)
+
+        try:
+            while self.is_running():
+                events = sel.select(timeout=0.5)
+                for key, _ in events:
+                    line = key.fileobj.readline()
+                    if line:
+                        if key.fileobj is self.process.stderr:
+                            console.print(f"  [red]stderr[/] │ {line.rstrip()}")
+                        else:
+                            console.print(f"  [dim]stdout[/] │ {line.rstrip()}")
+        except KeyboardInterrupt:
+            console.print()
+            info("Stopping bot...")
+            self.stop()
+            success("Bot stopped")
+            return 0
+        finally:
+            sel.close()
+
+        # Bot exited on its own
+        exit_code = self.process.returncode if self.process else 1
+
+        if exit_code != 0 and not self._shutting_down:
+            # Show remaining stderr
+            if self.process and self.process.stderr:
+                remaining = self.process.stderr.read()
+                if remaining:
+                    console.print()
+                    console.print(Panel(
+                        remaining.strip(),
+                        title="[red]Bot Error[/]",
+                        border_style="red",
+                    ))
+
+            error(f"Bot exited with code {exit_code}")
+        else:
+            success("Bot stopped")
+
+        return exit_code
+
+
+def run_dev(watch: bool = False) -> int:
+    """Main entry point for `botable dev`.
+
+    Returns exit code (0 = success).
+    """
+    from botable.config import load_project_config
+
+    config = load_project_config()
+    if config is None:
+        error("No [yellow]botable.toml[/] found. Run [cyan]botable init[/] first.")
+        return 1
+
+    project_root = Path(config["_project_root"])
+
+    runner = BotRunner(project_root)
+
+    # 1. Ensure venv
+    if not runner.ensure_venv():
+        return 1
+
+    # 2. Install dependencies
+    if not runner.install_requirements():
+        return 1
+
+    if watch:
+        return _run_with_watcher(runner, project_root)
+    else:
+        # 3. Start bot
+        if not runner.start():
+            return 1
+
+        # 4. Run with live output
+        return runner.run_with_output()
+
+
+def _run_with_watcher(runner: BotRunner, project_root: Path) -> int:
+    """Run bot with file watcher for hot reload."""
+    try:
+        from watchfiles import watch
+    except ImportError:
+        warn("watchfiles not installed — running without hot reload")
+        warn("Install with: pip install watchfiles")
+        if not runner.start():
+            return 1
+        return runner.run_with_output()
+
+    info("Watching for file changes (hot reload enabled)...")
+
+    # Start bot for the first time
+    if not runner.start():
+        return 1
+
+    console.print()
+    console.print(
+        Panel(
+            "[bold green]🤖 Bot running with hot reload![/]\n"
+            "Press [bold yellow]Ctrl+C[/] to stop.",
+            border_style="green",
+            padding=(0, 2),
+        )
+    )
+
+    import selectors
+    import threading
+
+    # Run file watcher in a thread
+    stop_event = threading.Event()
+
+    def file_watcher():
+        for changes in watch(
+            str(project_root),
+            watch_filter=lambda change, path: path.endswith((".py", ".env")),
+            stop_event=stop_event,
+        ):
+            if stop_event.is_set():
+                break
+            changed_files = [Path(p).name for _, p in changes]
+            console.print(f"\n  [yellow]↻[/] Files changed: {', '.join(changed_files)} — restarting...")
+            runner.stop()
+            time.sleep(0.3)
+            runner.install_requirements()
+            if runner.start():
+                success("Bot restarted")
+            else:
+                error("Failed to restart bot")
+
+    watcher_thread = threading.Thread(target=file_watcher, daemon=True)
+    watcher_thread.start()
+
+    # Main thread: display output
+    try:
+        while True:
+            if runner.is_running():
+                sel = selectors.DefaultSelector()
+                sel.register(runner.process.stdout, selectors.EVENT_READ)
+                sel.register(runner.process.stderr, selectors.EVENT_READ)
+                try:
+                    events = sel.select(timeout=0.5)
+                    for key, _ in events:
+                        line = key.fileobj.readline()
+                        if line:
+                            if key.fileobj is runner.process.stderr:
+                                console.print(f"  [red]stderr[/] │ {line.rstrip()}")
+                            else:
+                                console.print(f"  [dim]stdout[/] │ {line.rstrip()}")
+                finally:
+                    sel.close()
+            else:
+                time.sleep(0.5)
+    except KeyboardInterrupt:
+        console.print()
+        info("Shutting down...")
+        stop_event.set()
+        runner.stop()
+        success("Bot stopped")
+        return 0

botable/scaffold.py

@@ -0,0 +1,104 @@
+"""
+Project scaffolding for `botable init`.
+
+Creates a new bot project directory with:
+- botable.toml (project config)
+- .env (secrets placeholder)
+- .gitignore
+- README.md
+"""
+from __future__ import annotations
+
+from pathlib import Path
+
+from botable.config import save_project_config
+
+
+def scaffold_project(name: str) -> Path:
+    """Create a new bot project directory.
+
+    Args:
+        name: Project name (used as directory name).
+
+    Returns:
+        Path to the created project directory.
+
+    Raises:
+        FileExistsError: If the directory already exists.
+    """
+    project_dir = Path.cwd() / name
+
+    if project_dir.exists():
+        raise FileExistsError(f"Directory '{name}' already exists")
+
+    project_dir.mkdir(parents=True)
+
+    # ── botable.toml ──
+    config = {
+        "project": {
+            "name": name,
+            "description": "",
+            "version": "0.1.0",
+        },
+        "bot": {
+            "template": "custom",
+        },
+        "branding": {
+            "enabled": True,
+            "text": "Built with Botable (botable.dev)",
+            "style": "comment",  # "comment" | "docstring" | "none"
+        },
+    }
+    save_project_config(config, project_dir / "botable.toml")
+
+    # ── .env ──
+    env_content = """# Botable project secrets — DO NOT COMMIT
+# Get your bot token from @BotFather on Telegram
+BOT_TOKEN=your-token-here
+
+# Optional: OpenAI API key for AI-powered features
+# OPENAI_API_KEY=sk-...
+"""
+    (project_dir / ".env").write_text(env_content)
+
+    # ── .gitignore ──
+    gitignore = """.env
+__pycache__/
+*.pyc
+.venv/
+venv/
+bot/__pycache__/
+"""
+    (project_dir / ".gitignore").write_text(gitignore)
+
+    # ── README.md ──
+    readme = f"""# {name}
+
+A Telegram bot generated with [Botable](https://botable.dev).
+
+## Quick Start
+
+```bash
+# Set your bot token
+echo "BOT_TOKEN=your-token" > .env
+
+# Generate the bot
+botable generate "your bot description here"
+
+# Run locally
+botable dev
+```
+
+## Deploy
+
+```bash
+botable deploy
+```
+
+---
+
+⚡ Built with [Botable](https://botable.dev)
+"""
+    (project_dir / "README.md").write_text(readme)
+
+    return project_dir

botable/ui.py

@@ -0,0 +1,48 @@
+"""
+Rich console UI helpers for Botable CLI.
+
+Provides styled output: banner, success/error/info messages,
+progress bars, and status spinners.
+"""
+from __future__ import annotations
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.text import Text
+
+console = Console()
+
+
+def banner() -> None:
+    """Print the Botable ASCII banner."""
+    logo = Text.from_markup(
+        "[bold cyan]⚡ botable[/] [dim]— generate Telegram bots with AI[/]"
+    )
+    console.print()
+    console.print(Panel(logo, border_style="cyan", padding=(0, 2)))
+    console.print()
+
+
+def success(msg: str) -> None:
+    """Print a success message."""
+    console.print(f"  [bold green]✅[/] {msg}")
+
+
+def error(msg: str) -> None:
+    """Print an error message."""
+    console.print(f"  [bold red]❌[/] {msg}")
+
+
+def info(msg: str) -> None:
+    """Print an info message."""
+    console.print(f"  [bold blue]ℹ[/]  {msg}")
+
+
+def warn(msg: str) -> None:
+    """Print a warning message."""
+    console.print(f"  [bold yellow]⚠️[/]  {msg}")
+
+
+def step(n: int, msg: str) -> None:
+    """Print a numbered step."""
+    console.print(f"  [bold cyan]{n}.[/] {msg}")