mega-brain-ai 1.3.0

package/.claude/scripts/complete-tag-matching.py

@@ -0,0 +1,250 @@
+#!/usr/bin/env python3
+"""
+Complete Tag Matching Script - DE-PARA 1-a-1
+Matches each untagged file to its correct planilha entry and applies TAG
+"""
+
+import os
+import re
+import json
+from difflib import SequenceMatcher
+
+# Planilha data - extracted from Google Sheets
+PLANILHA_DATA = {
+    "30 Days Challenge": {
+        "prefix": "30DC",
+        "entries": {
+            "1 - Day 1": "30DC-0001",
+            "2 - Day 2": "30DC-0002",
+            "3 - Day 3": "30DC-0003",
+            "4 - Day 4": "30DC-0004",
+            "5 - Day 5": "30DC-0005",
+            "6 - Day 6": "30DC-0006",
+            "7 - Day 7": "30DC-0007",
+            "8 - Day 8": "30DC-0008",
+            "9 - Day 9": "30DC-0009",
+            "10 - Day 10": "30DC-0010",
+            "11 - Day 11.": "30DC-0011",
+            "12 - Day 12.": "30DC-0012",
+            "13- Day 13.": "30DC-0013",
+            "14 - Day 14.": "30DC-0014",
+            "15 - Day 15": "30DC-0015",
+            "16 - Day 16": "30DC-0016",
+            "17 - Day 17": "30DC-0017",
+            "18 - Day 18": "30DC-0018",
+            "19 - Day 19": "30DC-0019",
+            "20 - Day 20": "30DC-0020",
+            "21 - Day 21": "30DC-0021",
+            "22 - Day 22": "30DC-0022",
+            "23 - Day 23": "30DC-0023",
+            "24 - Day 24": "30DC-0024",
+            "25 - Day 25": "30DC-0025",
+            "26 - Day 26": "30DC-0026",
+            "27 - Day 27": "30DC-0027",
+            "28 - Day 28": "30DC-0028",
+            "29 - Day 29.": "30DC-0029",
+            "30 - Day 30": "30DC-0030",
+        }
+    },
+    "Cold Video Pitch": {
+        "prefix": "PCVP",
+        "entries": {
+            "1. Power Of Cold Video.": "PCVP-0001",
+            "2. Selling Advertising.": "PCVP-0002",
+            "3. Social Media Management.": "PCVP-0003",
+            "4. Google PPC.": "PCVP-0004",
+            "5. Facebook And Instagram.": "PCVP-0005",
+            "6. Long Form Content Creation.": "PCVP-0006",
+            "7. Animation.": "PCVP-0007",
+            "8. Graphics Design.": "PCVP-0008",
+            "9. Google Listing.": "PCVP-0009",
+            "10. Redoing Thumbnails.": "PCVP-0010",
+            "11. Sell Funnels.": "PCVP-0011",
+            "12. Chatbots.": "PCVP-0012",
+            "13. PR Services.": "PCVP-0013",
+        }
+    },
+    "Agency Blueprint": {
+        "prefix": "AOBA",
+        "entries": {
+            "1. What Is A Marketing Agency.": "AOBA-0001",
+            "2. Phases Of A Marketing Agency.": "AOBA-0002",
+            "3. Skills Or No Skills.": "AOBA-0003",
+            "4. Is It Best To Have Stuff Or A Referral Network.": "AOBA-0004",
+            "5. What Are The Possible Limiting Beliefs.": "AOBA-0005",
+            "6. What Is PPHD.": "AOBA-0006",
+            "7. Leveraging The Facebook Group.": "AOBA-0007",
+            "8. Is It Best To Go General Or Niche.": "AOBA-0008",
+            "9. Whats The Best Business Model Service Clients Or Consulting.": "AOBA-0009",
+            "10. How To Keep A Real Perspective Of Things.": "AOBA-0010",
+            "11. Do You Need A Website For Your Agency.": "AOBA-0011",
+            "12. How To Become An Expert.": "AOBA-0012",
+            "13. Before You Even Think About Getting A Partner.": "AOBA-0013",
+            "14. How To Be Comfortable With Failure.": "AOBA-0014",
+            "15. Anatomy Of A Perfect Client.": "AOBA-0015",
+            "16. How To Keep Your Standards High.": "AOBA-0016",
+            "17. The Power Of Expert Positioning": "AOBA-0017",
+            "18. How To Improve Your Social Presence.": "AOBA-0018",
+            "19. The Best Way To Hijack Authority.": "AOBA-0019",
+            "20. Differences Between Hard Flex and Soft Flex.": "AOBA-0020",
+            "21. When To Ask For Testimonials.": "AOBA-0021",
+            "22. Every Result Is A Marketable Headline.": "AOBA-0022",
+            "23. How To PR For Expansion.": "AOBA-0023",
+            "24. How To Overcome Major Obstacles.": "AOBA-0024",
+            "25. Is It Better To Charge High-Ticket Or Competitive Pricing.": "AOBA-0025",
+            "26. What Are The Core Services To Offer.": "AOBA-0026",
+            "27. What Model Is Better Transactional Or Recurring.": "AOBA-0027",
+            "28. How To Move From Transactional To Recurring.": "AOBA-0028",
+            "29. How To Stay Away From Free To Paid Service.": "AOBA-0029",
+            "30. The Profit First Business Model.": "AOBA-0030",
+            "31. How To Manage Agency Costs.": "AOBA-0031",
+            "32. How To Setup Bank Accounts.": "AOBA-0032",
+            "33. State Of The Agency Contraction And Expansion.": "AOBA-0033",
+            "34. Refunds Policy No Refunds.": "AOBA-0034",
+            "35. Result-Driven Services.": "AOBA-0035",
+            "36. Is It Better To Have A Contract Or Not.": "AOBA-0036",
+            "37. Change Is The Only Constant.": "AOBA-0037",
+            "38. Is It Best To Get New Skills Or Referrals.": "AOBA-0038",
+            "39. Cash Is Like Oxygen.": "AOBA-0039",
+            "40. Why Big Companies Focus On Sales.": "AOBA-0040",
+            "41. Daily Attitude And Training": "AOBA-0041",
+            "42. How Your Outflow Equals Your Inflow.": "AOBA-0042",
+            "43. Money Is In The Follow Up.": "AOBA-0043",
+            "44. How To Use Conviction To Win More.": "AOBA-0044",
+            "45. How To Win The Sales Game.": "AOBA-0045",
+            "46. Duplicating Yourself With Sales People.": "AOBA-0046",
+            "47. How To Be Confident In Your Services.": "AOBA-0047",
+            "48. How To Keep Your Cool At All Times.": "AOBA-0048",
+            "49. Is Cold Calling Dead.": "AOBA-0049",
+            "50. How To Keep A Full Pipeline.": "AOBA-0050",
+            "51. When Is It Time To Fire A Client.": "AOBA-0051",
+            "52. How To Deal With More Rejection Than Acceptance": "AOBA-0052",
+            "53. What Is A VAK.": "AOBA-0053",
+            "54. Leverage The Power Of Math.": "AOBA-0054",
+            "55. How To Use Systems To Save Your Agency.": "AOBA-0055",
+            "56. How To Keep Your Team Accountable.": "AOBA-0056",
+            "57. Expectations Equal Success.": "AOBA-0057",
+        }
+    }
+}
+
+def normalize_name(name):
+    """Normalize filename for matching"""
+    # Remove extension
+    name = re.sub(r'\.(txt|docx|mp4|pdf)$', '', name, flags=re.IGNORECASE)
+    # Remove youtube references
+    name = re.sub(r'\s*\[youtube\.com.*?\]', '', name)
+    # Remove timestamps
+    name = re.sub(r'\s*\d{1,2}-\d{1,2}-\d{2,4}', '', name)
+    # Normalize spaces and case
+    name = name.strip().lower()
+    # Remove multiple spaces
+    name = re.sub(r'\s+', ' ', name)
+    return name
+
+def find_best_match(filename, threshold=0.7):
+    """Find best matching planilha entry for a filename"""
+    norm_file = normalize_name(filename)
+
+    best_match = None
+    best_score = 0
+    best_tag = None
+    best_source = None
+
+    for source, data in PLANILHA_DATA.items():
+        for entry_name, tag in data["entries"].items():
+            norm_entry = normalize_name(entry_name)
+            score = SequenceMatcher(None, norm_file, norm_entry).ratio()
+
+            if score > best_score:
+                best_score = score
+                best_match = entry_name
+                best_tag = tag
+                best_source = source
+
+    if best_score >= threshold:
+        return {
+            "matched_to": best_match,
+            "tag": best_tag,
+            "source": best_source,
+            "score": best_score
+        }
+    return None
+
+def get_untagged_files(inbox_path):
+    """Get all untagged .txt files"""
+    untagged = []
+
+    for root, dirs, files in os.walk(inbox_path):
+        # Skip hidden and backup folders
+        dirs[:] = [d for d in dirs if not d.startswith('.') and not d.startswith('_')]
+
+        for f in files:
+            if f.endswith('.txt') and not (f.startswith('[') and ']' in f):
+                full_path = os.path.join(root, f)
+                rel_path = full_path.replace(inbox_path + '/', '')
+                untagged.append({
+                    "filename": f,
+                    "full_path": full_path,
+                    "rel_path": rel_path
+                })
+
+    return untagged
+
+def main():
+    inbox_path = "inbox"
+
+    print("=== COMPLETE TAG MATCHING - DE-PARA 1-a-1 ===\n")
+
+    # Get untagged files
+    untagged = get_untagged_files(inbox_path)
+    print(f"Total arquivos sem TAG: {len(untagged)}\n")
+
+    # Match each file
+    matches = []
+    orphans = []
+
+    for file_info in untagged:
+        match = find_best_match(file_info["filename"])
+        if match:
+            matches.append({
+                **file_info,
+                **match
+            })
+        else:
+            orphans.append(file_info)
+
+    print(f"MATCHES ENCONTRADOS: {len(matches)}")
+    print(f"ÓRFÃOS (sem match): {len(orphans)}\n")
+
+    print("=== MATCHES DETALHADOS ===\n")
+    for m in sorted(matches, key=lambda x: x["tag"]):
+        print(f"[{m['tag']}] {m['filename']}")
+        print(f"  → Planilha: {m['matched_to']} ({m['source']})")
+        print(f"  → Score: {m['score']:.2%}")
+        print(f"  → Path: {m['rel_path']}")
+        print()
+
+    print("\n=== ÓRFÃOS (ARQUIVOS SEM MATCH NA PLANILHA) ===\n")
+    for o in orphans:
+        print(f"  ✗ {o['rel_path']}")
+
+    # Save results
+    results = {
+        "total_untagged": len(untagged),
+        "total_matches": len(matches),
+        "total_orphans": len(orphans),
+        "matches": matches,
+        "orphans": orphans
+    }
+
+    output_path = ".claude/mission-control/COMPLETE-TAG-MATCHING.json"
+    with open(output_path, 'w') as f:
+        json.dump(results, f, indent=2, ensure_ascii=False)
+
+    print(f"\n\nResultados salvos em: {output_path}")
+
+    return results
+
+if __name__ == "__main__":
+    main()

package/.claude/scripts/deduplicate-inbox.py

@@ -0,0 +1,139 @@
+#!/usr/bin/env python3
+"""
+Deduplication Script - Remove duplicate files keeping only the most recent
+"""
+
+import os
+import re
+import shutil
+from collections import defaultdict
+from datetime import datetime
+
+INBOX_PATH = "inbox"
+BACKUP_PATH = os.path.join(INBOX_PATH, "_DEDUP_BACKUP")
+
+def find_tagged_files():
+    """Find all files with [TAG-XXXX] format"""
+    tagged_files = defaultdict(list)
+    tag_pattern = re.compile(r'^\[([A-Z0-9\-]+)\]')
+
+    for root, dirs, files in os.walk(INBOX_PATH):
+        # Skip the backup folder itself
+        if "_DEDUP_BACKUP" in root:
+            continue
+
+        for filename in files:
+            if not filename.endswith('.txt'):
+                continue
+
+            match = tag_pattern.match(filename)
+            if match:
+                tag = match.group(1)
+                full_path = os.path.join(root, filename)
+                mtime = os.path.getmtime(full_path)
+                tagged_files[tag].append({
+                    'filename': filename,
+                    'path': full_path,
+                    'mtime': mtime,
+                    'rel_path': os.path.relpath(full_path, INBOX_PATH)
+                })
+
+    return tagged_files
+
+def deduplicate(execute=False):
+    """Remove duplicates, keeping the most recent file for each TAG"""
+
+    print("=" * 70)
+    print("DEDUPLICAÇÃO DO INBOX - MEGA BRAIN")
+    print("=" * 70)
+    print(f"\nModo: {'EXECUTAR' if execute else 'PREVIEW (--execute para aplicar)'}")
+    print("=" * 70)
+
+    # Ensure backup folder exists
+    if execute and not os.path.exists(BACKUP_PATH):
+        os.makedirs(BACKUP_PATH)
+
+    tagged_files = find_tagged_files()
+
+    # Stats
+    total_tags = len(tagged_files)
+    duplicated_tags = 0
+    files_to_remove = 0
+
+    duplicates_list = []
+
+    for tag, files in sorted(tagged_files.items()):
+        if len(files) > 1:
+            duplicated_tags += 1
+            # Sort by mtime descending (most recent first)
+            files_sorted = sorted(files, key=lambda x: x['mtime'], reverse=True)
+            keep = files_sorted[0]
+            remove = files_sorted[1:]
+
+            print(f"\n[{tag}] {len(files)} cópias encontradas:")
+            print(f"  ✓ MANTER: {keep['rel_path']}")
+            print(f"    (modificado: {datetime.fromtimestamp(keep['mtime']).strftime('%Y-%m-%d %H:%M')})")
+
+            for f in remove:
+                files_to_remove += 1
+                print(f"  ✗ REMOVER: {f['rel_path']}")
+                print(f"    (modificado: {datetime.fromtimestamp(f['mtime']).strftime('%Y-%m-%d %H:%M')})")
+                duplicates_list.append({
+                    'tag': tag,
+                    'file': f,
+                    'keep': keep
+                })
+
+    print("\n" + "=" * 70)
+    print("RESUMO")
+    print("=" * 70)
+    print(f"Total de TAGs únicas: {total_tags}")
+    print(f"TAGs com duplicatas: {duplicated_tags}")
+    print(f"Arquivos a remover: {files_to_remove}")
+
+    if execute and duplicates_list:
+        print("\n" + "=" * 70)
+        print("EXECUTANDO REMOÇÃO")
+        print("=" * 70)
+
+        success = 0
+        errors = 0
+
+        for dup in duplicates_list:
+            src = dup['file']['path']
+            # Create subfolder in backup based on original relative path
+            rel_dir = os.path.dirname(dup['file']['rel_path'])
+            if rel_dir:
+                dest_dir = os.path.join(BACKUP_PATH, rel_dir)
+            else:
+                dest_dir = BACKUP_PATH
+
+            if not os.path.exists(dest_dir):
+                os.makedirs(dest_dir)
+
+            dest = os.path.join(dest_dir, dup['file']['filename'])
+
+            try:
+                shutil.move(src, dest)
+                print(f"✓ Movido: {dup['file']['rel_path']}")
+                success += 1
+            except Exception as e:
+                print(f"✗ Erro: {dup['file']['rel_path']} - {e}")
+                errors += 1
+
+        print("\n" + "=" * 70)
+        print("RESULTADO FINAL")
+        print("=" * 70)
+        print(f"✓ Arquivos movidos para backup: {success}")
+        print(f"✗ Erros: {errors}")
+        print(f"\nBackup em: {BACKUP_PATH}")
+
+    elif not execute:
+        print(f"\nExecute com: python3 deduplicate-inbox.py --execute")
+
+    return duplicated_tags, files_to_remove
+
+if __name__ == "__main__":
+    import sys
+    execute = '--execute' in sys.argv
+    deduplicate(execute)

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