botable-dev 0.3.1__py3-none-any.whl

botable/config.py

@@ -0,0 +1,193 @@
+"""
+Configuration loading for Botable CLI.
+
+Three config layers:
+1. botable.toml   — project config (committed to git)
+2. .env           — secrets (BOT_TOKEN, API keys — NOT committed)
+3. ~/.config/botable/config.toml — global user config (API URL, auth token)
+"""
+from __future__ import annotations
+
+import os
+import sys
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+from dotenv import load_dotenv
+
+# Use tomllib (3.11+) or tomli (backport)
+if sys.version_info >= (3, 11):
+    import tomllib
+else:
+    try:
+        import tomli as tomllib  # type: ignore[no-redef]
+    except ImportError:
+        tomllib = None  # type: ignore[assignment]
+
+try:
+    import tomli_w
+except ImportError:
+    tomli_w = None
+
+
+# ── Paths ────────────────────────────────────────────────────────────────────
+
+GLOBAL_CONFIG_DIR = Path.home() / ".config" / "botable"
+GLOBAL_CONFIG_FILE = GLOBAL_CONFIG_DIR / "config.toml"
+
+
+def _find_project_root() -> Optional[Path]:
+    """Walk up from CWD to find a directory containing botable.toml."""
+    cwd = Path.cwd()
+    for parent in [cwd, *cwd.parents]:
+        if (parent / "botable.toml").exists():
+            return parent
+    return None
+
+
+# ── Project config ───────────────────────────────────────────────────────────
+
+def load_project_config() -> Optional[Dict[str, Any]]:
+    """Load botable.toml from the project root.
+
+    Returns None if no botable.toml found.
+    """
+    root = _find_project_root()
+    if root is None:
+        return None
+
+    toml_path = root / "botable.toml"
+
+    if tomllib is None:
+        # Fallback: return minimal config
+        return {"_project_root": str(root)}
+
+    with open(toml_path, "rb") as f:
+        config = tomllib.load(f)
+
+    config["_project_root"] = str(root)
+    return config
+
+
+def save_project_config(config: Dict[str, Any], path: Path) -> None:
+    """Write botable.toml to disk."""
+    if tomli_w is None:
+        raise RuntimeError("tomli_w not installed — cannot write TOML")
+
+    # Remove internal keys
+    clean = {k: v for k, v in config.items() if not k.startswith("_")}
+    with open(path, "wb") as f:
+        tomli_w.dump(clean, f)
+
+
+# ── Environment ──────────────────────────────────────────────────────────────
+
+def load_env() -> None:
+    """Load .env from the project root."""
+    root = _find_project_root()
+    if root:
+        load_dotenv(root / ".env")
+
+
+def get_bot_token() -> Optional[str]:
+    """Get BOT_TOKEN from environment."""
+    load_env()
+    return os.environ.get("BOT_TOKEN")
+
+
+def get_openai_key() -> Optional[str]:
+    """Get OPENAI_API_KEY from environment or global config."""
+    load_env()
+    key = os.environ.get("OPENAI_API_KEY")
+    if key:
+        return key
+    config = load_global_config()
+    return config.get("openai_api_key")
+
+
+# ── Global config ────────────────────────────────────────────────────────────
+
+def load_global_config() -> Dict[str, Any]:
+    """Load ~/.config/botable/config.toml."""
+    if not GLOBAL_CONFIG_FILE.exists():
+        return {}
+
+    if tomllib is None:
+        return {}
+
+    with open(GLOBAL_CONFIG_FILE, "rb") as f:
+        return tomllib.load(f)
+
+
+def save_global_config(config: Dict[str, Any]) -> None:
+    """Save global config to ~/.config/botable/config.toml."""
+    if tomli_w is None:
+        raise RuntimeError("tomli_w not installed — cannot write TOML")
+
+    GLOBAL_CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    fd = os.open(GLOBAL_CONFIG_FILE, os.O_WRONLY | os.O_CREAT, 0o600)
+    with os.fdopen(fd, "wb") as f:
+        if hasattr(os, "fchmod"):
+            os.fchmod(f.fileno(), 0o600)
+        else:
+            os.chmod(GLOBAL_CONFIG_FILE, 0o600)
+        f.truncate()
+        tomli_w.dump(config, f)
+
+
+DEFAULT_API_URL = "https://api-staging.botable.dev"
+
+
+def get_api_url() -> str:
+    """Get the Botable API URL from global config or environment."""
+    # Priority: env var > global config > default
+    url = os.environ.get("BOTABLE_API_URL")
+    if url:
+        return url
+
+    config = load_global_config()
+    # Staging until the CLI routes reach production (owner decision 18.10.2026)
+    return config.get("api_url", DEFAULT_API_URL)
+
+
+def get_auth_token() -> Optional[str]:
+    """Get the user's auth token from global config."""
+    config = load_global_config()
+    return config.get("auth_token")
+
+
+# ── Branding config ──────────────────────────────────────────────────────────
+
+def get_branding_config() -> Dict[str, Any]:
+    """Get branding settings with 3-layer merge: defaults ← user ← project.
+
+    Config hierarchy (like Claude Code's CLAUDE.md pattern):
+      1. Built-in defaults
+      2. ~/.config/botable/config.toml → [branding]
+      3. ./botable.toml → [branding]   (project override wins)
+
+    Example in botable.toml:
+        [branding]
+        enabled = true
+        text = "Built with Botable (botable.dev)"
+        style = "comment"
+
+    To disable branding globally:
+        ~/.config/botable/config.toml:
+        [branding]
+        enabled = false
+    """
+    defaults: Dict[str, Any] = {
+        "enabled": True,
+        "text": "Built with Botable (botable.dev)",
+        "style": "comment",  # "comment" | "docstring" | "none"
+    }
+
+    # Layer 1: user global config
+    user_branding = load_global_config().get("branding", {})
+
+    # Layer 2: project config (highest priority)
+    project = load_project_config()
+    project_branding = (project or {}).get("branding", {})
+
+    return {**defaults, **user_branding, **project_branding}

botable/errors.py

@@ -0,0 +1,53 @@
+"""
+Typed exceptions for Botable CLI.
+
+Provides clean error hierarchy for consistent handling across commands.
+"""
+from __future__ import annotations
+
+
+class BotableError(Exception):
+    """Base exception for all Botable CLI errors."""
+
+
+class AuthError(BotableError):
+    """No API key configured — user needs to run `botable login`."""
+
+    def __init__(self, msg: str = "Not logged in. Run: botable login --api-key YOUR_KEY"):
+        super().__init__(msg)
+
+
+class ProjectError(BotableError):
+    """Project not found or misconfigured."""
+
+    def __init__(self, msg: str = "No botable.toml found. Run: botable init"):
+        super().__init__(msg)
+
+
+class APIError(BotableError):
+    """Backend returned an error response."""
+
+    def __init__(self, status_code: int, detail: str):
+        self.status_code = status_code
+        self.detail = detail
+        super().__init__(f"API error {status_code}: {detail}")
+
+    @classmethod
+    def from_httpx(cls, exc) -> "APIError":
+        """Extract detail from an httpx.HTTPStatusError."""
+        status = exc.response.status_code if exc.response else 0
+        detail = str(exc)
+        if exc.response is not None:
+            try:
+                body = exc.response.json()
+                detail = body.get("detail", body.get("message", detail))
+            except Exception:
+                pass
+        return cls(status, detail)
+
+
+class NetworkError(BotableError):
+    """Cannot reach the Botable API."""
+
+    def __init__(self, msg: str = "Cannot reach Botable API. Check your connection."):
+        super().__init__(msg)

botable/generate.py

@@ -0,0 +1,288 @@
+"""
+Bot generation engine for Botable CLI.
+
+Calls OpenAI directly to generate aiogram bot code, validates it,
+and writes output files to the project directory.
+"""
+from __future__ import annotations
+
+import ast
+import os
+import sys
+from pathlib import Path
+from typing import Optional
+
+from rich.console import Console
+from rich.live import Live
+from rich.panel import Panel
+from rich.spinner import Spinner
+from rich.text import Text
+
+from botable.config import load_env, load_project_config, get_branding_config
+from botable.prompts import SYSTEM_PROMPT, REQUIREMENTS_PROMPT
+from botable.ui import success, error, info, warn
+
+console = Console()
+
+# ── Default model ────────────────────────────────────────────────────────────
+
+DEFAULT_MODEL = "gpt-4o-mini"
+
+
+# ── Public API ───────────────────────────────────────────────────────────────
+
+def run_generate(description: str, model: str = DEFAULT_MODEL) -> bool:
+    """Generate a bot from description. Returns True on success."""
+    import asyncio
+    return asyncio.run(_generate_async(description, model))
+
+
+async def _generate_async(description: str, model: str) -> bool:
+    """Async generation pipeline: prompt → LLM → validate → write."""
+    # 1. Load config
+    load_env()
+    config = load_project_config()
+    if config is None:
+        error("No [yellow]botable.toml[/] found. Run [cyan]botable init[/] first.")
+        return False
+
+    project_root = Path(config["_project_root"])
+
+    # 2. Get OpenAI API key
+    api_key = os.environ.get("OPENAI_API_KEY")
+    if not api_key:
+        error("OPENAI_API_KEY not found. Add it to your [yellow].env[/] file:")
+        console.print("    [dim]echo 'OPENAI_API_KEY=sk-...' >> .env[/]")
+        return False
+
+    # 3. Import OpenAI (deferred to avoid import errors if not installed)
+    try:
+        from openai import AsyncOpenAI
+    except ImportError:
+        error("openai package not installed. Run:")
+        console.print("    [dim]pip install openai[/]")
+        return False
+
+    client = AsyncOpenAI(api_key=api_key)
+
+    # 4. Generate code with streaming UI
+    console.print()
+    code = await _generate_code(client, description, model)
+    if code is None:
+        return False
+
+    # 5. Clean up markdown wrappers if present
+    code = _strip_markdown(code)
+
+    # 6. Validate generated code
+    validation_ok = _validate_code(code)
+    if not validation_ok:
+        warn("Generated code has warnings — writing anyway.")
+
+    # 7. Generate requirements
+    requirements = await _generate_requirements(client, description, model)
+
+    # 8. Write files
+    _write_output(project_root, code, requirements, config)
+
+    return True
+
+
+# ── Code generation ──────────────────────────────────────────────────────────
+
+async def _generate_code(client, description: str, model: str) -> Optional[str]:
+    """Call OpenAI to generate bot code with streaming progress."""
+    from openai import APIError
+
+    status_text = Text()
+    spinner = Spinner("dots", text=status_text)
+
+    try:
+        status_text.plain = f"  Planning bot: {description[:60]}..."
+        with Live(spinner, console=console, refresh_per_second=12) as live:
+            # Stream the response
+            stream = await client.chat.completions.create(
+                model=model,
+                messages=[
+                    {"role": "system", "content": SYSTEM_PROMPT},
+                    {"role": "user", "content": f"Generate a Telegram bot: {description}"},
+                ],
+                stream=True,
+                temperature=0.3,
+                max_tokens=4096,
+            )
+
+            chunks = []
+            char_count = 0
+            status_text.plain = "  Generating code..."
+
+            async for chunk in stream:
+                delta = chunk.choices[0].delta.content
+                if delta:
+                    chunks.append(delta)
+                    char_count += len(delta)
+                    status_text.plain = f"  Generating code... ({char_count} chars)"
+
+        success(f"Code generated ({char_count} chars)")
+        return "".join(chunks)
+
+    except APIError as e:
+        error(f"OpenAI API error: {e.message}")
+        return None
+    except Exception as e:
+        error(f"Generation failed: {e}")
+        return None
+
+
+# ── Requirements generation ──────────────────────────────────────────────────
+
+async def _generate_requirements(client, description: str, model: str) -> str:
+    """Generate requirements.txt content based on bot description."""
+    try:
+        resp = await client.chat.completions.create(
+            model=model,
+            messages=[
+                {"role": "user", "content": REQUIREMENTS_PROMPT.format(description=description)},
+            ],
+            temperature=0.0,
+            max_tokens=200,
+        )
+        raw = resp.choices[0].message.content.strip()
+
+        # Parse and deduplicate
+        packages = set()
+        for line in raw.splitlines():
+            pkg = line.strip().lower()
+            # Skip comments, empty lines, stdlib modules
+            if pkg and not pkg.startswith("#") and pkg not in {
+                "os", "sys", "asyncio", "json", "re", "datetime", "logging",
+                "pathlib", "typing", "collections", "time", "hashlib",
+            }:
+                packages.add(pkg)
+
+        # Ensure aiogram and python-dotenv always present
+        packages.add("aiogram")
+        packages.add("python-dotenv")
+
+        return "\n".join(sorted(packages)) + "\n"
+
+    except Exception:
+        # Fallback: minimal requirements
+        return "aiogram\npython-dotenv\n"
+
+
+# ── Code validation ─────────────────────────────────────────────────────────
+
+def _validate_code(code: str) -> bool:
+    """Basic validation of generated code. Returns True if code is OK."""
+    errors_found = []
+
+    # 1. Syntax check
+    try:
+        ast.parse(code)
+    except SyntaxError as e:
+        errors_found.append(f"SyntaxError at line {e.lineno}: {e.msg}")
+
+    # 2. Check for aiogram import
+    if "aiogram" not in code:
+        errors_found.append("Missing aiogram import")
+
+    # 3. Check for __main__ guard
+    if "__main__" not in code:
+        errors_found.append("Missing if __name__ == '__main__' guard")
+
+    # 4. Check for dotenv
+    if "dotenv" not in code:
+        errors_found.append("Missing dotenv usage")
+
+    if errors_found:
+        for e in errors_found:
+            warn(f"Validation: {e}")
+        return False
+
+    success("Code validation passed")
+    return True
+
+
+# ── Markdown cleanup ─────────────────────────────────────────────────────────
+
+def _strip_markdown(code: str) -> str:
+    """Remove markdown code fences if LLM wrapped the output."""
+    code = code.strip()
+    if code.startswith("```python"):
+        code = code[len("```python"):].strip()
+    elif code.startswith("```"):
+        code = code[3:].strip()
+    if code.endswith("```"):
+        code = code[:-3].strip()
+    return code
+
+
+# ── File writing ─────────────────────────────────────────────────────────────
+
+def _write_output(
+    project_root: Path,
+    code: str,
+    requirements: str,
+    config: dict,
+) -> None:
+    """Write generated files to the project directory."""
+    # Inject branding if enabled
+    branding = get_branding_config()
+    if branding.get("enabled", True) and branding.get("style") != "none":
+        branding_text = branding.get("text", "Built with Botable (botable.dev)")
+        if branding.get("style") == "docstring":
+            code = f'"""{branding_text}"""\n\n' + code
+        else:  # default: comment
+            code = f"# {branding_text}\n\n" + code
+
+    # Write main.py
+    main_path = project_root / "main.py"
+    main_path.write_text(code, encoding="utf-8")
+    line_count = len(code.splitlines())
+    success(f"Written [cyan]main.py[/] ({line_count} lines)")
+
+    # Write requirements.txt
+    req_path = project_root / "requirements.txt"
+    req_path.write_text(requirements, encoding="utf-8")
+    pkg_count = len([l for l in requirements.splitlines() if l.strip()])
+    success(f"Written [cyan]requirements.txt[/] ({pkg_count} packages)")
+
+    # Update .env if needed — add env var placeholders
+    env_path = project_root / ".env"
+    existing_env = env_path.read_text(encoding="utf-8") if env_path.exists() else ""
+
+    env_additions = []
+    if "OPENAI_API_KEY" in code and "OPENAI_API_KEY" not in existing_env:
+        env_additions.append("# OPENAI_API_KEY=sk-your-key-here")
+
+    extra_keys = _detect_env_vars(code)
+    for key in extra_keys:
+        if key not in existing_env and key not in ("TELEGRAM_BOT_TOKEN", "OPENAI_API_KEY"):
+            env_additions.append(f"# {key}=your-value-here")
+
+    if env_additions:
+        with open(env_path, "a", encoding="utf-8") as f:
+            f.write("\n# --- Added by botable generate ---\n")
+            for line in env_additions:
+                f.write(line + "\n")
+        info(f"Updated [yellow].env[/] with {len(env_additions)} new variable placeholders")
+
+    # Final instructions
+    console.print()
+    console.print(
+        Panel(
+            "[bold green]Bot generated![/]\n\n"
+            "  1. Edit [yellow].env[/] — fill in any missing keys\n"
+            "  2. Run [bold cyan]botable dev[/] to start locally",
+            border_style="green",
+            padding=(1, 2),
+        )
+    )
+
+
+def _detect_env_vars(code: str) -> list[str]:
+    """Detect os.getenv() calls in code to find required env vars."""
+    import re
+    pattern = r'os\.getenv\(\s*["\']([A-Z_]+)["\']\s*\)'
+    return list(dict.fromkeys(re.findall(pattern, code)))

botable/mcp_install.py

@@ -0,0 +1,72 @@
+"""Register the installed botable-mcp console script with coding agents."""
+
+import json
+import os
+import re
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+from botable.config import tomllib
+
+
+def _mcp_command() -> str:
+    found = shutil.which("botable-mcp")
+    if found:
+        return str(Path(found).resolve())
+    # CLI run from a venv that is not on PATH (.venv/bin/botable): the script sits next to this Python.
+    sibling = Path(sys.executable).with_name("botable-mcp")
+    if sibling.is_file() and os.access(sibling, os.X_OK):
+        return str(sibling)
+    return "botable-mcp"
+
+
+def install_claude(scope: str) -> str:
+    executable = _mcp_command()
+    command = ["claude", "mcp", "add", "--scope", scope, "botable", "--", executable]
+    if shutil.which("claude"):
+        subprocess.run(["claude", "mcp", "remove", "--scope", scope, "botable"], check=False)
+        print("Running: " + " ".join(command))
+        subprocess.run(command, check=True)
+        return "Registered Botable MCP with Claude Code."
+
+    if scope != "project":
+        raise FileNotFoundError("Claude CLI unavailable; use --scope project to write .mcp.json.")
+
+    path = Path.cwd() / ".mcp.json"
+    data = json.loads(path.read_text(encoding="utf-8")) if path.exists() else {}
+    data.setdefault("mcpServers", {})["botable"] = {"command": executable}
+    path.write_text(json.dumps(data, indent=2) + "\n", encoding="utf-8")
+    return f"Claude CLI unavailable; merged project config {path} (project scope)."
+
+
+def install_codex() -> str:
+    executable = _mcp_command()
+    path = Path.home() / ".codex" / "config.toml"
+    raw = path.read_bytes() if path.exists() else b""
+    newline = "\r\n" if b"\r\n" in raw else "\n"
+    original = raw.decode("utf-8").replace("\r\n", "\n")
+    parsed = tomllib.loads(original) if original else {}
+    current = parsed.get("mcp_servers", {}).get("botable")
+    if isinstance(current, dict) and current.get("command") == executable and "args" not in current:
+        return f"Codex already configured: {path}"
+
+    section = re.search(r"(?m)^\[mcp_servers\.botable\][ \t]*\n", original)
+    if section:
+        next_section = re.search(r"(?m)^\[", original[section.end():])
+        end = section.end() + next_section.start() if next_section else len(original)
+        body = original[section.end():end]
+        body = re.sub(r'(?m)^(?:command|args)[ \t]*=.*\n?', '', body)
+        updated = original[:section.end()] + f"command = {json.dumps(executable)}\n" + body + original[end:]
+    elif current is not None:
+        raise ValueError("Unsupported inline Botable MCP config; edit it manually")
+    else:
+        updated = original.rstrip() + ('\n\n' if original.strip() else '') + f'[mcp_servers.botable]\ncommand = {json.dumps(executable)}\n'
+    tomllib.loads(updated)  # Refuse to write malformed TOML.
+    path.parent.mkdir(parents=True, exist_ok=True)
+    if path.exists():
+        backup = path.with_suffix(".toml.bak")
+        shutil.copy2(path, backup)
+    path.write_bytes(updated.replace("\n", newline).encode("utf-8"))
+    return f"Merged Codex config {path}" + (f" (backup: {backup})" if original else "")