mega-brain-ai 1.1.0

package/.claude/scripts/docx-xml-extractor.py

@@ -0,0 +1,141 @@
+#!/usr/bin/env python3
+"""
+DOCX XML Text Extractor for Mega Brain
+---------------------------------------
+Extrai texto de arquivos .docx usando parsing XML direto.
+Não requer pandoc ou outras dependências externas.
+"""
+
+import base64
+import tempfile
+import os
+import sys
+import re
+import zipfile
+from xml.etree import ElementTree as ET
+
+# OOXML namespace
+WORD_NAMESPACE = '{http://schemas.openxmlformats.org/wordprocessingml/2006/main}'
+
+def extract_text_from_xml(xml_content: str) -> str:
+    """
+    Extract text from Word document.xml content
+    """
+    try:
+        root = ET.fromstring(xml_content)
+    except ET.ParseError:
+        # Fallback to regex if XML parsing fails
+        texts = re.findall(r'<w:t[^>]*>([^<]*)</w:t>', xml_content)
+        return ' '.join(texts)
+
+    texts = []
+
+    # Find all <w:t> elements (text runs)
+    for elem in root.iter():
+        if elem.tag == f'{WORD_NAMESPACE}t':
+            if elem.text:
+                texts.append(elem.text)
+        # Handle paragraph breaks
+        elif elem.tag == f'{WORD_NAMESPACE}p':
+            if texts and not texts[-1].endswith('\n'):
+                texts.append('\n')
+        # Handle line breaks
+        elif elem.tag == f'{WORD_NAMESPACE}br':
+            texts.append('\n')
+
+    # Join and clean up
+    text = ''.join(texts)
+    # Normalize whitespace but preserve paragraph breaks
+    text = re.sub(r'[ \t]+', ' ', text)
+    text = re.sub(r'\n\s*\n', '\n\n', text)
+    text = text.strip()
+
+    return text
+
+def extract_from_docx_bytes(docx_bytes: bytes) -> str:
+    """
+    Extract text from docx file bytes
+    """
+    with tempfile.NamedTemporaryFile(suffix='.docx', delete=False) as tmp:
+        tmp.write(docx_bytes)
+        tmp_path = tmp.name
+
+    try:
+        if not zipfile.is_zipfile(tmp_path):
+            return "[ERROR] Invalid docx file (not a valid ZIP)"
+
+        with zipfile.ZipFile(tmp_path, 'r') as z:
+            if 'word/document.xml' not in z.namelist():
+                return "[ERROR] Invalid docx file (no document.xml)"
+
+            xml_content = z.read('word/document.xml').decode('utf-8')
+            return extract_text_from_xml(xml_content)
+
+    finally:
+        try:
+            os.unlink(tmp_path)
+        except:
+            pass
+
+def process_base64_file(input_file: str) -> str:
+    """
+    Process a file containing base64-encoded docx content
+    """
+    with open(input_file, 'r') as f:
+        base64_content = f.read().strip()
+
+    # Clean base64 content
+    base64_clean = base64_content.replace('\n', '').replace('\r', '').replace(' ', '')
+
+    try:
+        docx_bytes = base64.b64decode(base64_clean)
+    except Exception as e:
+        return f"[ERROR] Base64 decode failed: {e}"
+
+    return extract_from_docx_bytes(docx_bytes)
+
+def save_transcription(text: str, tag: str, name: str, output_dir: str) -> str:
+    """
+    Save transcription with proper [TAG] naming
+    """
+    # Clean the name
+    clean_name = name
+    for ext in ['.docx', '.mp4', '.txt']:
+        clean_name = clean_name.replace(ext, '')
+    clean_name = clean_name.strip(' -.')
+
+    filename = f"[{tag}] {clean_name}.txt"
+    filepath = os.path.join(output_dir, filename)
+
+    os.makedirs(output_dir, exist_ok=True)
+
+    with open(filepath, 'w', encoding='utf-8') as f:
+        f.write(text)
+
+    return filepath
+
+if __name__ == "__main__":
+    import argparse
+
+    parser = argparse.ArgumentParser(description='Extract text from base64-encoded docx')
+    parser.add_argument('base64_file', help='File containing base64 content')
+    parser.add_argument('--tag', help='TAG for output file (e.g., JM-0003)')
+    parser.add_argument('--name', help='Original filename for output')
+    parser.add_argument('--output-dir', help='Output directory')
+
+    args = parser.parse_args()
+
+    text = process_base64_file(args.base64_file)
+
+    if text.startswith('[ERROR]'):
+        print(text, file=sys.stderr)
+        sys.exit(1)
+
+    if args.tag and args.name and args.output_dir:
+        filepath = save_transcription(text, args.tag, args.name, args.output_dir)
+        print(f"Saved: {filepath}")
+        print(f"Characters: {len(text)}")
+        print(f"Words: {len(text.split())}")
+    else:
+        # Just print the text
+        print(text)

package/.claude/scripts/extract-docx-text.py

@@ -0,0 +1,58 @@
+#!/usr/bin/env python3
+"""
+Extract text from base64-encoded .docx files from Google Drive
+"""
+
+import base64
+import subprocess
+import tempfile
+import os
+import sys
+
+def extract_text_from_base64_docx(base64_content: str) -> str:
+    """
+    Decode base64 docx content and extract text using pandoc
+    """
+    # Decode base64
+    docx_bytes = base64.b64decode(base64_content)
+
+    # Create temp file
+    with tempfile.NamedTemporaryFile(suffix='.docx', delete=False) as tmp:
+        tmp.write(docx_bytes)
+        tmp_path = tmp.name
+
+    try:
+        # Use pandoc to extract text
+        result = subprocess.run(
+            ['pandoc', tmp_path, '-t', 'plain', '--wrap=none'],
+            capture_output=True,
+            text=True,
+            check=True
+        )
+        return result.stdout
+    finally:
+        # Clean up
+        os.unlink(tmp_path)
+
+def save_transcription(text: str, tag: str, name: str, output_dir: str) -> str:
+    """
+    Save extracted text to file with proper naming
+    """
+    # Clean filename
+    clean_name = name.replace('.docx', '').replace('.mp4', '').strip()
+    filename = f"[{tag}] {clean_name}.txt"
+    filepath = os.path.join(output_dir, filename)
+
+    with open(filepath, 'w', encoding='utf-8') as f:
+        f.write(text)
+
+    return filepath
+
+if __name__ == "__main__":
+    if len(sys.argv) < 2:
+        print("Usage: python extract-docx-text.py <base64_content>")
+        sys.exit(1)
+
+    base64_content = sys.argv[1]
+    text = extract_text_from_base64_docx(base64_content)
+    print(text)

package/.claude/scripts/extract-single-transcription.py

@@ -0,0 +1,74 @@
+#!/usr/bin/env python3
+"""
+Extract a single transcription directly from Google Drive
+Uses the MCP gdrive API output format
+"""
+
+import base64
+import subprocess
+import tempfile
+import os
+import sys
+import re
+import zipfile
+
+def extract_text_from_docx_bytes(docx_bytes: bytes) -> str:
+    """
+    Extract text from docx bytes using pandoc or fallback to XML parsing
+    """
+    # Create temp file
+    with tempfile.NamedTemporaryFile(suffix='.docx', delete=False) as tmp:
+        tmp.write(docx_bytes)
+        tmp_path = tmp.name
+
+    try:
+        # First try pandoc
+        result = subprocess.run(
+            ['pandoc', tmp_path, '-t', 'plain', '--wrap=none'],
+            capture_output=True,
+            text=True,
+            timeout=30
+        )
+
+        if result.returncode == 0:
+            return result.stdout
+
+        # Fallback: extract from XML directly
+        with zipfile.ZipFile(tmp_path, 'r') as z:
+            if 'word/document.xml' in z.namelist():
+                xml_content = z.read('word/document.xml').decode('utf-8')
+                # Extract text from <w:t> tags
+                texts = re.findall(r'<w:t[^>]*>([^<]*)</w:t>', xml_content)
+                return ' '.join(texts)
+
+        return "[ERROR] Could not extract text"
+
+    except Exception as e:
+        return f"[ERROR] {e}"
+    finally:
+        try:
+            os.unlink(tmp_path)
+        except:
+            pass
+
+def main():
+    # Read base64 from stdin
+    base64_content = sys.stdin.read().strip()
+
+    if not base64_content:
+        print("[ERROR] No base64 content provided via stdin")
+        sys.exit(1)
+
+    try:
+        docx_bytes = base64.b64decode(base64_content)
+        print(f"[INFO] Decoded {len(docx_bytes)} bytes", file=sys.stderr)
+
+        text = extract_text_from_docx_bytes(docx_bytes)
+        print(text)
+
+    except Exception as e:
+        print(f"[ERROR] {e}")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()

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