mega-brain-ai 1.1.0

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

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)