mega-brain-ai 1.1.0

package/.claude/scripts/planilha-tagger.py

@@ -0,0 +1,187 @@
+#!/usr/bin/env python3
+"""
+PLANILHA TAGGER - Tagueamento na Fonte
+Mega Brain - Sistema de Inteligência de Negócios
+
+Escreve TAGs diretamente na planilha de controle via MCP gdrive.
+TAGs são escritas NA FONTE, não localmente.
+
+USO: Este script é chamado pelo JARVIS via MCP, não diretamente.
+"""
+
+import os
+import json
+from datetime import datetime
+from pathlib import Path
+
+# Configurações
+MISSION_CONTROL = ".claude/mission-control"
+PLANILHA_INDEX = f"{MISSION_CONTROL}/PLANILHA-INDEX.json"
+SOURCE_SYNC_STATE = f"{MISSION_CONTROL}/SOURCE-SYNC-STATE.json"
+
+# Mapeamento de abas → prefixos de TAG
+SHEET_TO_PREFIX = {
+    "Jeremy Miner": "JM",
+    "Jeremy Haynes Sales Training": "JH-ST",
+    "Jeremy Haynes Inner Circle": "JH-IC",
+    "Inner Circle Weekly Group Call Recordings": "JH-WK",
+    "Agency Blueprint": "AOBA",
+    "Cold Video Pitch": "PCVP",
+    "Land Your First Agency Client": "LYFC",
+    "Marketer Mindset Masterclass": "MMM",
+    "30 Days Challenge": "30DC",
+    "Scale The Agency": "STA",
+    "Ultra High Ticket Closer": "UHTC",
+    "Cole Gordon": "CG",
+    "The Scalable Company": "TSC",
+    "Sales Training BR": "EDC",
+    "Alex Hormozi": "AH",
+    "Jeremy Haynes Program": "CA",
+}
+
+TAG_COLUMN = "I"
+TAG_COLUMN_INDEX = 8
+
+
+def load_planilha_index():
+    """Carrega índice da planilha."""
+    if os.path.exists(PLANILHA_INDEX):
+        with open(PLANILHA_INDEX, 'r', encoding='utf-8') as f:
+            return json.load(f)
+    return {"entries": [], "timestamp": None}
+
+
+def get_existing_tags(index, prefix):
+    """Retorna todas as TAGs existentes para um prefixo."""
+    tags = set()
+    for entry in index.get('entries', []):
+        tag = entry.get('tag', '')
+        if tag.startswith(prefix + "-"):
+            tags.add(tag)
+    return tags
+
+
+def generate_next_tag(prefix, existing_tags):
+    """Gera próxima TAG sequencial para um prefixo."""
+    max_num = 0
+    for tag in existing_tags:
+        if tag.startswith(prefix + "-"):
+            try:
+                num_part = tag.split("-")[-1]
+                num = int(num_part)
+                if num > max_num:
+                    max_num = num
+            except ValueError:
+                continue
+    return f"{prefix}-{str(max_num + 1).zfill(4)}"
+
+
+def identify_untagged_entries(delta_entries, index):
+    """Identifica entradas que precisam de TAG."""
+    untagged = []
+
+    for entry in delta_entries:
+        if entry.get('tag') and entry['tag'].strip():
+            continue
+
+        sheet_name = entry.get('sheet', '')
+        prefix = SHEET_TO_PREFIX.get(sheet_name)
+
+        if not prefix:
+            for sheet, pf in SHEET_TO_PREFIX.items():
+                if sheet.lower() in sheet_name.lower():
+                    prefix = pf
+                    break
+
+        if prefix:
+            untagged.append({
+                'entry': entry,
+                'prefix': prefix,
+                'sheet': sheet_name
+            })
+
+    return untagged
+
+
+def prepare_tag_operations(untagged, index):
+    """Prepara operações de tagueamento para MCP."""
+    operations = []
+    by_prefix = {}
+
+    for item in untagged:
+        prefix = item['prefix']
+        if prefix not in by_prefix:
+            by_prefix[prefix] = []
+        by_prefix[prefix].append(item)
+
+    for prefix, items in by_prefix.items():
+        existing_tags = get_existing_tags(index, prefix)
+
+        for item in items:
+            new_tag = generate_next_tag(prefix, existing_tags)
+            existing_tags.add(new_tag)
+
+            entry = item['entry']
+            operations.append({
+                'type': 'write_tag',
+                'spreadsheet_id': entry.get('spreadsheet_id'),
+                'sheet_name': item['sheet'],
+                'row': entry.get('row'),
+                'column': TAG_COLUMN,
+                'range': f"'{item['sheet']}'!{TAG_COLUMN}{entry.get('row')}",
+                'value': new_tag,
+                'original_name': entry.get('name', ''),
+                'prefix': prefix
+            })
+
+    return operations
+
+
+def generate_tag_report(operations):
+    """Gera relatório de operações de tagueamento."""
+    report = {
+        'timestamp': datetime.now().isoformat(),
+        'total_operations': len(operations),
+        'by_prefix': {},
+        'operations': operations
+    }
+
+    for op in operations:
+        prefix = op['prefix']
+        if prefix not in report['by_prefix']:
+            report['by_prefix'][prefix] = 0
+        report['by_prefix'][prefix] += 1
+
+    return report
+
+
+def main(delta_entries=None, preview=True):
+    """Função principal do tagger."""
+    index = load_planilha_index()
+
+    if delta_entries is None:
+        print("PLANILHA TAGGER - Modo Standalone")
+        print("Passe delta_entries para executar.")
+        return None
+
+    untagged = identify_untagged_entries(delta_entries, index)
+
+    if not untagged:
+        print("✅ Todas as entradas já possuem TAG!")
+        return []
+
+    operations = prepare_tag_operations(untagged, index)
+    report = generate_tag_report(operations)
+
+    print(f"TAGs a escrever: {report['total_operations']}")
+    for prefix, count in sorted(report['by_prefix'].items()):
+        print(f"  {prefix}: {count}")
+
+    if preview:
+        return None
+
+    return operations
+
+
+if __name__ == '__main__':
+    main()

package/.claude/scripts/revert-tags.py

@@ -0,0 +1,70 @@
+#!/usr/bin/env python3
+"""
+REVERT - Remove TAGs incorretas dos arquivos
+"""
+
+import os
+import re
+from pathlib import Path
+
+INBOX_PATH = "inbox"
+
+def revert_tags():
+    print("=" * 60)
+    print("REVERTENDO TAGS INCORRETAS")
+    print("=" * 60)
+
+    # Encontrar arquivos com TAG
+    tagged_files = []
+    pattern = re.compile(r'^\[[\w-]+\]\s*')
+
+    for root, dirs, files in os.walk(INBOX_PATH):
+        if '_BACKUP' in root or '_TEMPLATE' in root:
+            continue
+        for filename in files:
+            if pattern.match(filename):
+                tagged_files.append(Path(root) / filename)
+
+    print(f"\nEncontrados: {len(tagged_files)} arquivos com TAG")
+
+    # Reverter
+    success = 0
+    errors = []
+
+    for filepath in tagged_files:
+        old_name = filepath.name
+        # Remove [TAG] do início
+        new_name = pattern.sub('', old_name)
+        new_path = filepath.parent / new_name
+
+        # Verificar se destino já existe
+        if new_path.exists():
+            errors.append({'path': str(filepath), 'error': f'Destino já existe: {new_name}'})
+            continue
+
+        try:
+            filepath.rename(new_path)
+            success += 1
+            if success % 50 == 0:
+                print(f"  Revertidos: {success}/{len(tagged_files)}")
+        except Exception as e:
+            errors.append({'path': str(filepath), 'error': str(e)})
+
+    print()
+    print("=" * 60)
+    print("RESULTADO")
+    print("=" * 60)
+    print(f"  Sucesso: {success}")
+    print(f"  Erros: {len(errors)}")
+
+    if errors:
+        print("\nERROS:")
+        for e in errors[:20]:
+            print(f"  - {e['path']}: {e['error']}")
+        if len(errors) > 20:
+            print(f"  ... e mais {len(errors) - 20} erros")
+
+    return success, errors
+
+if __name__ == '__main__':
+    revert_tags()

package/.claude/scripts/source-sync.py

@@ -0,0 +1,265 @@
+#!/usr/bin/env python3
+"""
+SOURCE SYNC - Detecção de Delta e Sincronização com Planilha
+=============================================================
+
+Este script:
+1. Carrega o snapshot local (PLANILHA-INDEX.json)
+2. Compara com o estado atual da planilha (via MCP)
+3. Detecta arquivos NOVOS (delta)
+4. Gera relatório visual
+5. Opcionalmente executa tagueamento + download
+
+Uso:
+    python source-sync.py --check          # Apenas verificar
+    python source-sync.py --execute        # Verificar + baixar
+    python source-sync.py --source=JM      # Filtrar por fonte
+
+Autor: JARVIS
+Versão: 1.0.0
+Data: 2026-01-13
+"""
+
+import json
+import os
+import sys
+from datetime import datetime
+from pathlib import Path
+from typing import Dict, List, Optional, Tuple
+
+# =============================================================================
+# CONFIGURAÇÃO
+# =============================================================================
+
+MEGA_BRAIN_ROOT = Path(".")
+MISSION_CONTROL = MEGA_BRAIN_ROOT / ".claude" / "mission-control"
+INBOX_ROOT = MEGA_BRAIN_ROOT / "inbox"
+
+# Arquivos de estado
+PLANILHA_INDEX_FILE = MISSION_CONTROL / "PLANILHA-INDEX.json"
+SYNC_STATE_FILE = MISSION_CONTROL / "SOURCE-SYNC-STATE.json"
+DELTA_PENDING_FILE = MISSION_CONTROL / "DELTA-PENDING.json"
+
+# ID da planilha principal
+PLANILHA_ID = "1lVj2t1Ej97q1MTmFXR9NZUvGWxgv-RYXQ0SjZEGl7N4"
+
+# =============================================================================
+# MAPEAMENTO ABA → PREFIXO
+# =============================================================================
+
+SHEET_TO_PREFIX: Dict[str, str] = {
+    "Jeremy Miner": "JM",
+    "Jeremy Haynes Sales Training": "JH-ST",
+    "Jeremy Haynes Inner Circle": "JH-IC",
+    "Inner Circle Weekly Group Call Recordings": "JH-WK",
+    "Agency Blueprint": "AOBA",
+    "Cold Video Pitch": "PCVP",
+    "Land Your First Agency Client": "LYFC",
+    "Marketer Mindset Masterclass": "MMM",
+    "30 Days Challenge": "30DC",
+    "Scale The Agency": "STA",
+    "Ultra High Ticket Closer": "UHTC",
+    "The Scalable Company": "TSC",
+    "Cole Gordon": "CG",
+    "Sales Training BR": "EDC",
+    "Alex Hormozi": "AH",
+    "Jeremy Haynes Program": "CA",
+}
+
+# Mapeamento reverso para agrupamento
+PREFIX_TO_SOURCE: Dict[str, str] = {
+    "JM": "JEREMY MINER",
+    "JH-ST": "JEREMY HAYNES (SALES TRAINING)",
+    "JH-IC": "JEREMY HAYNES (INNER CIRCLE)",
+    "JH-WK": "JEREMY HAYNES (WEEKLY CALLS)",
+    "AOBA": "AGENCY OWNERS BLUEPRINT",
+    "PCVP": "PERFECT COLD VIDEO PITCH",
+    "LYFC": "LAND YOUR FIRST CLIENT",
+    "MMM": "MARKETER MINDSET",
+    "30DC": "30 DAYS CHALLENGE",
+    "STA": "SCALE THE AGENCY",
+    "UHTC": "ULTRA HIGH TICKET CLOSER",
+    "TSC": "THE SCALABLE COMPANY",
+    "CG": "COLE GORDON",
+    "EDC": "SALES TRAINING BR",
+    "AH": "ALEX HORMOZI",
+    "CA": "JEREMY HAYNES PROGRAM",
+}
+
+# =============================================================================
+# FUNÇÕES AUXILIARES
+# =============================================================================
+
+def load_json(path: Path) -> dict:
+    """Carrega arquivo JSON com tratamento de erro."""
+    if not path.exists():
+        return {}
+    try:
+        with open(path, 'r', encoding='utf-8') as f:
+            return json.load(f)
+    except json.JSONDecodeError:
+        print(f"⚠️ Erro ao ler {path}")
+        return {}
+
+def save_json(data: dict, path: Path) -> None:
+    """Salva dados em arquivo JSON."""
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with open(path, 'w', encoding='utf-8') as f:
+        json.dump(data, f, ensure_ascii=False, indent=2)
+
+def generate_next_tag(prefix: str, existing_tags: List[str]) -> str:
+    """Gera próxima TAG sequencial para um prefixo."""
+    # Extrair números existentes para este prefixo
+    existing_nums = []
+    for tag in existing_tags:
+        if tag.startswith(prefix + "-"):
+            try:
+                num = int(tag.split("-")[-1])
+                existing_nums.append(num)
+            except ValueError:
+                continue
+
+    # Próximo número
+    next_num = max(existing_nums, default=0) + 1
+    return f"{prefix}-{next_num:04d}"
+
+# =============================================================================
+# FUNÇÕES PRINCIPAIS
+# =============================================================================
+
+def load_snapshot() -> dict:
+    """Carrega snapshot local da planilha."""
+    snapshot = load_json(PLANILHA_INDEX_FILE)
+    if not snapshot:
+        snapshot = {
+            "entries": [],
+            "timestamp": None,
+            "total_count": 0
+        }
+    return snapshot
+
+def get_snapshot_tags(snapshot: dict) -> set:
+    """Extrai conjunto de TAGs do snapshot."""
+    return {entry.get("tag") for entry in snapshot.get("entries", []) if entry.get("tag")}
+
+def detect_delta(current_entries: List[dict], snapshot_tags: set) -> Tuple[List[dict], List[dict]]:
+    """
+    Detecta delta entre estado atual e snapshot.
+
+    Retorna:
+        - novos_com_tag: Arquivos novos que JÁ têm TAG na planilha
+        - novos_sem_tag: Arquivos novos que PRECISAM de TAG
+    """
+    novos_com_tag = []
+    novos_sem_tag = []
+
+    for entry in current_entries:
+        tag = entry.get("tag")
+
+        # Se não está no snapshot, é novo
+        if tag and tag not in snapshot_tags:
+            novos_com_tag.append(entry)
+        elif not tag:
+            novos_sem_tag.append(entry)
+
+    return novos_com_tag, novos_sem_tag
+
+def group_by_source(entries: List[dict]) -> Dict[str, List[dict]]:
+    """Agrupa entries por fonte/aba."""
+    grouped = {}
+    for entry in entries:
+        sheet = entry.get("sheet", "UNKNOWN")
+        if sheet not in grouped:
+            grouped[sheet] = []
+        grouped[sheet].append(entry)
+    return grouped
+
+def print_report(novos_com_tag: List[dict], novos_sem_tag: List[dict]) -> None:
+    """Exibe relatório visual do delta detectado."""
+    total_novos = len(novos_com_tag) + len(novos_sem_tag)
+
+    print()
+    print("╔" + "═" * 78 + "╗")
+    print("║" + "SOURCE SYNC - RELATÓRIO DE DELTA".center(78) + "║")
+    print("╠" + "═" * 78 + "╣")
+    print(f"║  NOVOS ARQUIVOS DETECTADOS: {total_novos:<48}║")
+    print("║" + " " * 78 + "║")
+
+    # Agrupar por fonte
+    all_novos = novos_com_tag + novos_sem_tag
+    grouped = group_by_source(all_novos)
+
+    print("║  POR FONTE:" + " " * 66 + "║")
+    for sheet, entries in sorted(grouped.items()):
+        prefix = SHEET_TO_PREFIX.get(sheet, "??")
+        line = f"  ├── {sheet[:30]:<30} ({prefix}): {len(entries):>3} novos"
+        print(f"║{line:<78}║")
+
+    print("║" + " " * 78 + "║")
+    print("║  AÇÕES NECESSÁRIAS:" + " " * 58 + "║")
+    print(f"║  ├── TAGs a gerar:       {len(novos_sem_tag):<3} (arquivos sem TAG)" + " " * 27 + "║")
+    print(f"║  ├── Downloads:          {total_novos:<3} arquivos" + " " * 34 + "║")
+    print("║  └── Destino: inbox/[FONTE]/[TIPO]/" + " " * 38 + "║")
+    print("╚" + "═" * 78 + "╝")
+    print()
+
+def update_sync_state(novos_count: int, status: str = "CHECKED") -> None:
+    """Atualiza estado da sincronização."""
+    state = {
+        "last_sync": datetime.now().isoformat(),
+        "last_status": status,
+        "last_delta_count": novos_count,
+        "planilha_id": PLANILHA_ID
+    }
+    save_json(state, SYNC_STATE_FILE)
+
+def save_delta_pending(novos_com_tag: List[dict], novos_sem_tag: List[dict]) -> None:
+    """Salva delta pendente para processamento posterior."""
+    delta = {
+        "timestamp": datetime.now().isoformat(),
+        "com_tag": novos_com_tag,
+        "sem_tag": novos_sem_tag,
+        "total": len(novos_com_tag) + len(novos_sem_tag)
+    }
+    save_json(delta, DELTA_PENDING_FILE)
+
+# =============================================================================
+# MAIN
+# =============================================================================
+
+def main():
+    """Função principal - executa detecção de delta."""
+    print("\n" + "=" * 80)
+    print("SOURCE SYNC - Detecção de Delta")
+    print("=" * 80)
+
+    # 1. Carregar snapshot
+    print("\n📁 Carregando snapshot local...")
+    snapshot = load_snapshot()
+    snapshot_tags = get_snapshot_tags(snapshot)
+    print(f"   → {len(snapshot_tags)} TAGs no snapshot")
+
+    # 2. NOTA: A leitura real da planilha deve ser feita via MCP no Claude
+    print("\n⚠️  Este script prepara a estrutura de dados.")
+    print("   A leitura real da planilha deve ser feita via MCP gdrive.")
+    print("   Use o comando /source-sync no Claude para execução completa.")
+
+    # 3. Exibir estado atual
+    print("\n📊 Estado atual:")
+    print(f"   → Snapshot: {PLANILHA_INDEX_FILE}")
+    print(f"   → State: {SYNC_STATE_FILE}")
+    print(f"   → Delta: {DELTA_PENDING_FILE}")
+
+    # 4. Verificar se há delta pendente
+    if DELTA_PENDING_FILE.exists():
+        delta = load_json(DELTA_PENDING_FILE)
+        if delta.get("total", 0) > 0:
+            print(f"\n⚠️  DELTA PENDENTE: {delta['total']} arquivos aguardando")
+            print(f"   → Timestamp: {delta.get('timestamp', 'N/A')}")
+
+    print("\n" + "=" * 80)
+    print("Use /source-sync no Claude para sincronização completa via MCP")
+    print("=" * 80 + "\n")
+
+if __name__ == "__main__":
+    main()