mega-brain-ai 1.3.0

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 = "[YOUR_SHEET_ID_HERE]"
+
+#=================================
+# 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()

package/.claude/scripts/tag-inbox-files.py

@@ -0,0 +1,276 @@
+#!/usr/bin/env python3
+"""
+FASE 2.5 - Script de Tagueamento de Arquivos INBOX
+Mega Brain - Sistema de Inteligencia de Negocios
+
+Este script:
+1. Le a planilha de controle e extrai mapeamento nome -> TAG
+2. Varre todos os arquivos do INBOX recursivamente
+3. Faz matching entre arquivos e TAGs
+4. Renomeia arquivos com prefixo [TAG]
+5. Gera relatorio de arquivos processados vs orfaos
+"""
+
+import os
+import re
+import json
+from pathlib import Path
+from datetime import datetime
+
+# Configuracoes
+INBOX_PATH = "inbox"
+SCHEMA_PATH = ".claude/mission-control/SPREADSHEET-SCHEMA.json"
+OUTPUT_PATH = ".claude/mission-control/TAG-MAPPING-REPORT.json"
+
+# Mapeamento de pasta INBOX -> prefixo TAG
+FOLDER_TO_PREFIX = {
+    "JEREMY MINER": "JM",
+    "JEREMY HAYNES": ["JH-ST", "JH-IC", "JH-WK", "AOBA", "PCVP", "LYFC", "MMM", "30DC", "STA", "UHTC"],
+    "THE SCALABLE COMPANY": "TSC",
+    "ALEX HORMOZI": "AH",
+    "JEREMY HAYNES PROGRAM": "CA",
+    "SAM OVEN (SETTERLUN UNIVERSITY)": None,  # Nao tem na planilha ainda
+    "SETTERLUN (SETTERLUN UNIVERSITY)": None,
+}
+
+def extract_number_from_filename(filename):
+    """Extrai o numero do inicio do nome do arquivo."""
+    # Padroes comuns:
+    # "6 - 42 Minutes of Sales Training.txt"
+    # "112. How To Get Prospects.txt"
+    # "44 - LIVE CALL A Masterclass.txt"
+
+    patterns = [
+        r'^(\d+)\s*[-\.]\s*',  # "123 - " ou "123. "
+        r'^(\d+)\.\s*',        # "123. "
+        r'^(\d+)\s+',          # "123 "
+    ]
+
+    for pattern in patterns:
+        match = re.match(pattern, filename)
+        if match:
+            return int(match.group(1))
+    return None
+
+def clean_filename_for_matching(filename):
+    """Limpa o nome do arquivo para facilitar matching."""
+    # Remove extensao
+    name = os.path.splitext(filename)[0]
+    # Remove timestamps no final
+    name = re.sub(r'_\d{14}$', '', name)
+    # Remove numero inicial
+    name = re.sub(r'^\d+\s*[-\.]\s*', '', name)
+    # Lowercase e remove caracteres especiais
+    name = name.lower()
+    name = re.sub(r'[^\w\s]', ' ', name)
+    name = re.sub(r'\s+', ' ', name).strip()
+    return name
+
+def determine_prefix_from_path(filepath):
+    """Determina o prefixo TAG baseado no caminho do arquivo."""
+    path_str = str(filepath).upper()
+
+    for folder, prefix in FOLDER_TO_PREFIX.items():
+        if folder in path_str:
+            return prefix
+    return None
+
+def scan_inbox_files():
+    """Varre todos os arquivos do INBOX recursivamente."""
+    files = []
+    extensions = {'.txt', '.docx', '.pdf'}
+
+    for root, dirs, filenames in os.walk(INBOX_PATH):
+        # Ignorar pastas de backup/template
+        if '_BACKUP' in root or '_TEMPLATE' in root:
+            continue
+
+        for filename in filenames:
+            ext = os.path.splitext(filename)[1].lower()
+            if ext in extensions:
+                filepath = Path(root) / filename
+
+                # Verificar se ja tem TAG no nome
+                has_tag = bool(re.match(r'^\[[\w-]+\]', filename))
+
+                files.append({
+                    'path': str(filepath),
+                    'filename': filename,
+                    'folder': os.path.basename(root),
+                    'parent_folder': os.path.basename(os.path.dirname(root)),
+                    'number': extract_number_from_filename(filename),
+                    'clean_name': clean_filename_for_matching(filename),
+                    'has_tag': has_tag,
+                    'suggested_prefix': determine_prefix_from_path(filepath)
+                })
+
+    return files
+
+def generate_tag_from_number(prefix, number):
+    """Gera TAG no formato [PREFIX]-[NNNN]."""
+    if isinstance(prefix, list):
+        prefix = prefix[0]  # Usar primeiro prefixo como padrao
+    return f"{prefix}-{number:04d}"
+
+def rename_file_with_tag(filepath, tag):
+    """Renomeia arquivo adicionando prefixo [TAG]."""
+    path = Path(filepath)
+    new_name = f"[{tag}] {path.name}"
+    new_path = path.parent / new_name
+
+    # Verificar se destino ja existe
+    if new_path.exists():
+        return None, "Destino ja existe"
+
+    try:
+        path.rename(new_path)
+        return str(new_path), None
+    except Exception as e:
+        return None, str(e)
+
+def execute_rename(report, dry_run=False):
+    """Executa a renomeacao dos arquivos."""
+    print()
+    print("=" * 60)
+    print("EXECUTANDO RENOMEACAO" + (" (DRY RUN)" if dry_run else ""))
+    print("=" * 60)
+    print()
+
+    success = 0
+    errors = []
+
+    for item in report['to_tag']:
+        filepath = item['current_path']
+        tag = item['suggested_tag']
+
+        if dry_run:
+            path = Path(filepath)
+            new_name = f"[{tag}] {path.name}"
+            print(f"  [DRY] {path.name}")
+            print(f"     -> {new_name}")
+            success += 1
+        else:
+            new_path, error = rename_file_with_tag(filepath, tag)
+            if error:
+                errors.append({'path': filepath, 'error': error})
+                print(f"  [ERRO] {item['filename']}: {error}")
+            else:
+                success += 1
+                if success % 50 == 0:
+                    print(f"  Renomeados: {success}/{len(report['to_tag'])}")
+
+    print()
+    print("=" * 60)
+    print("RESULTADO")
+    print("=" * 60)
+    print(f"  Sucesso: {success}")
+    print(f"  Erros: {len(errors)}")
+
+    if errors:
+        print()
+        print("ERROS:")
+        for e in errors[:10]:  # Mostrar apenas primeiros 10
+            print(f"  - {e['path']}: {e['error']}")
+        if len(errors) > 10:
+            print(f"  ... e mais {len(errors) - 10} erros")
+
+    return success, errors
+
+
+def main(execute=False, dry_run=False):
+    print("=" * 60)
+    print("FASE 2.5 - TAGUEAMENTO DE ARQUIVOS INBOX")
+    print("=" * 60)
+    print()
+
+    # 1. Carregar schema
+    print("[1/4] Carregando schema...")
+    with open(SCHEMA_PATH, 'r', encoding='utf-8') as f:
+        schema = json.load(f)
+
+    # 2. Escanear arquivos
+    print("[2/4] Escaneando INBOX...")
+    files = scan_inbox_files()
+    print(f"       Encontrados: {len(files)} arquivos")
+
+    # 3. Classificar arquivos
+    print("[3/4] Classificando arquivos...")
+
+    already_tagged = [f for f in files if f['has_tag']]
+    to_tag = [f for f in files if not f['has_tag'] and f['suggested_prefix'] and f['number']]
+    orphans = [f for f in files if not f['has_tag'] and (not f['suggested_prefix'] or not f['number'])]
+
+    print(f"       Ja tagueados: {len(already_tagged)}")
+    print(f"       Para taguear: {len(to_tag)}")
+    print(f"       Orfaos: {len(orphans)}")
+
+    # 4. Gerar relatorio
+    print("[4/4] Gerando relatorio...")
+
+    report = {
+        'timestamp': datetime.now().isoformat(),
+        'summary': {
+            'total_files': len(files),
+            'already_tagged': len(already_tagged),
+            'to_tag': len(to_tag),
+            'orphans': len(orphans)
+        },
+        'to_tag': [],
+        'orphans': []
+    }
+
+    for f in to_tag:
+        prefix = f['suggested_prefix']
+        if isinstance(prefix, list):
+            prefix = prefix[0]
+        tag = generate_tag_from_number(prefix, f['number'])
+        report['to_tag'].append({
+            'current_path': f['path'],
+            'suggested_tag': tag,
+            'filename': f['filename'],
+            'folder': f['folder']
+        })
+
+    for f in orphans:
+        report['orphans'].append({
+            'path': f['path'],
+            'filename': f['filename'],
+            'folder': f['folder'],
+            'reason': 'Sem prefixo conhecido' if not f['suggested_prefix'] else 'Sem numero no nome'
+        })
+
+    # Salvar relatorio
+    with open(OUTPUT_PATH, 'w', encoding='utf-8') as f:
+        json.dump(report, f, ensure_ascii=False, indent=2)
+
+    print()
+    print("=" * 60)
+    print("RELATORIO GERADO")
+    print("=" * 60)
+    print(f"Arquivo: {OUTPUT_PATH}")
+
+    # 5. Executar renomeacao se solicitado
+    if execute:
+        success, errors = execute_rename(report, dry_run)
+        report['execution'] = {
+            'success': success,
+            'errors': len(errors),
+            'error_details': errors
+        }
+        # Atualizar relatorio com resultado
+        with open(OUTPUT_PATH, 'w', encoding='utf-8') as f:
+            json.dump(report, f, ensure_ascii=False, indent=2)
+    else:
+        print()
+        print("PROXIMO PASSO: Executar com --execute para renomear")
+        print("              Ou --dry-run para simular")
+
+    print()
+    return report
+
+
+if __name__ == '__main__':
+    import sys
+    execute = '--execute' in sys.argv
+    dry_run = '--dry-run' in sys.argv
+    main(execute=execute, dry_run=dry_run)