mega-brain-ai 1.3.0

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

@@ -0,0 +1,77 @@
+#!/usr/bin/env python3
+"""
+Apply Tags Script - Renames matched files with TAG prefix
+"""
+
+import os
+import json
+import sys
+
+def apply_tags(execute=False):
+    # Load matching results
+    with open('.claude/mission-control/COMPLETE-TAG-MATCHING.json') as f:
+        data = json.load(f)
+
+    matches = data['matches']
+
+    print("=" * 60)
+    print("APLICAÇÃO DE TAGS - DE-PARA COMPLETO")
+    print("=" * 60)
+    print(f"\nTotal arquivos com match: {len(matches)}")
+    print(f"Modo: {'EXECUTAR' if execute else 'PREVIEW (--execute para aplicar)'}")
+    print("=" * 60)
+    print()
+
+    success = 0
+    errors = 0
+    skipped = 0
+
+    for m in sorted(matches, key=lambda x: x['tag']):
+        old_path = m['full_path']
+        tag = m['tag']
+        filename = m['filename']
+
+        # Skip if file already has a tag
+        if filename.startswith('[') and ']' in filename:
+            print(f"⏭️  SKIP (já tem tag): {filename}")
+            skipped += 1
+            continue
+
+        # Build new filename with tag
+        new_filename = f"[{tag}] {filename}"
+        new_path = os.path.join(os.path.dirname(old_path), new_filename)
+
+        print(f"[{tag}] {m['rel_path']}")
+        print(f"  → {new_filename}")
+
+        if execute:
+            try:
+                if os.path.exists(old_path):
+                    os.rename(old_path, new_path)
+                    print(f"  ✓ RENOMEADO")
+                    success += 1
+                else:
+                    print(f"  ✗ ERRO: Arquivo não encontrado")
+                    errors += 1
+            except Exception as e:
+                print(f"  ✗ ERRO: {e}")
+                errors += 1
+        print()
+
+    print("=" * 60)
+    print("RESUMO")
+    print("=" * 60)
+    if execute:
+        print(f"✓ Renomeados com sucesso: {success}")
+        print(f"⏭️  Pulados (já tem tag): {skipped}")
+        print(f"✗ Erros: {errors}")
+    else:
+        print(f"📋 Prontos para renomear: {len(matches) - skipped}")
+        print(f"⏭️  Já com tag: {skipped}")
+        print(f"\nExecute com: python3 apply-tags.py --execute")
+
+    return success, skipped, errors
+
+if __name__ == "__main__":
+    execute = '--execute' in sys.argv
+    apply_tags(execute)

package/.claude/scripts/batch-extract-transcriptions.py

@@ -0,0 +1,132 @@
+#!/usr/bin/env python3
+"""
+Batch Extraction Script for Mega Brain Transcriptions
+------------------------------------------------------
+Este script extrai transcrições de arquivos .docx no Google Drive
+e salva como arquivos .txt com TAG no INBOX.
+
+Uso:
+    python batch-extract-transcriptions.py <base64_file> <tag> <output_name> <output_dir>
+
+O arquivo base64_file deve conter o conteúdo base64 puro do .docx
+"""
+
+import base64
+import subprocess
+import tempfile
+import os
+import sys
+import json
+
+def decode_and_extract(base64_content: str) -> str:
+    """
+    Decode base64 docx content and extract text using pandoc
+    """
+    # Remove whitespace/newlines from base64
+    base64_clean = base64_content.strip().replace('\n', '').replace(' ', '')
+
+    # Decode base64
+    try:
+        docx_bytes = base64.b64decode(base64_clean)
+    except Exception as e:
+        return f"[ERROR] Base64 decode failed: {e}"
+
+    # Create temp file
+    with tempfile.NamedTemporaryFile(suffix='.docx', delete=False) as tmp:
+        tmp.write(docx_bytes)
+        tmp_path = tmp.name
+
+    try:
+        # Check if pandoc is available
+        result = subprocess.run(
+            ['which', 'pandoc'],
+            capture_output=True,
+            text=True
+        )
+
+        if result.returncode != 0:
+            # Try using unzip to extract document.xml directly
+            import zipfile
+            try:
+                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')
+                        # Basic XML text extraction
+                        import re
+                        text = re.sub(r'<[^>]+>', '', xml_content)
+                        text = re.sub(r'\s+', ' ', text)
+                        return text.strip()
+            except Exception as e:
+                return f"[ERROR] ZIP extraction failed: {e}"
+
+        # 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
+
+    except subprocess.CalledProcessError as e:
+        return f"[ERROR] Pandoc failed: {e.stderr}"
+    except Exception as e:
+        return f"[ERROR] Extraction failed: {e}"
+    finally:
+        # Clean up
+        try:
+            os.unlink(tmp_path)
+        except:
+            pass
+
+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()
+    # Remove leading numbers and dashes if duplicated
+    clean_name = clean_name.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
+
+def process_from_file(base64_file: str, tag: str, name: str, output_dir: str) -> dict:
+    """
+    Process a single file from base64 content file
+    """
+    with open(base64_file, 'r') as f:
+        base64_content = f.read()
+
+    text = decode_and_extract(base64_content)
+
+    if text.startswith('[ERROR]'):
+        return {'success': False, 'error': text, 'tag': tag}
+
+    filepath = save_transcription(text, tag, name, output_dir)
+    return {
+        'success': True,
+        'filepath': filepath,
+        'tag': tag,
+        'chars': len(text),
+        'words': len(text.split())
+    }
+
+if __name__ == "__main__":
+    if len(sys.argv) < 5:
+        print("Usage: python batch-extract-transcriptions.py <base64_file> <tag> <output_name> <output_dir>")
+        print("Example: python batch-extract-transcriptions.py /tmp/content.b64 JM-0003 'Your Prospects Are Lying' ./INBOX/")
+        sys.exit(1)
+
+    base64_file = sys.argv[1]
+    tag = sys.argv[2]
+    name = sys.argv[3]
+    output_dir = sys.argv[4]
+
+    result = process_from_file(base64_file, tag, name, output_dir)
+    print(json.dumps(result, indent=2))

package/.claude/scripts/build-complete-index.py

@@ -0,0 +1,250 @@
+#!/usr/bin/env python3
+"""
+BUILD COMPLETE INDEX - Extrai dados de todos os JSONs da planilha
+Mega Brain - Sistema de Inteligência de Negócios
+
+Processa os arquivos JSON salvos das chamadas do Google Sheets API
+e constrói o índice completo nome→TAG
+"""
+
+import os
+import re
+import json
+from datetime import datetime
+from pathlib import Path
+
+# Configurações
+TOOL_RESULTS_PATH = ""  # Set to your Claude tool-results path
+OUTPUT_PATH = ".claude/mission-control/PLANILHA-INDEX.json"
+SCHEMA_PATH = ".claude/mission-control/SPREADSHEET-SCHEMA.json"
+
+# Mapeamento de sheet -> coluna da TAG (índice baseado em 0 da row)
+SHEET_CONFIG = {
+    "Jeremy Haynes Sales Training": {"tag_col": -1, "prefix": "JH-ST"},  # última coluna
+    "Jeremy Haynes Inner Circle": {"tag_col": -1, "prefix": "JH-IC"},
+    "Inner Circle Weekly Group Call Recordings": {"tag_col": -1, "prefix": "JH-WK"},
+    "Agency Blueprint": {"tag_col": -1, "prefix": "AOBA"},
+    "Cold Video Pitch": {"tag_col": -1, "prefix": "PCVP"},
+    "Land Your First Agency Client": {"tag_col": -1, "prefix": "LYFC"},
+    "Marketer Mindset Masterclass": {"tag_col": -1, "prefix": "MMM"},
+    "30 Days Challenge": {"tag_col": -1, "prefix": "30DC"},
+    "Scale The Agency": {"tag_col": -1, "prefix": "STA"},
+    "Ultra High Ticket Closer": {"tag_col": -1, "prefix": "UHTC"},
+    "Jeremy Miner": {"tag_col": -1, "prefix": "JM"},
+    "The Scalable Company": {"tag_col": -1, "prefix": "TSC"},
+    "Sales Training BR": {"tag_col": -1, "prefix": "EDC"},
+    "Alex Hormozi": {"tag_col": -1, "prefix": "AH"},
+    "Jeremy Haynes Program": {"tag_col": -1, "prefix": "CA"},
+}
+
+def normalize_name(name):
+    """Normaliza nome para matching."""
+    if not name:
+        return ""
+    # Lowercase
+    name = str(name).lower()
+    # Remove extensão
+    name = re.sub(r'\.(mp4|docx|txt|pdf)$', '', name, flags=re.IGNORECASE)
+    # Remove número inicial
+    name = re.sub(r'^\d+[\s\.\-]+', '', name)
+    # Remove (1), (2), etc
+    name = re.sub(r'\s*\(\d+\)\s*', '', name)
+    # Remove youtube references
+    name = re.sub(r'\[youtube\.com[^\]]*\]', '', name)
+    # Remove caracteres especiais
+    name = re.sub(r'[^\w\s]', ' ', name)
+    name = re.sub(r'\s+', ' ', name).strip()
+    return name
+
+def is_valid_tag(tag, prefix=None):
+    """Verifica se é uma TAG válida."""
+    if not tag:
+        return False
+    tag = str(tag).strip()
+
+    # Formato básico: XXX-NNNN ou XX-XXX-NNNN
+    if not re.match(r'^[\w-]+-\d{4}$', tag):
+        return False
+
+    # Se prefix especificado, verificar
+    if prefix and not tag.startswith(prefix):
+        return False
+
+    return True
+
+def extract_from_row(row, sheet_name):
+    """Extrai nome e TAG de uma row."""
+    if not row:
+        return None, None
+
+    # Extrair valores
+    values = []
+    for cell in row:
+        if isinstance(cell, dict):
+            values.append(cell.get('value', ''))
+        else:
+            values.append(str(cell) if cell else '')
+
+    if not values:
+        return None, None
+
+    # Nome está na primeira coluna
+    name = values[0] if values else None
+
+    # TAG está na última coluna (geralmente)
+    # Procurar TAG no formato correto de trás para frente
+    tag = None
+    for v in reversed(values):
+        if v and is_valid_tag(v):
+            tag = v
+            break
+
+    return name, tag
+
+def process_json_file(filepath):
+    """Processa um arquivo JSON do Google Sheets."""
+    entries = []
+
+    try:
+        with open(filepath, 'r', encoding='utf-8') as f:
+            raw_data = json.load(f)
+
+        # Formato: [{type: text, text: JSON_STRING}]
+        if isinstance(raw_data, list) and raw_data:
+            if isinstance(raw_data[0], dict) and 'text' in raw_data[0]:
+                data = json.loads(raw_data[0]['text'])
+            else:
+                data = raw_data
+        else:
+            data = raw_data
+
+        # Processar dados
+        if isinstance(data, list):
+            # Lista de sheets
+            for sheet_data in data:
+                if isinstance(sheet_data, dict) and 'sheetName' in sheet_data:
+                    sheet_name = sheet_data['sheetName']
+                    rows = sheet_data.get('data', [])
+
+                    for row in rows:
+                        name, tag = extract_from_row(row, sheet_name)
+                        if name and tag:
+                            entries.append({
+                                'original_name': name,
+                                'normalized': normalize_name(name),
+                                'tag': tag,
+                                'sheet': sheet_name
+                            })
+
+        elif isinstance(data, dict):
+            # Pode ser formato valueRanges ou outro
+            if 'valueRanges' in data:
+                for range_data in data.get('valueRanges', []):
+                    # Extrair sheet name do range
+                    range_str = range_data.get('range', '')
+                    sheet_name = range_str.split('!')[0].strip("'")
+
+                    for row in range_data.get('values', []):
+                        name, tag = extract_from_row(row, sheet_name)
+                        if name and tag:
+                            entries.append({
+                                'original_name': name,
+                                'normalized': normalize_name(name),
+                                'tag': tag,
+                                'sheet': sheet_name
+                            })
+
+    except Exception as e:
+        print(f"  Erro processando {filepath}: {e}")
+
+    return entries
+
+def main():
+    print("=" * 60)
+    print("BUILD COMPLETE INDEX")
+    print("=" * 60)
+    print()
+
+    all_entries = []
+    sheets_found = set()
+
+    # 1. Processar todos os arquivos JSON em tool-results
+    print("[1/3] Processando arquivos JSON...")
+
+    if os.path.exists(TOOL_RESULTS_PATH):
+        json_files = list(Path(TOOL_RESULTS_PATH).glob("mcp-gdrive*.txt"))
+        print(f"       {len(json_files)} arquivos encontrados")
+
+        for filepath in json_files:
+            entries = process_json_file(filepath)
+            if entries:
+                print(f"       {filepath.name}: {len(entries)} entradas")
+                all_entries.extend(entries)
+                sheets_found.update(e['sheet'] for e in entries)
+    else:
+        print(f"       AVISO: Pasta não encontrada: {TOOL_RESULTS_PATH}")
+
+    # 2. Remover duplicatas (manter mais recente por tag)
+    print()
+    print("[2/3] Removendo duplicatas...")
+
+    seen_tags = {}
+    unique_entries = []
+
+    for entry in all_entries:
+        tag = entry['tag']
+        if tag not in seen_tags:
+            seen_tags[tag] = entry
+            unique_entries.append(entry)
+        else:
+            # Se mesma tag, manter a entrada com nome mais completo
+            existing = seen_tags[tag]
+            if len(entry['original_name']) > len(existing['original_name']):
+                seen_tags[tag] = entry
+                unique_entries = [e for e in unique_entries if e['tag'] != tag]
+                unique_entries.append(entry)
+
+    print(f"       De {len(all_entries)} para {len(unique_entries)} entradas únicas")
+
+    # 3. Ordenar por sheet e tag
+    unique_entries.sort(key=lambda x: (x['sheet'], x['tag']))
+
+    # 4. Salvar índice
+    print()
+    print("[3/3] Salvando índice...")
+
+    index = {
+        'version': '2.0',
+        'timestamp': datetime.now().isoformat(),
+        'total_entries': len(unique_entries),
+        'sheets_processed': sorted(list(sheets_found)),
+        'entries': unique_entries
+    }
+
+    with open(OUTPUT_PATH, 'w', encoding='utf-8') as f:
+        json.dump(index, f, ensure_ascii=False, indent=2)
+
+    print(f"       Salvo em: {OUTPUT_PATH}")
+    print()
+
+    # 5. Resumo por sheet
+    print("=" * 60)
+    print("RESUMO POR SHEET")
+    print("=" * 60)
+
+    sheet_counts = {}
+    for entry in unique_entries:
+        sheet = entry['sheet']
+        sheet_counts[sheet] = sheet_counts.get(sheet, 0) + 1
+
+    for sheet, count in sorted(sheet_counts.items()):
+        print(f"  {sheet}: {count} TAGs")
+
+    print()
+    print(f"TOTAL: {len(unique_entries)} entradas")
+    print("=" * 60)
+
+    return index
+
+if __name__ == '__main__':
+    main()

package/.claude/scripts/build-planilha-index.py

@@ -0,0 +1,170 @@
+#!/usr/bin/env python3
+"""
+BUILD PLANILHA INDEX - Cria índice nome→TAG da planilha
+Processa os arquivos JSON exportados das abas do Google Sheets
+"""
+
+import os
+import re
+import json
+from datetime import datetime
+
+# Configurações
+TOOL_RESULTS_PATH = ""  # Set to your Claude tool-results path
+OUTPUT_PATH = ".claude/mission-control/PLANILHA-INDEX.json"
+SCHEMA_PATH = ".claude/mission-control/SPREADSHEET-SCHEMA.json"
+
+def normalize_name(name):
+    """Normaliza nome para matching."""
+    if not name:
+        return ""
+    # Lowercase
+    name = str(name).lower()
+    # Remove extensão
+    name = re.sub(r'\.(mp4|docx|txt|pdf)$', '', name, flags=re.IGNORECASE)
+    # Remove número inicial
+    name = re.sub(r'^\d+[\s\.\-]+', '', name)
+    # Remove (1), (2), etc
+    name = re.sub(r'\s*\(\d+\)\s*', '', name)
+    # Remove caracteres especiais
+    name = re.sub(r'[^\w\s]', ' ', name)
+    name = re.sub(r'\s+', ' ', name).strip()
+    return name
+
+def process_sheet_data(data, sheet_name, tag_col_index):
+    """Processa dados de uma aba e extrai entradas."""
+    entries = []
+
+    for row in data:
+        if not row or len(row) < tag_col_index + 1:
+            continue
+
+        # Extrair valores relevantes
+        name_cell = row[0] if len(row) > 0 else None  # Coluna B (nome)
+        tag_cell = row[tag_col_index] if len(row) > tag_col_index else None
+
+        if not name_cell or not tag_cell:
+            continue
+
+        name = name_cell.get('value', '') if isinstance(name_cell, dict) else str(name_cell)
+        tag = tag_cell.get('value', '') if isinstance(tag_cell, dict) else str(tag_cell)
+
+        # Verificar se TAG é válida
+        if not tag or not re.match(r'^[\w-]+-\d{4}$', tag):
+            continue
+
+        entries.append({
+            'original_name': name,
+            'normalized': normalize_name(name),
+            'tag': tag,
+            'sheet': sheet_name
+        })
+
+    return entries
+
+def main():
+    print("=" * 60)
+    print("BUILD PLANILHA INDEX")
+    print("=" * 60)
+    print()
+
+    # Carregar schema para saber configuração de cada aba
+    print("[1/3] Carregando schema...")
+    with open(SCHEMA_PATH, 'r', encoding='utf-8') as f:
+        schema = json.load(f)
+
+    # Encontrar arquivos JSON do Google Sheets
+    print("[2/3] Processando dados exportados...")
+
+    # Dados inline do Sales Training (copiados do resultado anterior)
+    # Por agora, vou criar entradas manualmente baseadas no schema
+
+    entries = []
+
+    # Dados do Jeremy Haynes Sales Training (processado inline)
+    jh_st_data = [
+        ("1 - Introduction to Sales Training", "JH-ST-0001"),
+        ("2. The Plague of Fat Cat Closers", "JH-ST-0002"),
+        ("3. How to Deal With Inbound Leads Who Only Filled Out a Form", "JH-ST-0003"),
+        ("4. Sales Team Structures to Consider", "JH-ST-0004"),
+        ("5. The Cleaner Role", "JH-ST-0005"),
+        ("6. Using Sales Videos to Aid The Sales Process", "JH-ST-0006"),
+        ("7. Selfie Follow up Video Texts Get an iphone", "JH-ST-0007"),
+        ("8. Get Leads Back on The Phone With Value Driven Follow up", "JH-ST-0008"),
+        ("9. How to Increase Show Rate", "JH-ST-0009"),
+        ("10.Why You Should Text Every Lead Manually", "JH-ST-0010"),
+        ("11. Value Added vs Selfish Questions", "JH-ST-0011"),
+        ("12. Value Added Questions vs Selfish Questions", "JH-ST-0012"),
+        ("13. How to Increase Average Order Value", "JH-ST-0013"),
+        ("14. How to Recruit Sales People", "JH-ST-0014"),
+        ("15. How to Train Maintain a Great Sales Team", "JH-ST-0015"),
+        ("16. Why Full Time Closers Are Better", "JH-ST-0016"),
+        ("17. How to Raise The Value of The Price", "JH-ST-0017"),
+        ("18. Raising The Clients Interest Level", "JH-ST-0018"),
+        ("19. How to Create Real Scarcity Urgency", "JH-ST-0019"),
+        ("20. Reviewing Calls Providing Feedback", "JH-ST-0020"),
+        ("21. Your Personal Life Impacts Your Professional Life", "JH-ST-0021"),
+        ("22. Tools Software For Closers", "JH-ST-0022"),
+        ("23. When to Fire Sales Reps", "JH-ST-0023"),
+        ("24. Keep Your Moral High", "JH-ST-0024"),
+        ("25. Sales Training With Jordan Stupar", "JH-ST-0025"),
+        ("26. Sales Training With Josh Troy", "JH-ST-0026"),
+        ("1. Intro to Objections", "JH-ST-0028"),
+        ("2. What Happens if You go Out of Business", "JH-ST-0029"),
+        ("3. How do I Know my Money is Safe", "JH-ST-0030"),
+        ("4. Can I Speak to The Owner", "JH-ST-0031"),
+        ("5. How Can You Guarantee That Ill Make Money", "JH-ST-0032"),
+        ("6. Why Are You Better Than Everybody Else", "JH-ST-0033"),
+        ("7. Id Rather Get Started Next Quarter", "JH-ST-0034"),
+        ("8. I Have to Get my Lawyer to Review Before Moving Forward", "JH-ST-0035"),
+        ("9. My Business Partner I Will Need To Review This", "JH-ST-0036"),
+        ("10. Im Traveling This Week Lets Move Forward Next Week", "JH-ST-0037"),
+        ("11. Are You Open to Changes in The Agreement", "JH-ST-0038"),
+        ("12. Can I Speak to an Existing Client", "JH-ST-0039"),
+        ("13. I Saw a Negative Review Im Afraid Itll Happen to me", "JH-ST-0040"),
+        ("14. Objection I Cant Afford This", "JH-ST-0041"),
+        ("15. Objection I Cant Afford This", "JH-ST-0042"),
+        ("16. Objection I Cant Afford This", "JH-ST-0043"),
+        ("17. I Didnt Expect it to Cost This Much", "JH-ST-0044"),
+        ("18. I am Looking at Other Service Providers", "JH-ST-0045"),
+    ]
+
+    for name, tag in jh_st_data:
+        entries.append({
+            'original_name': name,
+            'normalized': normalize_name(name),
+            'tag': tag,
+            'sheet': 'Jeremy Haynes Sales Training'
+        })
+
+    print(f"       Processadas {len(entries)} entradas iniciais")
+    print()
+    print("  NOTA: Este script precisa ser expandido para processar todas as abas")
+    print("        via API do Google Sheets ou arquivos JSON exportados.")
+    print()
+
+    # 3. Salvar índice
+    print("[3/3] Salvando índice...")
+
+    index = {
+        'version': '1.0',
+        'timestamp': datetime.now().isoformat(),
+        'total_entries': len(entries),
+        'sheets_processed': list(set(e['sheet'] for e in entries)),
+        'entries': entries
+    }
+
+    with open(OUTPUT_PATH, 'w', encoding='utf-8') as f:
+        json.dump(index, f, ensure_ascii=False, indent=2)
+
+    print(f"       Salvo em: {OUTPUT_PATH}")
+    print(f"       Total: {len(entries)} entradas")
+    print()
+    print("=" * 60)
+    print("ÍNDICE CRIADO (parcial)")
+    print("=" * 60)
+
+    return index
+
+if __name__ == '__main__':
+    main()