mega-brain-ai 1.3.0

package/.claude/scripts/extract_docx_from_gdrive.py

@@ -0,0 +1,77 @@
+#!/usr/bin/env python3
+"""
+Script para extrair texto de arquivos .docx baixados do Google Drive (base64)
+"""
+
+import base64
+import zipfile
+import io
+import re
+import sys
+import os
+
+def decode_base64_docx(base64_content):
+    """Decodifica conteúdo base64 para bytes"""
+    # Remove possíveis prefixos de data URI
+    if ',' in base64_content:
+        base64_content = base64_content.split(',')[1]
+
+    # Remove whitespace
+    base64_content = base64_content.strip().replace('\n', '').replace('\r', '')
+
+    return base64.b64decode(base64_content)
+
+def extract_text_from_docx_bytes(docx_bytes):
+    """Extrai texto de um arquivo .docx (que é um ZIP)"""
+    try:
+        # Abre como ZIP
+        with zipfile.ZipFile(io.BytesIO(docx_bytes)) as zf:
+            # Lê word/document.xml
+            with zf.open('word/document.xml') as doc:
+                xml_content = doc.read().decode('utf-8')
+
+        # Remove tags XML, mantendo apenas texto
+        # Padrão para encontrar texto entre tags <w:t>
+        text_parts = re.findall(r'<w:t[^>]*>([^<]*)</w:t>', xml_content)
+
+        # Junta tudo
+        raw_text = ''.join(text_parts)
+
+        # Limpa e formata
+        # Substitui múltiplos espaços por um
+        text = re.sub(r' +', ' ', raw_text)
+
+        # Tenta preservar parágrafos baseado em padrões comuns
+        # Adiciona quebras antes de números que parecem timestamps ou marcadores
+        text = re.sub(r'(\d{1,2}:\d{2})', r'\n\1', text)
+
+        return text.strip()
+
+    except Exception as e:
+        return f"ERRO ao extrair texto: {str(e)}"
+
+def process_file(base64_content, output_path):
+    """Processa um arquivo: decode + extract + save"""
+    try:
+        # Decodifica base64
+        docx_bytes = decode_base64_docx(base64_content)
+
+        # Extrai texto
+        text = extract_text_from_docx_bytes(docx_bytes)
+
+        # Cria diretório se necessário
+        os.makedirs(os.path.dirname(output_path), exist_ok=True)
+
+        # Salva como .txt
+        with open(output_path, 'w', encoding='utf-8') as f:
+            f.write(text)
+
+        return True, len(text)
+
+    except Exception as e:
+        return False, str(e)
+
+if __name__ == "__main__":
+    # Teste básico
+    if len(sys.argv) > 1:
+        print(f"Script pronto. Use as funções: decode_base64_docx, extract_text_from_docx_bytes, process_file")

package/.claude/scripts/jarvis_orchestrator.py

@@ -0,0 +1,5 @@
+# Stub — full implementation pending
+
+
+class JarvisOrchestrator:
+    pass

package/.claude/scripts/organized-downloader.py

@@ -0,0 +1,246 @@
+#!/usr/bin/env python3
+"""
+ORGANIZED DOWNLOADER - Download com TAG
+Mega Brain - Sistema de Inteligência de Negócios
+
+Baixa arquivos do Google Drive JÁ com [TAG] no nome.
+Organiza automaticamente em inbox/[SOURCE]/
+
+USO: Este script é chamado pelo JARVIS via MCP, não diretamente.
+"""
+
+import os
+import json
+import re
+from datetime import datetime
+from pathlib import Path
+
+# Configurações
+MEGA_BRAIN = "."
+INBOX = f"{MEGA_BRAIN}/inbox"
+MISSION_CONTROL = f"{MEGA_BRAIN}/.claude/mission-control"
+PLANILHA_INDEX = f"{MISSION_CONTROL}/PLANILHA-INDEX.json"
+DOWNLOAD_LOG = f"{MISSION_CONTROL}/DOWNLOAD-LOG.json"
+
+# Mapeamento de prefixo → pasta no INBOX
+PREFIX_TO_FOLDER = {
+    "JM": "JEREMY MINER",
+    "JH-ST": "JEREMY HAYNES/SALES TRAINING",
+    "JH-IC": "JEREMY HAYNES/INNER CIRCLE",
+    "JH-WK": "JEREMY HAYNES/WEEKLY CALLS",
+    "AOBA": "JEREMY HAYNES/AOBA",
+    "PCVP": "JEREMY HAYNES/PCVP",
+    "LYFC": "JEREMY HAYNES/LYFC",
+    "MMM": "JEREMY HAYNES/MMM",
+    "30DC": "JEREMY HAYNES/30DC",
+    "STA": "JEREMY HAYNES/STA",
+    "UHTC": "JEREMY HAYNES/UHTC",
+    "CG": "COLE GORDON",
+    "TSC": "COLE GORDON/TSC",
+    "EDC": "COLE GORDON/EAD",
+    "AH": "ALEX HORMOZI",
+    "CA": "JEREMY HAYNES PROGRAM"
+}
+
+
+def sanitize_filename(name):
+    """Remove caracteres inválidos do nome do arquivo."""
+    invalid_chars = '<>:"/\\|?*'
+    for char in invalid_chars:
+        name = name.replace(char, '_')
+    return name.strip()
+
+
+def get_folder_for_tag(tag):
+    """Retorna pasta de destino baseada no prefixo da TAG."""
+    for prefix, folder in PREFIX_TO_FOLDER.items():
+        if tag.startswith(prefix + "-"):
+            return folder
+    return "OUTROS"
+
+
+def format_tagged_filename(tag, original_name):
+    """Formata nome do arquivo com TAG."""
+    clean_name = sanitize_filename(original_name)
+    return f"[{tag}] {clean_name}"
+
+
+def prepare_download_operations(tagged_entries):
+    """
+    Prepara operações de download para MCP.
+
+    Args:
+        tagged_entries: Lista de entradas já tagueadas na planilha
+        Formato: [{'tag': 'JM-0001', 'name': '...', 'file_id': '...', ...}]
+
+    Returns:
+        Lista de operações de download
+    """
+    operations = []
+
+    for entry in tagged_entries:
+        tag = entry.get('tag', '')
+        original_name = entry.get('name', entry.get('original_name', 'arquivo'))
+        file_id = entry.get('file_id', entry.get('drive_id', ''))
+
+        if not tag or not file_id:
+            continue
+
+        folder = get_folder_for_tag(tag)
+        dest_folder = os.path.join(INBOX, folder)
+        tagged_name = format_tagged_filename(tag, original_name)
+        dest_path = os.path.join(dest_folder, tagged_name)
+
+        operations.append({
+            'type': 'download',
+            'file_id': file_id,
+            'original_name': original_name,
+            'tagged_name': tagged_name,
+            'tag': tag,
+            'dest_folder': dest_folder,
+            'dest_path': dest_path,
+            'source': folder.split('/')[0] if '/' in folder else folder
+        })
+
+    return operations
+
+
+def ensure_folders_exist(operations):
+    """Cria pastas de destino se não existirem."""
+    folders = set(op['dest_folder'] for op in operations)
+    created = []
+
+    for folder in folders:
+        if not os.path.exists(folder):
+            os.makedirs(folder, exist_ok=True)
+            created.append(folder)
+
+    return created
+
+
+def generate_download_report(operations):
+    """Gera relatório de downloads."""
+    report = {
+        'timestamp': datetime.now().isoformat(),
+        'total_downloads': len(operations),
+        'by_source': {},
+        'operations': operations
+    }
+
+    for op in operations:
+        source = op['source']
+        if source not in report['by_source']:
+            report['by_source'][source] = 0
+        report['by_source'][source] += 1
+
+    return report
+
+
+def log_downloads(operations, success_ids):
+    """Registra downloads realizados."""
+    log_path = DOWNLOAD_LOG
+
+    if os.path.exists(log_path):
+        with open(log_path, 'r', encoding='utf-8') as f:
+            log = json.load(f)
+    else:
+        log = {'downloads': [], 'stats': {'total': 0, 'by_date': {}}}
+
+    today = datetime.now().strftime('%Y-%m-%d')
+
+    for op in operations:
+        if op['file_id'] in success_ids:
+            log['downloads'].append({
+                'timestamp': datetime.now().isoformat(),
+                'tag': op['tag'],
+                'file_id': op['file_id'],
+                'dest_path': op['dest_path']
+            })
+            log['stats']['total'] += 1
+
+            if today not in log['stats']['by_date']:
+                log['stats']['by_date'][today] = 0
+            log['stats']['by_date'][today] += 1
+
+    with open(log_path, 'w', encoding='utf-8') as f:
+        json.dump(log, f, indent=2, ensure_ascii=False)
+
+    return log
+
+
+def update_planilha_index(operations, success_ids):
+    """Atualiza índice da planilha com status de download."""
+    if not os.path.exists(PLANILHA_INDEX):
+        return
+
+    with open(PLANILHA_INDEX, 'r', encoding='utf-8') as f:
+        index = json.load(f)
+
+    downloaded_tags = {op['tag'] for op in operations if op['file_id'] in success_ids}
+
+    for entry in index.get('entries', []):
+        if entry.get('tag') in downloaded_tags:
+            entry['downloaded'] = True
+            entry['download_date'] = datetime.now().isoformat()
+
+    with open(PLANILHA_INDEX, 'w', encoding='utf-8') as f:
+        json.dump(index, f, indent=2, ensure_ascii=False)
+
+
+def main(tagged_entries=None, preview=True):
+    """
+    Função principal do downloader.
+
+    Args:
+        tagged_entries: Lista de entradas já tagueadas
+        preview: Se True, apenas mostra relatório
+
+    Returns:
+        Se preview=True: relatório
+        Se preview=False: lista de operações para MCP
+    """
+    print("=" * 60)
+    print("ORGANIZED DOWNLOADER - Download com TAG")
+    print("=" * 60)
+    print()
+
+    if tagged_entries is None:
+        print("[MODO STANDALONE]")
+        print("Passe tagged_entries para executar.")
+        return None
+
+    operations = prepare_download_operations(tagged_entries)
+
+    if not operations:
+        print("✅ Nenhum download pendente!")
+        return []
+
+    report = generate_download_report(operations)
+
+    print(f"Downloads preparados: {report['total_downloads']}")
+    print()
+    print("Por fonte:")
+    for source, count in sorted(report['by_source'].items()):
+        print(f"  {source}: {count}")
+    print()
+
+    if preview:
+        print("Arquivos:")
+        for i, op in enumerate(operations[:5], 1):
+            print(f"  {i}. [{op['tag']}] → {op['source']}")
+        if len(operations) > 5:
+            print(f"  ... e mais {len(operations) - 5}")
+        print()
+        print("MODO PREVIEW - Nenhum download realizado.")
+        return report
+
+    # Criar pastas
+    created_folders = ensure_folders_exist(operations)
+    if created_folders:
+        print(f"Pastas criadas: {len(created_folders)}")
+
+    return operations
+
+
+if __name__ == '__main__':
+    main()

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()