bps-kit 1.0.1 → 1.0.2

package/templates/vault/skill-sentinel/scripts/scanner.py

@@ -0,0 +1,271 @@
+"""
+Scanner de skills: descobre e inventaria todas as skills do ecossistema.
+
+Percorre os diretorios conhecidos procurando SKILL.md com frontmatter YAML,
+e coleta metricas de arquivo para cada skill encontrada.
+
+Uso:
+    from scanner import SkillScanner
+    scanner = SkillScanner()
+    skills = scanner.discover_all()
+    for s in skills:
+        print(s["name"], s["path"], s["file_count"])
+"""
+from __future__ import annotations
+
+import ast
+import re
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from config import (
+    IGNORE_DIRS,
+    SKILL_MAX_DEPTH,
+    SKILL_SEARCH_PATHS,
+    SKILLS_ROOT,
+)
+
+
+def _parse_yaml_frontmatter(content: str) -> Dict[str, str]:
+    """Extrai frontmatter YAML simples de um arquivo SKILL.md."""
+    if not content.startswith("---"):
+        return {}
+    end = content.find("---", 3)
+    if end == -1:
+        return {}
+    frontmatter = content[3:end].strip()
+    result = {}
+    for line in frontmatter.split("\n"):
+        line = line.strip()
+        if not line or line.startswith("#"):
+            continue
+        # Tratar continuacao de description com >-
+        if ":" in line and not line.startswith("-") and not line.startswith(" "):
+            key, _, value = line.partition(":")
+            key = key.strip()
+            value = value.strip().strip('"').strip("'")
+            if value == ">-" or value == ">":
+                # Multi-line: coletar proximas linhas indentadas
+                continue
+            result[key] = value
+        elif line.startswith(" ") and "description" not in result:
+            # Continuacao multi-line de description
+            result.setdefault("description", "")
+            result["description"] += " " + line.strip()
+    # Limpar description
+    if "description" in result:
+        result["description"] = result["description"].strip().strip('"').strip("'")
+    return result
+
+
+def _count_lines(filepath: Path) -> int:
+    """Conta linhas de um arquivo de texto."""
+    try:
+        return len(filepath.read_text(encoding="utf-8", errors="replace").splitlines())
+    except (OSError, UnicodeDecodeError):
+        return 0
+
+
+# .claude is an explicit SKILL_SEARCH_PATH so its .py files must be scanned
+_PY_IGNORE_DIRS = IGNORE_DIRS - {".claude"}
+
+
+def _list_python_files(directory: Path) -> List[Path]:
+    """Lista todos os .py dentro de um diretorio (recursivo)."""
+    result = []
+    if not directory.exists():
+        return result
+    for p in directory.rglob("*.py"):
+        if not any(part in _PY_IGNORE_DIRS for part in p.parts):
+            result.append(p)
+    return sorted(result)
+
+
+def _extract_functions(filepath: Path) -> List[Dict[str, Any]]:
+    """Extrai informacoes de funcoes/classes via AST."""
+    try:
+        source = filepath.read_text(encoding="utf-8", errors="replace")
+        tree = ast.parse(source, filename=str(filepath))
+    except (SyntaxError, OSError):
+        return []
+
+    functions = []
+    for node in ast.walk(tree):
+        if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+            functions.append({
+                "name": node.name,
+                "type": "async_function" if isinstance(node, ast.AsyncFunctionDef) else "function",
+                "line": node.lineno,
+                "end_line": getattr(node, "end_lineno", node.lineno),
+                "has_docstring": (
+                    isinstance(node.body[0], ast.Expr)
+                    and isinstance(node.body[0].value, (ast.Constant, ast.Str))
+                    if node.body else False
+                ),
+                "args_count": len(node.args.args),
+            })
+        elif isinstance(node, ast.ClassDef):
+            functions.append({
+                "name": node.name,
+                "type": "class",
+                "line": node.lineno,
+                "end_line": getattr(node, "end_lineno", node.lineno),
+                "has_docstring": (
+                    isinstance(node.body[0], ast.Expr)
+                    and isinstance(node.body[0].value, (ast.Constant, ast.Str))
+                    if node.body else False
+                ),
+                "args_count": 0,
+            })
+    return functions
+
+
+def _parse_requirements(skill_dir: Path) -> List[Dict[str, str]]:
+    """Parse requirements.txt se existir."""
+    reqs_path = skill_dir / "scripts" / "requirements.txt"
+    if not reqs_path.exists():
+        return []
+    deps = []
+    try:
+        for line in reqs_path.read_text(encoding="utf-8").splitlines():
+            line = line.strip()
+            if not line or line.startswith("#") or line.startswith("-"):
+                continue
+            # Parse "package==1.0" ou "package>=1.0" ou "package"
+            match = re.match(r'^([a-zA-Z0-9_-]+)\s*([><=!~]+)?\s*([\d.]*)', line)
+            if match:
+                deps.append({
+                    "name": match.group(1),
+                    "version_spec": (match.group(2) or "") + (match.group(3) or ""),
+                    "pinned": "==" in (match.group(2) or ""),
+                })
+    except OSError:
+        pass
+    return deps
+
+
+class SkillScanner:
+    """Descobre e inventaria skills no ecossistema."""
+
+    def __init__(self, skills_root: Path = SKILLS_ROOT):
+        self.skills_root = skills_root
+
+    def discover_all(self) -> List[Dict[str, Any]]:
+        """Descobre todas as skills, retornando metadados enriquecidos."""
+        skill_dirs = self._find_skill_dirs()
+        skills = []
+        for skill_dir in skill_dirs:
+            info = self._analyze_skill(skill_dir)
+            if info:
+                skills.append(info)
+        return sorted(skills, key=lambda s: s["name"])
+
+    def discover_skill(self, name: str) -> Optional[Dict[str, Any]]:
+        """Descobre uma skill especifica pelo nome."""
+        for skill in self.discover_all():
+            if skill["name"] == name:
+                return skill
+        return None
+
+    def _find_skill_dirs(self) -> List[Path]:
+        """Encontra diretorios que contem SKILL.md."""
+        found = []
+        for search_path in SKILL_SEARCH_PATHS:
+            if not search_path.exists():
+                continue
+            self._search_recursive(search_path, found, depth=0)
+        # Deduplica
+        seen = set()
+        unique = []
+        for p in found:
+            resolved = p.resolve()
+            if resolved not in seen:
+                seen.add(resolved)
+                unique.append(p)
+        return unique
+
+    def _search_recursive(self, directory: Path, found: List[Path], depth: int) -> None:
+        """Busca recursiva por SKILL.md com limite de profundidade."""
+        if depth > SKILL_MAX_DEPTH:
+            return
+        try:
+            for item in sorted(directory.iterdir()):
+                if not item.is_dir():
+                    continue
+                if item.name in IGNORE_DIRS:
+                    continue
+                skill_md = item / "SKILL.md"
+                if skill_md.exists():
+                    found.append(item)
+                else:
+                    self._search_recursive(item, found, depth + 1)
+        except PermissionError:
+            pass
+
+    def _analyze_skill(self, skill_dir: Path) -> Optional[Dict[str, Any]]:
+        """Analisa uma skill e retorna metadados completos."""
+        skill_md = skill_dir / "SKILL.md"
+        if not skill_md.exists():
+            return None
+
+        try:
+            content = skill_md.read_text(encoding="utf-8", errors="replace")
+        except OSError:
+            return None
+
+        meta = _parse_yaml_frontmatter(content)
+        if not meta.get("name"):
+            # Inferir nome do diretorio
+            meta["name"] = skill_dir.name
+
+        py_files = _list_python_files(skill_dir / "scripts")
+        total_lines = sum(_count_lines(f) for f in py_files)
+
+        all_functions = {}
+        for f in py_files:
+            funcs = _extract_functions(f)
+            if funcs:
+                all_functions[str(f.relative_to(skill_dir))] = funcs
+
+        ref_dir = skill_dir / "references"
+        ref_files = sorted(ref_dir.glob("*.md")) if ref_dir.exists() else []
+
+        deps = _parse_requirements(skill_dir)
+
+        return {
+            "name": meta.get("name", skill_dir.name),
+            "path": str(skill_dir),
+            "version": meta.get("version", ""),
+            "description": meta.get("description", ""),
+            "skill_md_path": str(skill_md),
+            "skill_md_lines": _count_lines(skill_md),
+            "python_files": [str(f.relative_to(skill_dir)) for f in py_files],
+            "file_count": len(py_files),
+            "line_count": total_lines,
+            "functions": all_functions,
+            "requirements": deps,
+            "reference_files": [str(f.relative_to(skill_dir)) for f in ref_files],
+            "has_scripts_dir": (skill_dir / "scripts").is_dir(),
+            "has_references_dir": ref_dir.is_dir(),
+            "has_data_dir": (skill_dir / "data").is_dir(),
+            "has_governance": any("governance" in f.name for f in py_files),
+            "has_db": any("db" in f.name for f in py_files),
+            "has_config": any("config" in f.name for f in py_files),
+        }
+
+
+# -- CLI -----------------------------------------------------------------------
+if __name__ == "__main__":
+    import json
+    scanner = SkillScanner()
+    skills = scanner.discover_all()
+    print(f"Skills encontradas: {len(skills)}\n")
+    for s in skills:
+        print(f"  {s['name']} (v{s['version'] or '?'})")
+        print(f"    Path: {s['path']}")
+        print(f"    Files: {s['file_count']} Python ({s['line_count']} lines)")
+        print(f"    Refs: {len(s['reference_files'])} docs")
+        print(f"    Gov: {'sim' if s['has_governance'] else 'nao'} | "
+              f"DB: {'sim' if s['has_db'] else 'nao'} | "
+              f"Config: {'sim' if s['has_config'] else 'nao'}")
+        print()

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

@@ -0,0 +1,266 @@
+"""
+Configuracao central da skill Stability AI.
+
+Gerencia: API keys, modelos, formatos, aspect ratios, limites de seguranca.
+"""
+from __future__ import annotations
+
+import json
+import os
+from datetime import datetime
+from pathlib import Path
+
+# ── Paths ────────────────────────────────────────────────────────────────────
+
+ROOT_DIR = Path(__file__).resolve().parent.parent
+SCRIPTS_DIR = ROOT_DIR / "scripts"
+DATA_DIR = ROOT_DIR / "data"
+OUTPUT_DIR = DATA_DIR / "outputs"
+OUTPUT_DIR.mkdir(parents=True, exist_ok=True)
+
+# ── API ──────────────────────────────────────────────────────────────────────
+
+API_BASE = "https://api.stability.ai/v2beta"
+USER_AGENT = "StabilityAI-Skill/2.0"
+
+ENDPOINTS = {
+    "generate_sd3": "/stable-image/generate/sd3",
+    "generate_ultra": "/stable-image/generate/ultra",
+    "generate_core": "/stable-image/generate/core",
+    "upscale_conservative": "/stable-image/upscale/conservative",
+    "upscale_creative": "/stable-image/upscale/creative",
+    "remove_bg": "/stable-image/edit/remove-background",
+    "inpaint": "/stable-image/edit/inpaint",
+    "search_replace": "/stable-image/edit/search-and-replace",
+    "erase": "/stable-image/edit/erase",
+    "outpaint": "/stable-image/edit/outpaint",
+}
+
+# ── Modelos ──────────────────────────────────────────────────────────────────
+
+MODELS = {
+    "sd3.5-large": {
+        "id": "sd3.5-large",
+        "name": "Stable Diffusion 3.5 Large",
+        "endpoint": "generate_sd3",
+        "description": "Melhor qualidade geral. Recomendado para a maioria dos usos.",
+        "cost": "free",
+    },
+    "sd3.5-large-turbo": {
+        "id": "sd3.5-large-turbo",
+        "name": "SD 3.5 Large Turbo",
+        "endpoint": "generate_sd3",
+        "description": "Versao rapida do SD 3.5. Menos passos, resultado bom.",
+        "cost": "free",
+    },
+    "sd3.5-medium": {
+        "id": "sd3.5-medium",
+        "name": "SD 3.5 Medium",
+        "endpoint": "generate_sd3",
+        "description": "Balanco entre velocidade e qualidade.",
+        "cost": "free",
+    },
+    "ultra": {
+        "id": "ultra",
+        "name": "Stable Image Ultra",
+        "endpoint": "generate_ultra",
+        "description": "Maxima qualidade. Fotorrealismo e detalhes extremos.",
+        "cost": "free",
+    },
+    "core": {
+        "id": "core",
+        "name": "Stable Image Core",
+        "endpoint": "generate_core",
+        "description": "Rapido e eficiente. Bom para iteracao.",
+        "cost": "free",
+    },
+}
+
+DEFAULT_MODEL = "sd3.5-large"
+
+# ── Aspect Ratios ────────────────────────────────────────────────────────────
+
+ASPECT_RATIOS = {
+    "square": "1:1",
+    "portrait": "2:3",
+    "landscape": "3:2",
+    "wide": "16:9",
+    "ultrawide": "21:9",
+    "stories": "9:16",
+    "phone": "9:21",
+    "photo": "4:5",
+    "cinema": "5:4",
+}
+
+ASPECT_ALIASES = {
+    # Valores diretos
+    "1:1": "1:1", "2:3": "2:3", "3:2": "3:2", "16:9": "16:9",
+    "21:9": "21:9", "9:16": "9:16", "9:21": "9:21", "4:5": "4:5", "5:4": "5:4",
+    # Portugues
+    "quadrado": "1:1", "retrato": "2:3", "paisagem": "3:2",
+    "widescreen": "16:9", "vertical": "9:16", "horizontal": "3:2",
+    # Plataformas
+    "ig": "1:1", "instagram": "1:1", "ig-feed": "4:5", "ig-stories": "9:16",
+    "youtube": "16:9", "yt": "16:9", "tiktok": "9:16", "reels": "9:16",
+    "twitter": "16:9", "x": "16:9", "facebook": "16:9", "fb": "16:9",
+    "pinterest": "2:3", "linkedin": "16:9",
+    "wallpaper": "16:9", "desktop": "16:9", "mobile": "9:16",
+}
+
+DEFAULT_ASPECT_RATIO = "1:1"
+
+# ── MIME Types ───────────────────────────────────────────────────────────────
+
+MIME_MAP = {
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".webp": "image/webp",
+    ".gif": "image/gif",
+    ".bmp": "image/bmp",
+    ".tiff": "image/tiff",
+    ".tif": "image/tiff",
+}
+
+# ── Output ───────────────────────────────────────────────────────────────────
+
+OUTPUT_SETTINGS = {
+    "format": "png",
+    "save_metadata": True,
+    "save_prompt": True,
+}
+
+# ── Limites de Seguranca ─────────────────────────────────────────────────────
+
+SAFETY_MAX_IMAGES_PER_DAY = int(os.environ.get("SAFETY_MAX_IMAGES_PER_DAY", "100"))
+
+
+# ── Funcoes ──────────────────────────────────────────────────────────────────
+
+
+def _parse_env_file(env_path: Path) -> dict[str, str]:
+    """Parse arquivo .env e retorna dict chave=valor."""
+    result: dict[str, str] = {}
+    if not env_path.exists():
+        return result
+    try:
+        for line in env_path.read_text(encoding="utf-8").splitlines():
+            line = line.strip()
+            if not line or line.startswith("#"):
+                continue
+            if "=" in line:
+                k, v = line.split("=", 1)
+                k = k.strip()
+                v = v.strip().strip('"').strip("'")
+                if k and v:
+                    result[k] = v
+    except (OSError, UnicodeDecodeError):
+        pass
+    return result
+
+
+def get_api_key() -> str | None:
+    """Busca a API key em ordem: env var > .env na skill."""
+    key = os.environ.get("STABILITY_API_KEY")
+    if key:
+        return key
+
+    env_data = _parse_env_file(ROOT_DIR / ".env")
+    return env_data.get("STABILITY_API_KEY")
+
+
+def get_all_api_keys() -> list[str]:
+    """Retorna todas as API keys (primaria + backups)."""
+    keys: list[str] = []
+    primary = get_api_key()
+    if primary:
+        keys.append(primary)
+
+    env_data = _parse_env_file(ROOT_DIR / ".env")
+    for k, v in env_data.items():
+        if k.startswith("STABILITY_API_KEY_BACKUP") and v and v not in keys:
+            keys.append(v)
+
+    return keys
+
+
+def resolve_aspect_ratio(name: str) -> str:
+    """Resolve nome ou alias para aspect ratio valido."""
+    name_lower = name.lower().strip()
+    if name_lower in ASPECT_RATIOS:
+        return ASPECT_RATIOS[name_lower]
+    if name_lower in ASPECT_ALIASES:
+        return ASPECT_ALIASES[name_lower]
+    if ":" in name and all(p.isdigit() for p in name.split(":")):
+        return name
+    return DEFAULT_ASPECT_RATIO
+
+
+def get_mime_type(filepath: Path) -> str:
+    """Retorna MIME type baseado na extensao do arquivo."""
+    return MIME_MAP.get(filepath.suffix.lower(), "image/png")
+
+
+def safety_check_daily_limit(num_images: int = 1) -> tuple[bool, str]:
+    """Verifica se nao excedeu limite diario."""
+    today = datetime.now().strftime("%Y-%m-%d")
+    counter_file = DATA_DIR / "daily_counter.json"
+
+    count = 0
+    if counter_file.exists():
+        try:
+            data = json.loads(counter_file.read_text(encoding="utf-8"))
+            if data.get("date") == today:
+                count = data.get("count", 0)
+        except (json.JSONDecodeError, KeyError, OSError):
+            pass
+
+    if count + num_images > SAFETY_MAX_IMAGES_PER_DAY:
+        return False, (
+            f"LIMITE DIARIO: {count}/{SAFETY_MAX_IMAGES_PER_DAY} imagens hoje. "
+            f"Tentando gerar {num_images} mais. "
+            f"Configure SAFETY_MAX_IMAGES_PER_DAY para ajustar."
+        )
+
+    return True, f"OK: {count}/{SAFETY_MAX_IMAGES_PER_DAY} imagens hoje."
+
+
+def increment_daily_counter(num_images: int = 1) -> None:
+    """Incrementa o contador diario de forma segura."""
+    today = datetime.now().strftime("%Y-%m-%d")
+    counter_file = DATA_DIR / "daily_counter.json"
+
+    count = 0
+    if counter_file.exists():
+        try:
+            data = json.loads(counter_file.read_text(encoding="utf-8"))
+            if data.get("date") == today:
+                count = data.get("count", 0)
+        except (json.JSONDecodeError, KeyError, OSError):
+            pass
+
+    try:
+        counter_file.parent.mkdir(parents=True, exist_ok=True)
+        counter_file.write_text(
+            json.dumps({"date": today, "count": count + num_images}, indent=2),
+            encoding="utf-8",
+        )
+    except OSError:
+        pass  # Falha silenciosa no contador nao deve bloquear geracao
+
+
+def validate_image_file(filepath: str | Path) -> Path:
+    """Valida que o arquivo de imagem existe e tem extensao suportada."""
+    path = Path(filepath)
+    if not path.exists():
+        raise FileNotFoundError(f"Arquivo nao encontrado: {path}")
+    if not path.is_file():
+        raise ValueError(f"Nao e um arquivo: {path}")
+    if path.suffix.lower() not in MIME_MAP:
+        supported = ", ".join(MIME_MAP.keys())
+        raise ValueError(f"Formato nao suportado: {path.suffix}. Suportados: {supported}")
+    if path.stat().st_size == 0:
+        raise ValueError(f"Arquivo vazio: {path}")
+    if path.stat().st_size > 50 * 1024 * 1024:  # 50MB
+        raise ValueError(f"Arquivo muito grande ({path.stat().st_size / 1024 / 1024:.1f}MB). Max: 50MB")
+    return path