bps-kit 1.0.1 → 1.0.2

package/templates/vault/stability-ai/scripts/styles.py

@@ -0,0 +1,174 @@
+"""
+Presets de estilo para Stability AI.
+
+Cada estilo adiciona qualificadores ao prompt do usuario para direcionar
+o modelo na direcao visual desejada. Use --style <nome> no CLI.
+"""
+from __future__ import annotations
+
+STYLES = {
+    "photorealistic": {
+        "name": "Fotorrealismo",
+        "suffix": (
+            "photorealistic, hyperrealistic, 8k uhd, high resolution, "
+            "sharp focus, professional photography, natural lighting, "
+            "film grain, bokeh, shot on Canon EOS R5"
+        ),
+        "negative": "cartoon, painting, illustration, drawing, anime, cgi, render",
+    },
+    "anime": {
+        "name": "Anime / Manga",
+        "suffix": (
+            "anime style, manga art, cel shading, vibrant colors, "
+            "clean linework, detailed eyes, studio ghibli inspired, "
+            "high quality anime illustration"
+        ),
+        "negative": "photorealistic, photo, 3d render, western cartoon",
+    },
+    "digital-art": {
+        "name": "Arte Digital",
+        "suffix": (
+            "digital art, highly detailed, digital painting, artstation, "
+            "concept art, smooth, sharp focus, illustration, "
+            "professional digital artwork"
+        ),
+        "negative": "photo, photograph, low quality, blurry",
+    },
+    "oil-painting": {
+        "name": "Pintura a Oleo",
+        "suffix": (
+            "oil painting on canvas, thick brushstrokes, rich texture, "
+            "classical art, warm color palette, museum quality, "
+            "rembrandt lighting, chiaroscuro"
+        ),
+        "negative": "digital, photo, smooth, flat, cartoon",
+    },
+    "watercolor": {
+        "name": "Aquarela",
+        "suffix": (
+            "watercolor painting, soft washes, translucent layers, "
+            "wet on wet technique, delicate details, paper texture visible, "
+            "flowing colors, artistic watercolor illustration"
+        ),
+        "negative": "digital, photo, sharp edges, bold outlines",
+    },
+    "pixel-art": {
+        "name": "Pixel Art",
+        "suffix": (
+            "pixel art, 16-bit, retro game style, limited color palette, "
+            "crisp pixels, no anti-aliasing, nostalgic, 8-bit aesthetic"
+        ),
+        "negative": "realistic, photo, smooth, high resolution, blurry",
+    },
+    "3d-render": {
+        "name": "Render 3D",
+        "suffix": (
+            "3d render, octane render, unreal engine 5, ray tracing, "
+            "volumetric lighting, subsurface scattering, physically based rendering, "
+            "cinema 4d, blender cycles, ultra detailed"
+        ),
+        "negative": "2d, flat, painting, sketch, low poly",
+    },
+    "concept-art": {
+        "name": "Concept Art",
+        "suffix": (
+            "concept art, highly detailed, professional illustration, "
+            "trending on artstation, matte painting, dynamic composition, "
+            "cinematic, dramatic lighting, epic scale"
+        ),
+        "negative": "photo, amateur, low quality, simple",
+    },
+    "comic": {
+        "name": "Comics / HQ",
+        "suffix": (
+            "comic book style, bold outlines, halftone dots, dynamic pose, "
+            "vivid colors, graphic novel illustration, ink drawing, "
+            "professional comic art"
+        ),
+        "negative": "photorealistic, soft, watercolor, oil painting",
+    },
+    "minimalist": {
+        "name": "Minimalista",
+        "suffix": (
+            "minimalist design, clean lines, simple shapes, "
+            "limited color palette, negative space, modern aesthetic, "
+            "flat design, geometric, elegant simplicity"
+        ),
+        "negative": "complex, detailed, busy, cluttered, realistic",
+    },
+    "fantasy": {
+        "name": "Fantasy Art",
+        "suffix": (
+            "epic fantasy art, magical atmosphere, ethereal glow, "
+            "detailed fantasy illustration, mystical, enchanted, "
+            "dramatic lighting, heroic, masterpiece"
+        ),
+        "negative": "modern, mundane, realistic, photo",
+    },
+    "sci-fi": {
+        "name": "Sci-Fi Futurista",
+        "suffix": (
+            "science fiction art, futuristic, neon lights, cyberpunk, "
+            "advanced technology, holographic, chrome and glass, "
+            "blade runner aesthetic, high tech"
+        ),
+        "negative": "medieval, fantasy, natural, organic, rustic",
+    },
+    "sketch": {
+        "name": "Desenho a Lapis",
+        "suffix": (
+            "pencil sketch, graphite drawing, detailed linework, "
+            "cross-hatching, shading, paper texture, hand-drawn, "
+            "charcoal drawing, artist sketchbook"
+        ),
+        "negative": "color, painted, digital, photo, saturated",
+    },
+    "pop-art": {
+        "name": "Pop Art",
+        "suffix": (
+            "pop art style, bold primary colors, ben-day dots, "
+            "high contrast, graphic, screen print effect, "
+            "vibrant and eye-catching"
+        ),
+        "negative": "realistic, muted colors, subtle, natural",
+    },
+    "noir": {
+        "name": "Film Noir",
+        "suffix": (
+            "film noir style, black and white, dramatic shadows, "
+            "high contrast, moody atmosphere, venetian blinds shadow, "
+            "detective story aesthetic, 1940s cinema"
+        ),
+        "negative": "colorful, bright, cheerful, modern, flat lighting",
+    },
+}
+
+DEFAULT_STYLE = None
+
+
+def get_style(name: str) -> dict | None:
+    """Retorna configuracao de um estilo ou None se nao existe."""
+    return STYLES.get(name.lower().strip())
+
+
+def list_styles() -> dict:
+    """Retorna todos os estilos disponiveis."""
+    return STYLES
+
+
+def apply_style(prompt: str, style_name: str | None) -> tuple[str, str | None]:
+    """
+    Aplica estilo ao prompt.
+
+    Retorna (prompt_modificado, negative_prompt).
+    Se estilo nao encontrado, retorna prompt original.
+    """
+    if not style_name:
+        return prompt, None
+
+    style = get_style(style_name)
+    if not style:
+        return prompt, None
+
+    enhanced = f"{prompt}, {style['suffix']}"
+    return enhanced, style.get("negative")

package/templates/vault/telegram/assets/boilerplate/nodejs/src/bot-client.ts

@@ -0,0 +1,86 @@
+import TelegramBot from 'node-telegram-bot-api';
+import express from 'express';
+
+export class TelegramBotClient {
+  public bot: TelegramBot;
+  private token: string;
+
+  constructor(token: string, webhookMode: boolean = false) {
+    this.token = token;
+    this.bot = new TelegramBot(token, {
+      polling: !webhookMode,
+    });
+  }
+
+  async startPolling(): Promise<void> {
+    const me = await this.bot.getMe();
+    console.log(`Bot @${me.username} (${me.first_name}) started with polling`);
+  }
+
+  async startWebhook(port: number, webhookUrl: string, secret?: string): Promise<void> {
+    const app = express();
+    app.use(express.json());
+
+    // Webhook endpoint
+    app.post(`/webhook/${this.token}`, (req, res) => {
+      if (secret) {
+        const headerSecret = req.headers['x-telegram-bot-api-secret-token'];
+        if (headerSecret !== secret) {
+          return res.sendStatus(403);
+        }
+      }
+      this.bot.processUpdate(req.body);
+      res.sendStatus(200);
+    });
+
+    // Health check
+    app.get('/health', (_req, res) => {
+      res.json({ status: 'ok', bot: 'running' });
+    });
+
+    // Register webhook with Telegram
+    await this.bot.setWebHook(`${webhookUrl}/webhook/${this.token}`, {
+      max_connections: 40,
+      secret_token: secret,
+    } as any);
+
+    const info = await this.bot.getWebHookInfo();
+    console.log('Webhook registered:', info.url);
+
+    app.listen(port, () => {
+      console.log(`Express server listening on port ${port}`);
+    });
+
+    const me = await this.bot.getMe();
+    console.log(`Bot @${me.username} (${me.first_name}) started with webhook`);
+  }
+
+  /**
+   * Send a text message with automatic retry on rate limit.
+   */
+  async sendMessageSafe(
+    chatId: number | string,
+    text: string,
+    options?: TelegramBot.SendMessageOptions
+  ): Promise<TelegramBot.Message | null> {
+    const maxRetries = 3;
+    for (let attempt = 0; attempt < maxRetries; attempt++) {
+      try {
+        return await this.bot.sendMessage(chatId, text, options);
+      } catch (error: any) {
+        if (error?.response?.statusCode === 429) {
+          const retryAfter = error.response.body?.parameters?.retry_after || 5;
+          console.warn(`Rate limited. Retrying after ${retryAfter}s...`);
+          await new Promise((r) => setTimeout(r, retryAfter * 1000));
+          continue;
+        }
+        if (error?.response?.statusCode === 403) {
+          console.warn(`Bot blocked by user ${chatId}`);
+          return null;
+        }
+        throw error;
+      }
+    }
+    return null;
+  }
+}

package/templates/vault/telegram/assets/boilerplate/nodejs/src/handlers.ts

@@ -0,0 +1,79 @@
+import { TelegramBotClient } from './bot-client';
+import TelegramBot from 'node-telegram-bot-api';
+
+export function registerHandlers(client: TelegramBotClient): void {
+  const bot = client.bot;
+
+  // /start command
+  bot.onText(/\/start/, async (msg) => {
+    const name = msg.from?.first_name || 'usuario';
+    await client.sendMessageSafe(
+      msg.chat.id,
+      `Ola, ${name}! Bem-vindo ao bot.\n\nComandos disponiveis:\n/start - Iniciar\n/help - Ajuda\n/about - Sobre`,
+      { parse_mode: 'HTML' }
+    );
+  });
+
+  // /help command
+  bot.onText(/\/help/, async (msg) => {
+    await client.sendMessageSafe(
+      msg.chat.id,
+      '<b>Comandos:</b>\n' +
+        '/start - Iniciar o bot\n' +
+        '/help - Ver esta mensagem\n' +
+        '/about - Informacoes sobre o bot\n' +
+        '/echo &lt;texto&gt; - Repetir texto',
+      { parse_mode: 'HTML' }
+    );
+  });
+
+  // /about command
+  bot.onText(/\/about/, async (msg) => {
+    const me = await bot.getMe();
+    await client.sendMessageSafe(
+      msg.chat.id,
+      `<b>${me.first_name}</b>\n@${me.username}\n\nBot criado com Telegram Bot API`,
+      { parse_mode: 'HTML' }
+    );
+  });
+
+  // /echo command
+  bot.onText(/\/echo (.+)/, async (msg, match) => {
+    const text = match?.[1] || '';
+    await client.sendMessageSafe(msg.chat.id, text);
+  });
+
+  // Callback query handler (for inline keyboards)
+  bot.on('callback_query', async (query) => {
+    await bot.answerCallbackQuery(query.id, { text: `Opcao: ${query.data}` });
+
+    if (query.message) {
+      await bot.editMessageText(`Voce escolheu: ${query.data}`, {
+        chat_id: query.message.chat.id,
+        message_id: query.message.message_id,
+      });
+    }
+  });
+
+  // Default message handler (echo)
+  bot.on('message', async (msg) => {
+    // Skip commands
+    if (msg.text?.startsWith('/')) return;
+
+    // Echo non-command text messages
+    if (msg.text) {
+      await client.sendMessageSafe(msg.chat.id, `Voce disse: ${msg.text}`);
+    }
+  });
+
+  // Error handler
+  bot.on('polling_error', (error) => {
+    console.error('Polling error:', error.message);
+  });
+
+  bot.on('webhook_error', (error) => {
+    console.error('Webhook error:', error.message);
+  });
+
+  console.log('All handlers registered');
+}

package/templates/vault/telegram/assets/boilerplate/nodejs/src/index.ts

@@ -0,0 +1,32 @@
+import dotenv from 'dotenv';
+dotenv.config();
+
+import { TelegramBotClient } from './bot-client';
+import { registerHandlers } from './handlers';
+
+async function main() {
+  const token = process.env.TELEGRAM_BOT_TOKEN;
+  if (!token) {
+    console.error('ERROR: Set TELEGRAM_BOT_TOKEN in .env file');
+    process.exit(1);
+  }
+
+  const useWebhook = !!process.env.WEBHOOK_URL;
+  const client = new TelegramBotClient(token, useWebhook);
+
+  // Register all command and message handlers
+  registerHandlers(client);
+
+  if (useWebhook) {
+    const port = parseInt(process.env.PORT || '3000');
+    const webhookUrl = process.env.WEBHOOK_URL!;
+    const secret = process.env.WEBHOOK_SECRET;
+    await client.startWebhook(port, webhookUrl, secret);
+    console.log(`Bot running in webhook mode on port ${port}`);
+  } else {
+    await client.startPolling();
+    console.log('Bot running in polling mode. Press Ctrl+C to stop.');
+  }
+}
+
+main().catch(console.error);

package/templates/vault/telegram/scripts/send_message.py

@@ -0,0 +1,143 @@
+#!/usr/bin/env python3
+"""
+Send a test message via Telegram Bot API.
+
+Usage:
+    python send_message.py --token "TOKEN" --chat-id "CHAT_ID" --text "Hello!"
+    python send_message.py --chat-id "CHAT_ID" --text "Hello!"  # Uses env var
+    python send_message.py --chat-id "CHAT_ID" --photo "https://example.com/img.jpg"
+    python send_message.py --chat-id "CHAT_ID" --document "/path/to/file.pdf"
+"""
+
+import argparse
+import json
+import os
+import sys
+from urllib.request import urlopen, Request
+from urllib.error import HTTPError
+
+
+def _mask_token(token: str) -> str:
+    """Return a masked version of the token for safe logging."""
+    if not token or len(token) < 12:
+        return "***masked***"
+    return f"{token[:8]}...masked"
+
+
+def api_call(token: str, method: str, data: dict) -> dict:
+    """Make a Telegram Bot API call."""
+    url = f"https://api.telegram.org/bot{token}/{method}"
+    payload = json.dumps(data).encode("utf-8")
+    req = Request(url, data=payload, headers={"Content-Type": "application/json"})
+
+    try:
+        with urlopen(req, timeout=30) as resp:
+            return json.loads(resp.read().decode())
+    except HTTPError as e:
+        error_body = json.loads(e.read().decode())
+        return error_body
+
+
+def send_text(token: str, chat_id: str, text: str, parse_mode: str = None,
+              silent: bool = False) -> dict:
+    """Send a text message."""
+    data = {"chat_id": chat_id, "text": text}
+    if parse_mode:
+        data["parse_mode"] = parse_mode
+    if silent:
+        data["disable_notification"] = True
+    return api_call(token, "sendMessage", data)
+
+
+def send_photo(token: str, chat_id: str, photo: str, caption: str = None) -> dict:
+    """Send a photo by URL or file_id."""
+    data = {"chat_id": chat_id, "photo": photo}
+    if caption:
+        data["caption"] = caption
+    return api_call(token, "sendPhoto", data)
+
+
+def send_document_url(token: str, chat_id: str, document: str, caption: str = None) -> dict:
+    """Send a document by URL."""
+    data = {"chat_id": chat_id, "document": document}
+    if caption:
+        data["caption"] = caption
+    return api_call(token, "sendDocument", data)
+
+
+def send_location(token: str, chat_id: str, lat: float, lon: float) -> dict:
+    """Send a location."""
+    return api_call(token, "sendLocation", {
+        "chat_id": chat_id,
+        "latitude": lat,
+        "longitude": lon
+    })
+
+
+def send_poll(token: str, chat_id: str, question: str, options: list) -> dict:
+    """Send a poll."""
+    return api_call(token, "sendPoll", {
+        "chat_id": chat_id,
+        "question": question,
+        "options": [{"text": opt} for opt in options]
+    })
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Send Telegram message")
+    parser.add_argument("--token", type=str, help="Bot token (or TELEGRAM_BOT_TOKEN env)")
+    parser.add_argument("--chat-id", type=str, required=True, help="Target chat ID")
+    parser.add_argument("--text", type=str, help="Text message to send")
+    parser.add_argument("--parse-mode", type=str, choices=["HTML", "MarkdownV2", "Markdown"],
+                        help="Parse mode for text formatting")
+    parser.add_argument("--photo", type=str, help="Photo URL to send")
+    parser.add_argument("--document", type=str, help="Document URL to send")
+    parser.add_argument("--caption", type=str, help="Caption for photo/document")
+    parser.add_argument("--location", type=str, help="Location as 'lat,lon'")
+    parser.add_argument("--poll", type=str, help="Poll question")
+    parser.add_argument("--poll-options", type=str, nargs="+", help="Poll options")
+    parser.add_argument("--silent", action="store_true", help="Send without notification")
+    args = parser.parse_args()
+
+    token = args.token or os.environ.get("TELEGRAM_BOT_TOKEN")
+    if not token:
+        print("ERROR: Provide --token or set TELEGRAM_BOT_TOKEN environment variable")
+        sys.exit(1)
+
+    masked = _mask_token(token)
+    result = None
+
+    if args.text:
+        print(f"Sending text to {args.chat_id}...")
+        result = send_text(token, args.chat_id, args.text, args.parse_mode, args.silent)
+    elif args.photo:
+        print(f"Sending photo to {args.chat_id}...")
+        result = send_photo(token, args.chat_id, args.photo, args.caption)
+    elif args.document:
+        print(f"Sending document to {args.chat_id}...")
+        result = send_document_url(token, args.chat_id, args.document, args.caption)
+    elif args.location:
+        lat, lon = map(float, args.location.split(","))
+        print(f"Sending location to {args.chat_id}...")
+        result = send_location(token, args.chat_id, lat, lon)
+    elif args.poll and args.poll_options:
+        print(f"Sending poll to {args.chat_id}...")
+        result = send_poll(token, args.chat_id, args.poll, args.poll_options)
+    else:
+        print("ERROR: Provide --text, --photo, --document, --location, or --poll")
+        sys.exit(1)
+
+    if result and result.get("ok"):
+        msg = result["result"]
+        print(f"OK - Message sent! ID: {msg.get('message_id')}")
+        print(f"     Chat: {msg.get('chat', {}).get('title', msg.get('chat', {}).get('first_name', 'N/A'))}")
+        print(f"     Date: {msg.get('date')}")
+    else:
+        # Mask token in error output to prevent credential leakage
+        safe_output = json.dumps(result, indent=2, ensure_ascii=False).replace(token, masked)
+        print(f"FAIL - {safe_output}")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

package/templates/vault/telegram/scripts/setup_project.py

@@ -0,0 +1,103 @@
+#!/usr/bin/env python3
+"""
+Setup a new Telegram Bot project with boilerplate code.
+
+Usage:
+    python setup_project.py --language nodejs --path ./my-telegram-bot
+    python setup_project.py --language python --path ./my-telegram-bot
+    python setup_project.py --language python --path ./my-bot --with-webhook --with-ai
+"""
+
+import argparse
+import os
+import shutil
+import sys
+
+SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
+SKILL_DIR = os.path.dirname(SCRIPT_DIR)
+BOILERPLATE_DIR = os.path.join(SKILL_DIR, "assets", "boilerplate")
+
+
+def setup_nodejs(project_path: str, with_webhook: bool = False, with_ai: bool = False):
+    """Setup Node.js/TypeScript project."""
+    src_dir = os.path.join(BOILERPLATE_DIR, "nodejs")
+
+    if not os.path.exists(src_dir):
+        print(f"ERROR: Boilerplate not found at {src_dir}")
+        sys.exit(1)
+
+    # Copy boilerplate
+    shutil.copytree(src_dir, project_path, dirs_exist_ok=True)
+
+    print(f"Node.js project created at: {project_path}")
+    print("\nNext steps:")
+    print(f"  1. cd {project_path}")
+    print("  2. npm install")
+    print("  3. Copy .env.example to .env and add your bot token")
+    print("  4. npm run dev  (development with hot reload)")
+    print("  5. npm run build && npm start  (production)")
+
+    if with_webhook:
+        print("\n  Webhook mode enabled - configure WEBHOOK_URL in .env")
+    if with_ai:
+        print("\n  AI integration enabled - configure ANTHROPIC_API_KEY in .env")
+
+
+def setup_python(project_path: str, with_webhook: bool = False, with_ai: bool = False):
+    """Setup Python project."""
+    src_dir = os.path.join(BOILERPLATE_DIR, "python")
+
+    if not os.path.exists(src_dir):
+        print(f"ERROR: Boilerplate not found at {src_dir}")
+        sys.exit(1)
+
+    # Copy boilerplate
+    shutil.copytree(src_dir, project_path, dirs_exist_ok=True)
+
+    print(f"Python project created at: {project_path}")
+    print("\nNext steps:")
+    print(f"  1. cd {project_path}")
+    print("  2. pip install -r requirements.txt")
+    print("  3. Copy .env.example to .env and add your bot token")
+    print("  4. python bot.py  (long polling mode)")
+
+    if with_webhook:
+        print("  5. python webhook_server.py  (webhook mode)")
+    if with_ai:
+        print("\n  AI integration enabled - configure ANTHROPIC_API_KEY in .env")
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Setup Telegram Bot project")
+    parser.add_argument("--language", type=str, required=True,
+                        choices=["nodejs", "python"],
+                        help="Project language")
+    parser.add_argument("--path", type=str, required=True,
+                        help="Project directory path")
+    parser.add_argument("--with-webhook", action="store_true",
+                        help="Include webhook server setup")
+    parser.add_argument("--with-ai", action="store_true",
+                        help="Include AI integration boilerplate")
+    parser.add_argument("--force", action="store_true",
+                        help="Overwrite existing directory")
+    args = parser.parse_args()
+
+    project_path = os.path.abspath(args.path)
+
+    if os.path.exists(project_path) and not args.force:
+        print(f"ERROR: Directory already exists: {project_path}")
+        print("Use --force to overwrite")
+        sys.exit(1)
+
+    os.makedirs(project_path, exist_ok=True)
+
+    if args.language == "nodejs":
+        setup_nodejs(project_path, args.with_webhook, args.with_ai)
+    elif args.language == "python":
+        setup_python(project_path, args.with_webhook, args.with_ai)
+
+    print("\nDone!")
+
+
+if __name__ == "__main__":
+    main()