mega-brain-ai 1.1.0

package/.claude/rules/state-management.md

@@ -0,0 +1,93 @@
+# Regras de Gerenciamento de Estado
+
+## 🔴 MISSION-STATE.json é SAGRADO
+
+**Localização:** `/.claude/mission-control/MISSION-STATE.json`
+
+## 📖 Ler ANTES de
+
+- Qualquer resposta ao usuário
+- Qualquer processamento
+- Qualquer sugestão de próxima ação
+- Qualquer estimativa de tempo/progresso
+
+## ✏️ Atualizar APÓS
+
+- Completar um batch
+- Mudar de source
+- Mudar de fase
+- Iniciar sessão
+- Encerrar sessão
+- Qualquer ação significativa
+
+## 📋 Campos críticos
+
+```json
+{
+  "current_state": {
+    "phase": 4,              // 1-5
+    "phase_name": "Pipeline",
+    "status": "IN_PROGRESS", // NOT_STARTED, IN_PROGRESS, COMPLETE
+    "source_code": "CG",
+    "source_name": "Cole Gordon",
+    "batch_current": 3,
+    "batch_total": 8,
+    "percent_complete": 37.5
+  },
+  "session": {
+    "id": "SESSION-2026-01-08-001",
+    "started_at": "2026-01-08T14:00:00Z",
+    "last_action_at": "2026-01-08T14:35:00Z",
+    "is_active": true
+  },
+  "next_action": {
+    "description": "Processar BATCH-004 Cole Gordon",
+    "phase": 4,
+    "details": "Arquivos CG_sales-8.txt até CG_sales-15.txt"
+  }
+}
+```
+
+## 🎯 Posição EXATA sempre
+
+❌ ERRADO: "Estamos na fase 4"
+❌ ERRADO: "Processando Cole Gordon"
+❌ ERRADO: "Quase terminando"
+
+✅ CERTO: "Fase 4, Batch 3/8, Cole Gordon, arquivo 8/23"
+✅ CERTO: "37.5% da fase 4 completa"
+
+## 🔄 Ao iniciar sessão
+
+```bash
+# 1. Ler estado
+cat /.claude/mission-control/MISSION-STATE.json
+
+# 2. Atualizar sessão
+# session.id = novo ID
+# session.started_at = agora
+# session.is_active = true
+
+# 3. Exibir status visual
+# 4. Perguntar se continua
+```
+
+## 🔄 Ao encerrar sessão
+
+```bash
+# 1. Atualizar estado
+# session.last_action_at = agora
+# session.is_active = false
+
+# 2. Criar HANDOFF
+# /logs/handoffs/HANDOFF-LATEST.md
+
+# 3. Salvar estado
+```
+
+## ⚠️ Nunca
+
+- Modificar sem ler primeiro
+- Deixar session.is_active = true ao sair
+- Esquecer de atualizar next_action
+- Deixar percent_complete desatualizado

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