mega-brain-ai 1.3.0

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

@@ -0,0 +1,253 @@
+#!/usr/bin/env python3
+"""
+FASE 2.5 v2 - Tagueamento por MATCHING DE NOMES
+Mega Brain - Sistema de Inteligência de Negócios
+
+ABORDAGEM CORRETA:
+1. Extrair de TODAS as abas: nome_video → TAG
+2. Para cada arquivo INBOX, fazer matching por nome similar
+3. Se match encontrado, usar TAG da planilha
+4. Se não, manter órfão
+"""
+
+import os
+import re
+import json
+from pathlib import Path
+from datetime import datetime
+from difflib import SequenceMatcher
+
+# Configurações
+INBOX_PATH = "inbox"
+SCHEMA_PATH = ".claude/mission-control/SPREADSHEET-SCHEMA.json"
+INDEX_PATH = ".claude/mission-control/PLANILHA-INDEX.json"
+OUTPUT_PATH = ".claude/mission-control/TAG-MAPPING-V2.json"
+
+def normalize_name(name):
+    """Normaliza nome para matching."""
+    # Remove extensão
+    name = os.path.splitext(name)[0]
+    # Lowercase
+    name = name.lower()
+    # Remove timestamps
+    name = re.sub(r'_\d{14}$', '', name)
+    name = re.sub(r'\d{1,2}-\d{1,2}-\d{2,4}', '', name)  # Remove datas tipo 12-25-24
+    # Remove número inicial
+    name = re.sub(r'^\d+[\s\.\-]+', '', name)
+    # Remove [youtube.com...] e similares
+    name = re.sub(r'\[youtube\.com[^\]]*\]', '', name)
+    name = re.sub(r'\[[^\]]*\]', '', 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 similar(a, b):
+    """Calcula similaridade entre dois nomes (0-1)."""
+    return SequenceMatcher(None, a, b).ratio()
+
+def load_planilha_index():
+    """Carrega índice da planilha (nome → TAG)."""
+    if os.path.exists(INDEX_PATH):
+        with open(INDEX_PATH, 'r', encoding='utf-8') as f:
+            return json.load(f)
+    return None
+
+def scan_inbox_files():
+    """Varre todos os arquivos do INBOX."""
+    files = []
+    extensions = {'.txt', '.docx', '.pdf'}
+
+    for root, dirs, filenames in os.walk(INBOX_PATH):
+        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 já tem TAG
+                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)),
+                    'normalized': normalize_name(filename),
+                    'has_tag': has_tag
+                })
+
+    return files
+
+def match_file_to_index(file_info, index, threshold=0.7):
+    """Tenta encontrar match no índice da planilha."""
+    normalized_name = file_info['normalized']
+
+    if not normalized_name:
+        return None, 0
+
+    best_match = None
+    best_score = 0
+
+    for entry in index['entries']:
+        # Comparar com nome normalizado da planilha
+        score = similar(normalized_name, entry['normalized'])
+        if score > best_score and score >= threshold:
+            best_score = score
+            best_match = entry
+
+    return best_match, best_score
+
+def main(execute=False, threshold=0.7):
+    print("=" * 60)
+    print("FASE 2.5 v2 - TAGUEAMENTO POR MATCHING")
+    print("=" * 60)
+    print()
+
+    # 1. Carregar índice da planilha
+    print("[1/4] Carregando índice da planilha...")
+    index = load_planilha_index()
+    if not index:
+        print("  ERRO: Índice não encontrado!")
+        print("  Execute primeiro: /criar-indice-planilha")
+        return None
+    print(f"       {len(index['entries'])} entradas no índice")
+
+    # 2. Escanear INBOX
+    print("[2/4] Escaneando INBOX...")
+    files = scan_inbox_files()
+    print(f"       {len(files)} arquivos encontrados")
+
+    # 3. Fazer matching
+    print(f"[3/4] Matching (threshold={threshold})...")
+
+    matched = []
+    orphans = []
+    already_tagged = []
+
+    for f in files:
+        if f['has_tag']:
+            already_tagged.append(f)
+            continue
+
+        match, score = match_file_to_index(f, index, threshold)
+        if match:
+            matched.append({
+                'file': f,
+                'match': match,
+                'score': score
+            })
+        else:
+            orphans.append(f)
+
+    print(f"       Já tagueados: {len(already_tagged)}")
+    print(f"       Match encontrado: {len(matched)}")
+    print(f"       Órfãos: {len(orphans)}")
+
+    # 4. Gerar relatório
+    print("[4/4] Gerando relatório...")
+
+    report = {
+        'timestamp': datetime.now().isoformat(),
+        'threshold': threshold,
+        'summary': {
+            'total_files': len(files),
+            'already_tagged': len(already_tagged),
+            'matched': len(matched),
+            'orphans': len(orphans)
+        },
+        'matches': [],
+        'orphans': []
+    }
+
+    for m in matched:
+        report['matches'].append({
+            'current_path': m['file']['path'],
+            'filename': m['file']['filename'],
+            'folder': m['file']['folder'],
+            'matched_to': m['match']['original_name'],
+            'tag': m['match']['tag'],
+            'sheet': m['match']['sheet'],
+            'score': round(m['score'], 3)
+        })
+
+    for o in orphans:
+        report['orphans'].append({
+            'path': o['path'],
+            'filename': o['filename'],
+            'folder': o['folder'],
+            'normalized': o['normalized']
+        })
+
+    # Salvar relatório
+    with open(OUTPUT_PATH, 'w', encoding='utf-8') as f:
+        json.dump(report, f, ensure_ascii=False, indent=2)
+
+    print()
+    print("=" * 60)
+    print("RELATÓRIO GERADO")
+    print("=" * 60)
+    print(f"Arquivo: {OUTPUT_PATH}")
+
+    # 5. Executar renomeação se solicitado
+    if execute and matched:
+        print()
+        print("=" * 60)
+        print("EXECUTANDO RENOMEAÇÃO")
+        print("=" * 60)
+
+        success = 0
+        errors = []
+
+        for m in matched:
+            filepath = Path(m['file']['path'])
+            tag = m['match']['tag']
+            new_name = f"[{tag}] {filepath.name}"
+            new_path = filepath.parent / new_name
+
+            if new_path.exists():
+                errors.append({'path': str(filepath), 'error': 'Destino já existe'})
+                continue
+
+            try:
+                filepath.rename(new_path)
+                success += 1
+                if success % 50 == 0:
+                    print(f"  Renomeados: {success}/{len(matched)}")
+            except Exception as e:
+                errors.append({'path': str(filepath), 'error': str(e)})
+
+        print()
+        print(f"Sucesso: {success}")
+        print(f"Erros: {len(errors)}")
+
+        report['execution'] = {
+            'success': success,
+            'errors': len(errors),
+            'error_details': errors
+        }
+
+        with open(OUTPUT_PATH, 'w', encoding='utf-8') as f:
+            json.dump(report, f, ensure_ascii=False, indent=2)
+
+    else:
+        print()
+        print("PRÓXIMO PASSO: Execute com --execute para renomear")
+        print(f"              Threshold atual: {threshold}")
+        print("              Use --threshold=0.6 para matching mais flexível")
+
+    return report
+
+
+if __name__ == '__main__':
+    import sys
+    execute = '--execute' in sys.argv
+    threshold = 0.7
+    for arg in sys.argv:
+        if arg.startswith('--threshold='):
+            threshold = float(arg.split('=')[1])
+    main(execute=execute, threshold=threshold)

package/.claude/scripts/test-extraction.py

@@ -0,0 +1,35 @@
+#!/usr/bin/env python3
+"""
+Test extraction of text from base64-encoded .docx
+"""
+
+import base64
+import subprocess
+import tempfile
+import os
+
+# Base64 content from Google Drive (truncated for test - will use full content)
+base64_content = """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"""
+
+# Decode and process
+try:
+    docx_bytes = base64.b64decode(base64_content)
+    print(f"Decoded {len(docx_bytes)} bytes")
+
+    # Save to temp file
+    with open('/tmp/test_doc.docx', 'wb') as f:
+        f.write(docx_bytes)
+
+    print("Saved to /tmp/test_doc.docx")
+
+    # Check if it's a valid zip/docx
+    import zipfile
+    if zipfile.is_zipfile('/tmp/test_doc.docx'):
+        print("Valid ZIP/DOCX structure detected")
+        with zipfile.ZipFile('/tmp/test_doc.docx', 'r') as z:
+            print("Contents:", z.namelist()[:5])
+    else:
+        print("Not a valid ZIP file - content may be truncated")
+
+except Exception as e:
+    print(f"Error: {e}")

package/.claude/scripts/test-full-extraction.py

@@ -0,0 +1,74 @@
+#!/usr/bin/env python3
+"""
+Test script to verify extraction works with known base64 content
+"""
+
+import base64
+import tempfile
+import zipfile
+import re
+from xml.etree import ElementTree as ET
+
+WORD_NAMESPACE = '{http://schemas.openxmlformats.org/wordprocessingml/2006/main}'
+
+def extract_text_from_xml(xml_content: str) -> str:
+    try:
+        root = ET.fromstring(xml_content)
+    except ET.ParseError:
+        texts = re.findall(r'<w:t[^>]*>([^<]*)</w:t>', xml_content)
+        return ' '.join(texts)
+
+    texts = []
+    for elem in root.iter():
+        if elem.tag == f'{WORD_NAMESPACE}t':
+            if elem.text:
+                texts.append(elem.text)
+        elif elem.tag == f'{WORD_NAMESPACE}p':
+            if texts and not texts[-1].endswith('\n'):
+                texts.append('\n')
+        elif elem.tag == f'{WORD_NAMESPACE}br':
+            texts.append('\n')
+
+    text = ''.join(texts)
+    text = re.sub(r'[ \t]+', ' ', text)
+    text = re.sub(r'\n\s*\n', '\n\n', text)
+    return text.strip()
+
+# Read test base64 from file
+TEST_FILE = ".claude/temp/full_base64.txt"
+
+try:
+    with open(TEST_FILE, 'r') as f:
+        base64_content = f.read().strip()
+
+    print(f"Read {len(base64_content)} chars of base64")
+
+    docx_bytes = base64.b64decode(base64_content)
+    print(f"Decoded to {len(docx_bytes)} bytes")
+
+    # Save temporarily and check structure
+    with tempfile.NamedTemporaryFile(suffix='.docx', delete=False) as tmp:
+        tmp.write(docx_bytes)
+        tmp_path = tmp.name
+
+    if zipfile.is_zipfile(tmp_path):
+        print("Valid ZIP/DOCX structure")
+        with zipfile.ZipFile(tmp_path, 'r') as z:
+            files = z.namelist()
+            print(f"Contains {len(files)} files")
+            if 'word/document.xml' in files:
+                xml_content = z.read('word/document.xml').decode('utf-8')
+                print(f"document.xml: {len(xml_content)} chars")
+                text = extract_text_from_xml(xml_content)
+                print(f"\nExtracted text ({len(text)} chars, {len(text.split())} words):")
+                print("="*60)
+                print(text[:2000] if len(text) > 2000 else text)
+                print("="*60)
+    else:
+        print("Not a valid ZIP file")
+
+except FileNotFoundError:
+    print(f"Test file not found: {TEST_FILE}")
+    print("Please save base64 content to this file first")
+except Exception as e:
+    print(f"Error: {e}")