bps-kit 1.0.1 → 1.0.2

package/templates/vault/i18n-localization/scripts/i18n_checker.py

@@ -0,0 +1,241 @@
+#!/usr/bin/env python3
+"""
+i18n Checker - Detects hardcoded strings and missing translations.
+Scans for untranslated text in React, Vue, and Python files.
+"""
+import sys
+import re
+import json
+from pathlib import Path
+
+# Fix Windows console encoding for Unicode output
+try:
+    sys.stdout.reconfigure(encoding='utf-8', errors='replace')
+    sys.stderr.reconfigure(encoding='utf-8', errors='replace')
+except AttributeError:
+    pass  # Python < 3.7
+
+# Patterns that indicate hardcoded strings (should be translated)
+HARDCODED_PATTERNS = {
+    'jsx': [
+        # Text directly in JSX: <div>Hello World</div>
+        r'>\s*[A-Z][a-zA-Z\s]{3,30}\s*</',
+        # JSX attribute strings: title="Welcome"
+        r'(title|placeholder|label|alt|aria-label)="[A-Z][a-zA-Z\s]{2,}"',
+        # Button/heading text
+        r'<(button|h[1-6]|p|span|label)[^>]*>\s*[A-Z][a-zA-Z\s!?.,]{3,}\s*</',
+    ],
+    'vue': [
+        # Vue template text
+        r'>\s*[A-Z][a-zA-Z\s]{3,30}\s*</',
+        r'(placeholder|label|title)="[A-Z][a-zA-Z\s]{2,}"',
+    ],
+    'python': [
+        # print/raise with string literals
+        r'(print|raise\s+\w+)\s*\(\s*["\'][A-Z][^"\']{5,}["\']',
+        # Flask flash messages
+        r'flash\s*\(\s*["\'][A-Z][^"\']{5,}["\']',
+    ]
+}
+
+# Patterns that indicate proper i18n usage
+I18N_PATTERNS = [
+    r't\(["\']',           # t('key') - react-i18next
+    r'useTranslation',     # React hook
+    r'\$t\(',              # Vue i18n
+    r'_\(["\']',           # Python gettext
+    r'gettext\(',          # Python gettext
+    r'useTranslations',    # next-intl
+    r'FormattedMessage',   # react-intl
+    r'i18n\.',             # Generic i18n
+]
+
+def find_locale_files(project_path: Path) -> list:
+    """Find translation/locale files."""
+    patterns = [
+        "**/locales/**/*.json",
+        "**/translations/**/*.json",
+        "**/lang/**/*.json",
+        "**/i18n/**/*.json",
+        "**/messages/*.json",
+        "**/*.po",  # gettext
+    ]
+    
+    files = []
+    for pattern in patterns:
+        files.extend(project_path.glob(pattern))
+    
+    return [f for f in files if 'node_modules' not in str(f)]
+
+def check_locale_completeness(locale_files: list) -> dict:
+    """Check if all locales have the same keys."""
+    issues = []
+    passed = []
+    
+    if not locale_files:
+        return {'passed': [], 'issues': ["[!] No locale files found"]}
+    
+    # Group by parent folder (language)
+    locales = {}
+    for f in locale_files:
+        if f.suffix == '.json':
+            try:
+                lang = f.parent.name
+                content = json.loads(f.read_text(encoding='utf-8'))
+                if lang not in locales:
+                    locales[lang] = {}
+                locales[lang][f.stem] = set(flatten_keys(content))
+            except:
+                continue
+    
+    if len(locales) < 2:
+        passed.append(f"[OK] Found {len(locale_files)} locale file(s)")
+        return {'passed': passed, 'issues': issues}
+    
+    passed.append(f"[OK] Found {len(locales)} language(s): {', '.join(locales.keys())}")
+    
+    # Compare keys across locales
+    all_langs = list(locales.keys())
+    base_lang = all_langs[0]
+    
+    for namespace in locales.get(base_lang, {}):
+        base_keys = locales[base_lang].get(namespace, set())
+        
+        for lang in all_langs[1:]:
+            other_keys = locales.get(lang, {}).get(namespace, set())
+            
+            missing = base_keys - other_keys
+            if missing:
+                issues.append(f"[X] {lang}/{namespace}: Missing {len(missing)} keys")
+            
+            extra = other_keys - base_keys
+            if extra:
+                issues.append(f"[!] {lang}/{namespace}: {len(extra)} extra keys")
+    
+    if not issues:
+        passed.append("[OK] All locales have matching keys")
+    
+    return {'passed': passed, 'issues': issues}
+
+def flatten_keys(d, prefix=''):
+    """Flatten nested dict keys."""
+    keys = set()
+    for k, v in d.items():
+        new_key = f"{prefix}.{k}" if prefix else k
+        if isinstance(v, dict):
+            keys.update(flatten_keys(v, new_key))
+        else:
+            keys.add(new_key)
+    return keys
+
+def check_hardcoded_strings(project_path: Path) -> dict:
+    """Check for hardcoded strings in code files."""
+    issues = []
+    passed = []
+    
+    # Find code files
+    extensions = {
+        '.tsx': 'jsx', '.jsx': 'jsx', '.ts': 'jsx', '.js': 'jsx',
+        '.vue': 'vue',
+        '.py': 'python'
+    }
+    
+    code_files = []
+    for ext in extensions:
+        code_files.extend(project_path.rglob(f"*{ext}"))
+    
+    code_files = [f for f in code_files if not any(x in str(f) for x in 
+                  ['node_modules', '.git', 'dist', 'build', '__pycache__', 'venv', 'test', 'spec'])]
+    
+    if not code_files:
+        return {'passed': ["[!] No code files found"], 'issues': []}
+    
+    files_with_i18n = 0
+    files_with_hardcoded = 0
+    hardcoded_examples = []
+    
+    for file_path in code_files[:50]:  # Limit
+        try:
+            content = file_path.read_text(encoding='utf-8', errors='ignore')
+            ext = file_path.suffix
+            file_type = extensions.get(ext, 'jsx')
+            
+            # Check for i18n usage
+            has_i18n = any(re.search(p, content) for p in I18N_PATTERNS)
+            if has_i18n:
+                files_with_i18n += 1
+            
+            # Check for hardcoded strings
+            patterns = HARDCODED_PATTERNS.get(file_type, [])
+            hardcoded_found = False
+            
+            for pattern in patterns:
+                matches = re.findall(pattern, content)
+                if matches and not has_i18n:
+                    hardcoded_found = True
+                    if len(hardcoded_examples) < 5:
+                        hardcoded_examples.append(f"{file_path.name}: {str(matches[0])[:40]}...")
+            
+            if hardcoded_found:
+                files_with_hardcoded += 1
+                
+        except:
+            continue
+    
+    passed.append(f"[OK] Analyzed {len(code_files)} code files")
+    
+    if files_with_i18n > 0:
+        passed.append(f"[OK] {files_with_i18n} files use i18n")
+    
+    if files_with_hardcoded > 0:
+        issues.append(f"[X] {files_with_hardcoded} files may have hardcoded strings")
+        for ex in hardcoded_examples:
+            issues.append(f"   → {ex}")
+    else:
+        passed.append("[OK] No obvious hardcoded strings detected")
+    
+    return {'passed': passed, 'issues': issues}
+
+def main():
+    target = sys.argv[1] if len(sys.argv) > 1 else "."
+    project_path = Path(target)
+    
+    print("\n" + "=" * 60)
+    print("  i18n CHECKER - Internationalization Audit")
+    print("=" * 60 + "\n")
+    
+    # Check locale files
+    locale_files = find_locale_files(project_path)
+    locale_result = check_locale_completeness(locale_files)
+    
+    # Check hardcoded strings
+    code_result = check_hardcoded_strings(project_path)
+    
+    # Print results
+    print("[LOCALE FILES]")
+    print("-" * 40)
+    for item in locale_result['passed']:
+        print(f"  {item}")
+    for item in locale_result['issues']:
+        print(f"  {item}")
+    
+    print("\n[CODE ANALYSIS]")
+    print("-" * 40)
+    for item in code_result['passed']:
+        print(f"  {item}")
+    for item in code_result['issues']:
+        print(f"  {item}")
+    
+    # Summary
+    critical_issues = sum(1 for i in locale_result['issues'] + code_result['issues'] if i.startswith("[X]"))
+    
+    print("\n" + "=" * 60)
+    if critical_issues == 0:
+        print("[OK] i18n CHECK: PASSED")
+        sys.exit(0)
+    else:
+        print(f"[X] i18n CHECK: {critical_issues} issues found")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()

package/templates/vault/instagram/scripts/account_setup.py

@@ -0,0 +1,233 @@
+"""
+Configuração e verificação de conta Instagram.
+
+Uso:
+    python scripts/account_setup.py --check     # Detecta tipo de conta
+    python scripts/account_setup.py --guide     # Guia de setup/migração
+    python scripts/account_setup.py --verify    # Verifica pré-requisitos
+"""
+from __future__ import annotations
+
+import argparse
+import asyncio
+import json
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).parent))
+
+from api_client import InstagramAPI, InstagramAPIError
+from db import Database
+
+db = Database()
+db.init()
+
+
+async def check_account() -> None:
+    """Detecta tipo de conta e status."""
+    account = db.get_active_account()
+    if not account:
+        print(json.dumps({
+            "status": "not_configured",
+            "message": "Nenhuma conta configurada.",
+            "next_step": "Execute: python scripts/auth.py --setup",
+        }, indent=2, ensure_ascii=False))
+        return
+
+    try:
+        api = InstagramAPI()
+        profile = await api.get_user_profile()
+        await api.close()
+
+        result = {
+            "status": "ok",
+            "username": profile.get("username"),
+            "account_type": profile.get("account_type"),
+            "name": profile.get("name"),
+            "followers": profile.get("followers_count"),
+            "following": profile.get("follows_count"),
+            "posts": profile.get("media_count"),
+            "biography": profile.get("biography"),
+            "website": profile.get("website"),
+        }
+        print(json.dumps(result, indent=2, ensure_ascii=False))
+
+    except InstagramAPIError as e:
+        print(json.dumps({
+            "status": "error",
+            "error": str(e),
+            "code": e.code,
+            "suggestion": "Token pode estar expirado. Execute: python scripts/auth.py --refresh",
+        }, indent=2, ensure_ascii=False))
+    except ValueError as e:
+        print(json.dumps({
+            "status": "not_configured",
+            "error": str(e),
+        }, indent=2, ensure_ascii=False))
+
+
+def show_guide() -> None:
+    """Mostra guia de setup/migração."""
+    account = db.get_active_account()
+
+    checklist = []
+    checklist.append(("Facebook account", "OK" if True else "PENDENTE",
+                      "Crie em: https://www.facebook.com"))
+    checklist.append(("Instagram account", "OK" if account else "PENDENTE",
+                      "Crie em: https://www.instagram.com"))
+
+    account_type = account.get("account_type") if account else None
+    is_business = account_type in ("BUSINESS", "CREATOR") if account_type else False
+    checklist.append((
+        f"Conta Business/Creator (atual: {account_type or '?'})",
+        "OK" if is_business else "PENDENTE",
+        "Precisa ser Business ou Creator para usar a API",
+    ))
+
+    has_page = bool(account.get("facebook_page_id")) if account else False
+    checklist.append(("Facebook Page vinculada", "OK" if has_page else "PENDENTE",
+                      "Vincule uma Page à sua conta Instagram"))
+
+    has_token = bool(account.get("access_token")) if account else False
+    checklist.append(("Token OAuth", "OK" if has_token else "PENDENTE",
+                      "Execute: python scripts/auth.py --setup"))
+
+    print()
+    print("=" * 65)
+    print("CHECKLIST DE CONFIGURAÇÃO - INSTAGRAM")
+    print("=" * 65)
+
+    for item, status, hint in checklist:
+        icon = "[OK]" if status == "OK" else "[!!]"
+        print(f"  {icon}  {item}")
+        if status != "OK":
+            print(f"       -> {hint}")
+
+    print()
+
+    if not is_business:
+        print("-" * 65)
+        print("COMO MIGRAR PARA CONTA BUSINESS:")
+        print("-" * 65)
+        print("""
+  1. Abra o app Instagram → Configurações → Conta
+  2. Toque em "Mudar para conta profissional"
+  3. Selecione "Business" (para empresas) ou "Creator" (para criadores)
+  4. Conecte à sua Facebook Page (ou crie uma)
+  5. Após migrar, execute: python scripts/account_setup.py --check
+""")
+
+    if not has_page:
+        print("-" * 65)
+        print("COMO CRIAR/VINCULAR FACEBOOK PAGE:")
+        print("-" * 65)
+        print("""
+  1. Acesse: https://www.facebook.com/pages/create
+  2. Crie uma Page para seu negócio/marca
+  3. No Instagram: Configurações → Conta → Contas vinculadas → Facebook
+  4. Vincule a Page recém-criada
+  5. Execute: python scripts/auth.py --setup
+""")
+
+    if not has_token:
+        print("-" * 65)
+        print("COMO CONFIGURAR O META APP:")
+        print("-" * 65)
+        print("""
+  1. Acesse: https://developers.facebook.com/apps/
+  2. Clique "Criar App" → Selecione "Business"
+  3. Em "Adicionar Produtos", adicione "Instagram Graph API"
+  4. No painel, copie App ID e App Secret
+  5. Execute: python scripts/auth.py --setup
+  6. Cole o App ID e App Secret quando solicitado
+""")
+
+
+async def verify_setup() -> None:
+    """Verifica se todos os pré-requisitos estão OK."""
+    checks = []
+
+    # 1. Conta no banco
+    account = db.get_active_account()
+    checks.append({
+        "check": "Conta configurada",
+        "passed": account is not None,
+        "detail": f"@{account['username']}" if account else "Nenhuma conta",
+    })
+
+    if not account:
+        print(json.dumps({"checks": checks, "all_passed": False}, indent=2))
+        return
+
+    # 2. Token válido
+    try:
+        api = InstagramAPI()
+        profile = await api.get_user_profile()
+        checks.append({
+            "check": "Token válido",
+            "passed": True,
+            "detail": f"Conta @{profile.get('username')} acessível",
+        })
+    except Exception as e:
+        checks.append({
+            "check": "Token válido",
+            "passed": False,
+            "detail": str(e),
+        })
+        print(json.dumps({"checks": checks, "all_passed": False}, indent=2))
+        return
+
+    # 3. Tipo de conta
+    acct_type = profile.get("account_type", "UNKNOWN")
+    checks.append({
+        "check": "Conta Business/Creator",
+        "passed": acct_type in ("BUSINESS", "CREATOR"),
+        "detail": f"Tipo: {acct_type}",
+    })
+
+    # 4. Facebook Page vinculada
+    checks.append({
+        "check": "Facebook Page vinculada",
+        "passed": bool(account.get("facebook_page_id")),
+        "detail": f"Page ID: {account.get('facebook_page_id', 'N/A')}",
+    })
+
+    # 5. Permissões básicas (tenta buscar mídia)
+    try:
+        media = await api.get_user_media(limit=1)
+        checks.append({
+            "check": "Permissão instagram_basic",
+            "passed": True,
+            "detail": "OK - pode ler mídia",
+        })
+    except Exception:
+        checks.append({
+            "check": "Permissão instagram_basic",
+            "passed": False,
+            "detail": "Sem permissão para ler mídia",
+        })
+
+    await api.close()
+
+    all_passed = all(c["passed"] for c in checks)
+    print(json.dumps({"checks": checks, "all_passed": all_passed}, indent=2, ensure_ascii=False))
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Configuração de conta Instagram")
+    group = parser.add_mutually_exclusive_group(required=True)
+    group.add_argument("--check", action="store_true", help="Detecta tipo de conta")
+    group.add_argument("--guide", action="store_true", help="Guia de setup/migração")
+    group.add_argument("--verify", action="store_true", help="Verifica pré-requisitos")
+    args = parser.parse_args()
+
+    if args.check:
+        asyncio.run(check_account())
+    elif args.guide:
+        show_guide()
+    elif args.verify:
+        asyncio.run(verify_setup())
+
+
+if __name__ == "__main__":
+    main()

package/templates/vault/instagram/scripts/analyze.py

@@ -0,0 +1,221 @@
+"""
+Análise inteligente de dados do Instagram (SQL puro, sem dependências externas).
+
+Uso:
+    python scripts/analyze.py --best-times          # Melhores horários para postar
+    python scripts/analyze.py --top-posts --limit 10 # Top posts por engajamento
+    python scripts/analyze.py --growth --period 30   # Tendência de crescimento
+    python scripts/analyze.py --summary              # Resumo geral
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import sqlite3
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).parent))
+
+from config import DB_PATH
+from db import Database
+
+db = Database()
+db.init()
+
+
+def _connect() -> sqlite3.Connection:
+    conn = sqlite3.connect(DB_PATH)
+    conn.row_factory = sqlite3.Row
+    return conn
+
+
+def best_times() -> None:
+    """Analisa melhores horários para postar baseado em engajamento."""
+    conn = _connect()
+
+    # Agregar engajamento por hora do dia e dia da semana
+    sql = """
+    SELECT
+        strftime('%H', p.published_at) as hour,
+        strftime('%w', p.published_at) as weekday,
+        COUNT(DISTINCT p.id) as post_count,
+        AVG(i.metric_value) as avg_engagement,
+        MAX(i.metric_value) as max_engagement
+    FROM posts p
+    JOIN insights i ON i.ig_media_id = p.ig_media_id
+    WHERE p.status = 'published'
+      AND p.published_at IS NOT NULL
+      AND i.metric_name IN ('engagement', 'reach', 'impressions')
+    GROUP BY hour, weekday
+    HAVING post_count >= 1
+    ORDER BY avg_engagement DESC
+    """
+    rows = conn.execute(sql).fetchall()
+    conn.close()
+
+    if not rows:
+        # Tentar com dados de user_insights se não houver dados granulares
+        print(json.dumps({
+            "message": "Dados insuficientes para análise. Publique mais posts e busque insights primeiro.",
+            "tip": "Execute: python scripts/insights.py --fetch-all --limit 50",
+        }, indent=2, ensure_ascii=False))
+        return
+
+    weekday_names = ["Domingo", "Segunda", "Terça", "Quarta", "Quinta", "Sexta", "Sábado"]
+    results = []
+    for r in rows:
+        results.append({
+            "hour": f"{r['hour']}:00",
+            "weekday": weekday_names[int(r["weekday"])] if r["weekday"] else "?",
+            "posts_analyzed": r["post_count"],
+            "avg_engagement": round(r["avg_engagement"], 1),
+            "max_engagement": round(r["max_engagement"], 1),
+        })
+
+    # Top 5 melhores combinações hora/dia
+    print(json.dumps({
+        "analysis": "best_times",
+        "top_5": results[:5],
+        "all_data": results,
+    }, indent=2, ensure_ascii=False))
+
+
+def top_posts(limit: int = 10) -> None:
+    """Lista top posts por engajamento."""
+    conn = _connect()
+    sql = """
+    SELECT
+        p.id, p.ig_media_id, p.media_type, p.permalink, p.published_at,
+        SUBSTR(p.caption, 1, 80) as caption_preview,
+        SUM(CASE WHEN i.metric_name = 'engagement' THEN i.metric_value ELSE 0 END) as engagement,
+        SUM(CASE WHEN i.metric_name = 'impressions' THEN i.metric_value ELSE 0 END) as impressions,
+        SUM(CASE WHEN i.metric_name = 'reach' THEN i.metric_value ELSE 0 END) as reach,
+        SUM(CASE WHEN i.metric_name = 'saved' THEN i.metric_value ELSE 0 END) as saves
+    FROM posts p
+    LEFT JOIN insights i ON i.ig_media_id = p.ig_media_id
+    WHERE p.status = 'published'
+    GROUP BY p.id
+    ORDER BY engagement DESC
+    LIMIT ?
+    """
+    rows = conn.execute(sql, [limit]).fetchall()
+    conn.close()
+
+    results = [dict(r) for r in rows]
+    print(json.dumps({"analysis": "top_posts", "total": len(results), "posts": results}, indent=2, ensure_ascii=False))
+
+
+def growth_trend(period_days: int = 30) -> None:
+    """Analisa tendência de crescimento."""
+    conn = _connect()
+    sql = """
+    SELECT
+        DATE(end_time) as date,
+        metric_name,
+        metric_value
+    FROM user_insights
+    WHERE end_time >= date('now', ?)
+      AND metric_name IN ('follower_count', 'reach', 'impressions', 'profile_views')
+    ORDER BY end_time ASC
+    """
+    rows = conn.execute(sql, [f"-{period_days} days"]).fetchall()
+    conn.close()
+
+    if not rows:
+        print(json.dumps({
+            "message": "Sem dados de crescimento. Busque insights da conta primeiro.",
+            "tip": "Execute: python scripts/insights.py --user --period day --since 30",
+        }, indent=2, ensure_ascii=False))
+        return
+
+    # Agrupar por métrica
+    metrics = {}
+    for r in rows:
+        name = r["metric_name"]
+        if name not in metrics:
+            metrics[name] = []
+        metrics[name].append({"date": r["date"], "value": r["metric_value"]})
+
+    # Calcular variação
+    summary = {}
+    for name, data in metrics.items():
+        if len(data) >= 2:
+            first = data[0]["value"]
+            last = data[-1]["value"]
+            change = last - first
+            pct = (change / first * 100) if first > 0 else 0
+            summary[name] = {
+                "first_value": first,
+                "last_value": last,
+                "change": change,
+                "change_pct": round(pct, 1),
+                "data_points": len(data),
+            }
+
+    print(json.dumps({
+        "analysis": "growth",
+        "period_days": period_days,
+        "summary": summary,
+        "details": metrics,
+    }, indent=2, ensure_ascii=False))
+
+
+def overall_summary() -> None:
+    """Resumo geral da conta."""
+    stats = db.get_stats()
+    conn = _connect()
+
+    # Engajamento médio
+    avg_engagement = conn.execute("""
+        SELECT AVG(metric_value) as avg_val
+        FROM insights WHERE metric_name = 'engagement'
+    """).fetchone()
+
+    # Posts esta semana
+    posts_this_week = conn.execute("""
+        SELECT COUNT(*) FROM posts
+        WHERE status = 'published' AND published_at >= date('now', '-7 days')
+    """).fetchone()[0]
+
+    # Último post
+    last_post = conn.execute("""
+        SELECT published_at, SUBSTR(caption, 1, 60) as caption
+        FROM posts WHERE status = 'published'
+        ORDER BY published_at DESC LIMIT 1
+    """).fetchone()
+
+    conn.close()
+
+    result = {
+        "database_stats": stats,
+        "avg_engagement": round(avg_engagement["avg_val"], 1) if avg_engagement and avg_engagement["avg_val"] else 0,
+        "posts_this_week": posts_this_week,
+        "last_post": dict(last_post) if last_post else None,
+    }
+    print(json.dumps(result, indent=2, ensure_ascii=False))
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Análise de dados Instagram")
+    group = parser.add_mutually_exclusive_group(required=True)
+    group.add_argument("--best-times", action="store_true", help="Melhores horários para postar")
+    group.add_argument("--top-posts", action="store_true", help="Top posts por engajamento")
+    group.add_argument("--growth", action="store_true", help="Tendência de crescimento")
+    group.add_argument("--summary", action="store_true", help="Resumo geral")
+    parser.add_argument("--limit", type=int, default=10, help="Limite (para --top-posts)")
+    parser.add_argument("--period", type=int, default=30, help="Dias (para --growth)")
+    args = parser.parse_args()
+
+    if args.best_times:
+        best_times()
+    elif args.top_posts:
+        top_posts(args.limit)
+    elif args.growth:
+        growth_trend(args.period)
+    elif args.summary:
+        overall_summary()
+
+
+if __name__ == "__main__":
+    main()