@techwavedev/agi-agent-kit 1.5.2 → 1.6.0

package/templates/skills/extended/other/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()

package/templates/skills/extended/other/instagram/scripts/api_client.py

@@ -0,0 +1,444 @@
+"""
+Cliente da Instagram Graph API com retry, rate limiting e logging integrados.
+
+Uso:
+    from api_client import InstagramAPI
+
+    api = InstagramAPI()
+    profile = await api.get_user_profile()
+    media = await api.get_user_media(limit=10)
+    await api.close()
+"""
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+import sys
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+sys.path.insert(0, str(Path(__file__).parent))
+
+import httpx
+
+from config import (
+    GRAPH_API_BASE,
+    IMGUR_CLIENT_ID,
+    IMGUR_UPLOAD_URL,
+    MAX_RETRIES,
+    REQUEST_TIMEOUT,
+    RETRY_BACKOFF_BASE,
+)
+from db import Database
+from governance import GovernanceManager, RateLimitExceeded
+
+logger = logging.getLogger(__name__)
+
+
+class InstagramAPIError(Exception):
+    """Erro da Instagram Graph API."""
+
+    def __init__(self, message: str, code: Optional[int] = None, subcode: Optional[int] = None):
+        self.code = code
+        self.subcode = subcode
+        super().__init__(message)
+
+    def is_rate_limit(self) -> bool:
+        return self.code in (4, 17, 32)
+
+    def is_permission_error(self) -> bool:
+        return self.code in (10, 200, 190)
+
+
+class InstagramAPI:
+    """Wrapper da Instagram Graph API com governança integrada."""
+
+    def __init__(
+        self,
+        account_id: Optional[int] = None,
+        db: Optional[Database] = None,
+        governance: Optional[GovernanceManager] = None,
+    ):
+        self._db = db or Database()
+        self._db.init()
+        self._gov = governance or GovernanceManager(self._db)
+        self._client: Optional[httpx.AsyncClient] = None
+
+        # Carregar conta
+        if account_id:
+            self._account = self._db.get_account_by_id(account_id)
+        else:
+            self._account = self._db.get_active_account()
+
+        if not self._account:
+            raise ValueError(
+                "Nenhuma conta Instagram configurada. Execute: python scripts/auth.py --setup"
+            )
+
+        self.account_id = self._account["id"]
+        self.ig_user_id = self._account["ig_user_id"]
+        self.access_token = self._account["access_token"]
+
+    async def _get_client(self) -> httpx.AsyncClient:
+        if self._client is None or self._client.is_closed:
+            self._client = httpx.AsyncClient(timeout=REQUEST_TIMEOUT)
+        return self._client
+
+    async def close(self) -> None:
+        if self._client and not self._client.is_closed:
+            await self._client.aclose()
+
+    # ── Core Request ──────────────────────────────────────────────────────────
+
+    async def _request(
+        self,
+        method: str,
+        endpoint: str,
+        params: Optional[Dict] = None,
+        data: Optional[Dict] = None,
+        action_name: str = "api_call",
+    ) -> Dict[str, Any]:
+        """
+        Faz request à Graph API com retry, rate limiting e logging.
+        """
+        # Verificar rate limit
+        self._gov.check_rate_limit(action_name, self.account_id)
+
+        url = f"{GRAPH_API_BASE}/{endpoint}" if not endpoint.startswith("http") else endpoint
+        params = params or {}
+        params["access_token"] = self.access_token
+
+        client = await self._get_client()
+
+        for attempt in range(1, MAX_RETRIES + 1):
+            try:
+                if method.upper() == "POST":
+                    resp = await client.post(url, params=params, data=data)
+                elif method.upper() == "DELETE":
+                    resp = await client.delete(url, params=params)
+                else:
+                    resp = await client.get(url, params=params)
+
+                # Parse response
+                result = resp.json()
+
+                # Verificar erro da API
+                if "error" in result:
+                    error = result["error"]
+                    api_error = InstagramAPIError(
+                        message=error.get("message", "Unknown error"),
+                        code=error.get("code"),
+                        subcode=error.get("error_subcode"),
+                    )
+                    if api_error.is_rate_limit():
+                        logger.warning("Rate limit da API atingido (code %s). Aguardando...", api_error.code)
+                        if attempt < MAX_RETRIES:
+                            await asyncio.sleep(60)  # espera 1 min para rate limits da API
+                            continue
+                    if api_error.is_permission_error():
+                        raise api_error  # não faz retry para erros de permissão
+                    if attempt < MAX_RETRIES:
+                        await asyncio.sleep(RETRY_BACKOFF_BASE ** attempt)
+                        continue
+                    raise api_error
+
+                resp.raise_for_status()
+
+                # Log da ação
+                self._gov.log_action(
+                    action=action_name,
+                    params={"endpoint": endpoint, "method": method},
+                    result={"status": resp.status_code},
+                    account_id=self.account_id,
+                )
+
+                return result
+
+            except httpx.HTTPStatusError as exc:
+                logger.warning(
+                    "HTTP %s em %s (tentativa %d/%d)",
+                    exc.response.status_code, url, attempt, MAX_RETRIES,
+                )
+                if attempt < MAX_RETRIES:
+                    await asyncio.sleep(RETRY_BACKOFF_BASE ** attempt)
+                else:
+                    raise
+
+            except (httpx.RequestError, httpx.TimeoutException) as exc:
+                logger.warning(
+                    "Erro de request em %s: %s (tentativa %d/%d)",
+                    url, exc, attempt, MAX_RETRIES,
+                )
+                if attempt < MAX_RETRIES:
+                    await asyncio.sleep(RETRY_BACKOFF_BASE ** attempt)
+                else:
+                    raise
+
+        raise InstagramAPIError("Falha após todas as tentativas")
+
+    async def get(self, endpoint: str, params: Optional[Dict] = None, action: str = "api_get") -> Dict:
+        return await self._request("GET", endpoint, params=params, action_name=action)
+
+    async def post(self, endpoint: str, data: Optional[Dict] = None, params: Optional[Dict] = None, action: str = "api_post") -> Dict:
+        return await self._request("POST", endpoint, params=params, data=data, action_name=action)
+
+    async def delete(self, endpoint: str, params: Optional[Dict] = None, action: str = "api_delete") -> Dict:
+        return await self._request("DELETE", endpoint, params=params, action_name=action)
+
+    # ── User / Profile ────────────────────────────────────────────────────────
+
+    async def get_user_profile(self) -> Dict[str, Any]:
+        """Busca informações do perfil da conta Instagram."""
+        return await self.get(
+            f"{self.ig_user_id}",
+            params={
+                "fields": "id,username,name,account_type,profile_picture_url,"
+                          "biography,followers_count,follows_count,media_count,website",
+            },
+            action="get_profile",
+        )
+
+    # ── Media ─────────────────────────────────────────────────────────────────
+
+    async def get_user_media(
+        self, limit: int = 25, after: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """Lista mídia do usuário com paginação."""
+        params = {
+            "fields": "id,caption,media_type,media_url,thumbnail_url,permalink,"
+                      "timestamp,like_count,comments_count",
+            "limit": str(limit),
+        }
+        if after:
+            params["after"] = after
+        return await self.get(f"{self.ig_user_id}/media", params=params, action="get_media")
+
+    async def get_media_details(self, media_id: str) -> Dict[str, Any]:
+        """Busca detalhes de uma mídia específica."""
+        return await self.get(
+            media_id,
+            params={
+                "fields": "id,caption,media_type,media_url,thumbnail_url,permalink,"
+                          "timestamp,like_count,comments_count,children{id,media_type,media_url}",
+            },
+            action="get_media_details",
+        )
+
+    # ── Publishing (2-step) ───────────────────────────────────────────────────
+
+    async def create_media_container(
+        self,
+        media_type: str = "IMAGE",
+        image_url: Optional[str] = None,
+        video_url: Optional[str] = None,
+        caption: Optional[str] = None,
+        location_id: Optional[str] = None,
+        user_tags: Optional[List[Dict]] = None,
+        is_carousel_item: bool = False,
+        cover_url: Optional[str] = None,
+        share_to_feed: bool = True,
+        children: Optional[List[str]] = None,
+    ) -> Dict[str, Any]:
+        """Cria container de mídia (step 1 do publish)."""
+        data: Dict[str, Any] = {}
+
+        if media_type == "IMAGE":
+            data["image_url"] = image_url
+        elif media_type == "VIDEO":
+            data["media_type"] = "VIDEO"
+            data["video_url"] = video_url
+        elif media_type == "REELS":
+            data["media_type"] = "REELS"
+            data["video_url"] = video_url
+            if cover_url:
+                data["cover_url"] = cover_url
+            data["share_to_feed"] = str(share_to_feed).lower()
+        elif media_type == "STORIES":
+            if image_url:
+                data["image_url"] = image_url
+            elif video_url:
+                data["video_url"] = video_url
+                data["media_type"] = "VIDEO"
+        elif media_type == "CAROUSEL":
+            data["media_type"] = "CAROUSEL"
+            if children:
+                data["children"] = ",".join(children)
+
+        if caption and not is_carousel_item:
+            data["caption"] = caption
+        if location_id:
+            data["location_id"] = location_id
+        if user_tags:
+            data["user_tags"] = json.dumps(user_tags)
+        if is_carousel_item:
+            data["is_carousel_item"] = "true"
+
+        return await self.post(
+            f"{self.ig_user_id}/media",
+            data=data,
+            action=f"create_container_{media_type.lower()}",
+        )
+
+    async def check_container_status(self, container_id: str) -> Dict[str, Any]:
+        """Verifica status de um container (usado para vídeos que precisam processar)."""
+        return await self.get(
+            container_id,
+            params={"fields": "status_code,status"},
+            action="check_container",
+        )
+
+    async def publish_media(self, container_id: str) -> Dict[str, Any]:
+        """Publica um container (step 2 do publish)."""
+        return await self.post(
+            f"{self.ig_user_id}/media_publish",
+            data={"creation_id": container_id},
+            action="publish_media",
+        )
+
+    # ── Comments ──────────────────────────────────────────────────────────────
+
+    async def get_comments(
+        self, media_id: str, limit: int = 50, after: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        params = {
+            "fields": "id,text,username,timestamp,replies{id,text,username,timestamp}",
+            "limit": str(limit),
+        }
+        if after:
+            params["after"] = after
+        return await self.get(f"{media_id}/comments", params=params, action="get_comments")
+
+    async def reply_to_comment(self, comment_id: str, text: str) -> Dict[str, Any]:
+        return await self.post(
+            f"{comment_id}/replies",
+            data={"message": text},
+            action="reply_comment",
+        )
+
+    async def delete_comment(self, comment_id: str) -> Dict[str, Any]:
+        return await self.delete(comment_id, action="delete_comment")
+
+    async def get_mentions(self, limit: int = 25) -> Dict[str, Any]:
+        return await self.get(
+            f"{self.ig_user_id}/tags",
+            params={"fields": "id,caption,media_type,permalink,timestamp", "limit": str(limit)},
+            action="get_mentions",
+        )
+
+    # ── Insights ──────────────────────────────────────────────────────────────
+
+    async def get_media_insights(
+        self, media_id: str, metrics: Optional[List[str]] = None,
+    ) -> Dict[str, Any]:
+        if not metrics:
+            metrics = ["impressions", "reach", "engagement", "saved", "shares"]
+        return await self.get(
+            f"{media_id}/insights",
+            params={"metric": ",".join(metrics)},
+            action="get_media_insights",
+        )
+
+    async def get_user_insights(
+        self,
+        period: str = "day",
+        metrics: Optional[List[str]] = None,
+        since: Optional[str] = None,
+        until: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        if not metrics:
+            metrics = ["impressions", "reach", "follower_count", "profile_views"]
+        params: Dict[str, str] = {
+            "metric": ",".join(metrics),
+            "period": period,
+        }
+        if since:
+            params["since"] = since
+        if until:
+            params["until"] = until
+        return await self.get(
+            f"{self.ig_user_id}/insights",
+            params=params,
+            action="get_user_insights",
+        )
+
+    # ── Hashtags ──────────────────────────────────────────────────────────────
+
+    async def search_hashtag(self, hashtag: str) -> Dict[str, Any]:
+        """Busca o ID de uma hashtag."""
+        return await self.get(
+            "ig_hashtag_search",
+            params={"q": hashtag, "user_id": self.ig_user_id},
+            action="search_hashtag",
+        )
+
+    async def get_hashtag_recent_media(
+        self, hashtag_id: str, limit: int = 25,
+    ) -> Dict[str, Any]:
+        return await self.get(
+            f"{hashtag_id}/recent_media",
+            params={
+                "user_id": self.ig_user_id,
+                "fields": "id,caption,media_type,permalink,timestamp,like_count,comments_count",
+                "limit": str(limit),
+            },
+            action="get_hashtag_media",
+        )
+
+    async def get_hashtag_top_media(
+        self, hashtag_id: str, limit: int = 25,
+    ) -> Dict[str, Any]:
+        return await self.get(
+            f"{hashtag_id}/top_media",
+            params={
+                "user_id": self.ig_user_id,
+                "fields": "id,caption,media_type,permalink,timestamp,like_count,comments_count",
+                "limit": str(limit),
+            },
+            action="get_hashtag_top",
+        )
+
+    # ── Messaging ─────────────────────────────────────────────────────────────
+
+    async def send_message(self, recipient_id: str, text: str) -> Dict[str, Any]:
+        return await self.post(
+            f"{self.ig_user_id}/messages",
+            data={
+                "recipient": json.dumps({"id": recipient_id}),
+                "message": json.dumps({"text": text}),
+            },
+            action="send_dm",
+        )
+
+    async def get_conversations(self, limit: int = 20) -> Dict[str, Any]:
+        return await self.get(
+            f"{self.ig_user_id}/conversations",
+            params={
+                "fields": "id,participants,updated_time",
+                "limit": str(limit),
+                "platform": "instagram",
+            },
+            action="get_conversations",
+        )
+
+    # ── Imgur Upload (mídia local → URL pública) ──────────────────────────────
+
+    async def upload_to_imgur(self, file_path: str) -> str:
+        """
+        Faz upload de arquivo local para o Imgur (anônimo).
+        Retorna a URL pública da imagem.
+        """
+        client = await self._get_client()
+        with open(file_path, "rb") as f:
+            resp = await client.post(
+                IMGUR_UPLOAD_URL,
+                headers={"Authorization": f"Client-ID {IMGUR_CLIENT_ID}"},
+                files={"image": f},
+            )
+        resp.raise_for_status()
+        data = resp.json()
+        if data.get("success"):
+            url = data["data"]["link"]
+            logger.info("Upload Imgur: %s → %s", file_path, url)
+            return url
+        raise InstagramAPIError(f"Imgur upload falhou: {data}")