mega-brain-ai 1.1.0

package/bin/mega-brain.js

@@ -0,0 +1,97 @@
+#!/usr/bin/env node
+
+/**
+ * Mega Brain - AI Knowledge Management System
+ * CLI Entry Point
+ *
+ * Usage:
+ *   npx mega-brain install    - Install Mega Brain in current/specified directory
+ *   npx mega-brain validate   - Validate MoneyClub email
+ *   npx mega-brain push       - Push to Layer 1/2/3 remote
+ *   npx mega-brain upgrade    - Upgrade Community to Premium
+ *   npx mega-brain --help     - Show help
+ */
+
+import { createRequire } from 'module';
+import { fileURLToPath } from 'url';
+import { dirname, resolve } from 'path';
+import { readFileSync } from 'fs';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const require = createRequire(import.meta.url);
+
+const pkg = JSON.parse(readFileSync(resolve(__dirname, '..', 'package.json'), 'utf-8'));
+
+const args = process.argv.slice(2);
+const command = args[0];
+
+async function main() {
+  const { showBanner } = await import('./lib/ascii-art.js');
+
+  showBanner(pkg.version);
+
+  if (!command || command === '--help' || command === '-h') {
+    showHelp();
+    process.exit(0);
+  }
+
+  if (command === 'install') {
+    const { runInstaller } = await import('./lib/installer.js');
+    await runInstaller(pkg.version);
+  } else if (command === 'validate') {
+    const { validateEmail } = await import('./lib/validate-email.js');
+    const email = args[1];
+    if (!email) {
+      console.error('\n  Uso: mega-brain validate <email>\n');
+      process.exit(1);
+    }
+    const result = await validateEmail(email);
+    console.log(result.valid ? `\n  Email válido: ${result.name}` : `\n  Email inválido: ${result.reason}`);
+    setTimeout(() => process.exit(result.valid ? 0 : 1), 100);
+  } else if (command === 'push') {
+    // Dynamic import of push module
+    await import('./push.js');
+  } else if (command === 'upgrade') {
+    const { runUpgrade } = await import('./lib/installer.js');
+    if (typeof runUpgrade === 'function') {
+      await runUpgrade(pkg.version);
+    } else {
+      console.log('\n  Funcionalidade de upgrade será disponibilizada em breve.');
+      console.log('  Por enquanto, reinstale com: mega-brain install\n');
+    }
+  } else {
+    console.error(`\n  Comando desconhecido: ${command}`);
+    showHelp();
+    process.exit(1);
+  }
+}
+
+function showHelp() {
+  console.log(`
+  Mega Brain v${pkg.version}
+  AI Knowledge Management System
+
+  Comandos:
+    install     Instalar Mega Brain (PREMIUM ou Community)
+    validate    Validar email MoneyClub (mega-brain validate <email>)
+    push        Push para Layer 1/2/3 (mega-brain push [--layer N])
+    upgrade     Atualizar Community para Premium
+    --help      Mostrar esta mensagem
+
+  Layers:
+    Layer 1     Community (público) — shell sem conteúdo
+    Layer 2     Premium (MoneyClub) — shell + cérebro
+    Layer 3     Full Backup (pessoal) — tudo incluindo dados sensíveis
+
+  Exemplos:
+    npx mega-brain install
+    npx mega-brain push --layer 1
+    npx mega-brain push
+`);
+}
+
+main().catch((err) => {
+  console.error('\n  Erro inesperado:', err.message);
+  setTimeout(() => process.exit(1), 100);
+});

package/bin/push.js

@@ -0,0 +1,342 @@
+#!/usr/bin/env node
+
+/**
+ * Mega Brain - 3-Layer Push System
+ *
+ * Pushes content to the appropriate git remote based on layer selection:
+ *   Layer 1 (public)  → Only allowlisted files → remote "public"
+ *   Layer 2 (premium) → Layer 1 + premium content → remote "premium"
+ *   Layer 3 (backup)  → Everything, no filtering → remote "backup"
+ *
+ * Usage:
+ *   mega-brain push           Interactive layer selection
+ *   mega-brain push --layer 1 Direct push to Layer 1
+ *   mega-brain push --layer 2 Direct push to Layer 2
+ *   mega-brain push --layer 3 Direct push to Layer 3
+ */
+
+import { createInterface } from 'readline';
+import { readFileSync, existsSync, mkdirSync, cpSync, rmSync, readdirSync, statSync } from 'fs';
+import { resolve, dirname, join, relative } from 'path';
+import { fileURLToPath } from 'url';
+import { execSync } from 'child_process';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const PROJECT_ROOT = resolve(__dirname, '..');
+
+function prompt(question) {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((res) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      res(answer.trim());
+    });
+  });
+}
+
+function git(cmd, opts = {}) {
+  try {
+    return execSync(`git ${cmd}`, {
+      cwd: PROJECT_ROOT,
+      encoding: 'utf-8',
+      stdio: opts.silent ? 'pipe' : 'inherit',
+      ...opts,
+    });
+  } catch (err) {
+    if (opts.silent) return '';
+    throw err;
+  }
+}
+
+function loadAllowlist(filePath) {
+  if (!existsSync(filePath)) return [];
+  const content = readFileSync(filePath, 'utf-8');
+  return content
+    .split('\n')
+    .map((l) => l.trim())
+    .filter((l) => l && !l.startsWith('#'));
+}
+
+function matchesPattern(filePath, patterns) {
+  for (const pattern of patterns) {
+    // Exact match
+    if (filePath === pattern) return true;
+    // Directory match (pattern ends with /)
+    if (pattern.endsWith('/') && filePath.startsWith(pattern)) return true;
+    // File starts with pattern directory
+    if (filePath.startsWith(pattern + '/')) return true;
+    // Glob-like: pattern without trailing slash matches as prefix
+    if (!pattern.includes('*') && filePath.startsWith(pattern)) return true;
+  }
+  return false;
+}
+
+function getTrackedFiles() {
+  const output = git('ls-files', { silent: true, stdio: 'pipe' });
+  return output.split('\n').filter(Boolean);
+}
+
+function getRemotes() {
+  const output = git('remote -v', { silent: true, stdio: 'pipe' });
+  const remotes = {};
+  for (const line of output.split('\n')) {
+    const match = line.match(/^(\S+)\s+(\S+)\s+\(push\)/);
+    if (match) remotes[match[1]] = match[2];
+  }
+  return remotes;
+}
+
+async function selectLayer(args) {
+  // Check for --layer flag
+  const layerIdx = args.indexOf('--layer');
+  if (layerIdx !== -1 && args[layerIdx + 1]) {
+    const layer = parseInt(args[layerIdx + 1], 10);
+    if ([1, 2, 3].includes(layer)) return layer;
+  }
+
+  console.log(`
+  ┌──────────────────────────────────────────────────────────────┐
+  │                  MEGA BRAIN — PUSH LAYERS                    │
+  ├──────────────────────────────────────────────────────────────┤
+  │                                                              │
+  │  [1] Layer 1 — COMMUNITY (Público)                          │
+  │      Shell do sistema + comandos + estrutura vazia           │
+  │      Remote: public → GitHub público                         │
+  │                                                              │
+  │  [2] Layer 2 — PREMIUM (MoneyClub Members)                  │
+  │      Layer 1 + Mentes Clonadas + Playbooks + DNAs           │
+  │      Remote: premium → GitHub privado (gated)                │
+  │                                                              │
+  │  [3] Layer 3 — FULL BACKUP (Pessoal)                        │
+  │      Tudo. Inbox, logs, .env, dados sensíveis               │
+  │      Remote: backup → GitHub privado (seu)                   │
+  │                                                              │
+  └──────────────────────────────────────────────────────────────┘
+`);
+
+  const choice = await prompt('  Selecione a Layer (1/2/3): ');
+  const layer = parseInt(choice, 10);
+  if (![1, 2, 3].includes(layer)) {
+    console.error('\n  Opção inválida. Use 1, 2 ou 3.\n');
+    process.exit(1);
+  }
+  return layer;
+}
+
+function getRemoteName(layer) {
+  return { 1: 'public', 2: 'premium', 3: 'backup' }[layer];
+}
+
+function getLayerLabel(layer) {
+  return {
+    1: 'COMMUNITY (Layer 1 — Público)',
+    2: 'PREMIUM (Layer 2 — MoneyClub)',
+    3: 'FULL BACKUP (Layer 3 — Pessoal)',
+  }[layer];
+}
+
+async function pushLayer3(remoteName, branch) {
+  // Layer 3: push everything, no filtering
+  console.log(`\n  Enviando TUDO para remote "${remoteName}"...`);
+  git(`push ${remoteName} ${branch}`);
+  console.log(`\n  Layer 3 enviada com sucesso para ${remoteName}/${branch}`);
+}
+
+async function pushFiltered(layer, remoteName, branch) {
+  const allowlistPath = resolve(PROJECT_ROOT, '.github', 'layer1-allowlist.txt');
+  const allowlist = loadAllowlist(allowlistPath);
+
+  if (allowlist.length === 0) {
+    console.error('\n  ERRO: Allowlist vazia ou não encontrada.');
+    console.error(`  Verifique: ${allowlistPath}\n`);
+    process.exit(1);
+  }
+
+  const syncDir = resolve(PROJECT_ROOT, '.layer-sync', `layer${layer}`);
+
+  console.log(`\n  Preparando Layer ${layer}...`);
+
+  // Clean previous sync
+  if (existsSync(syncDir)) {
+    rmSync(syncDir, { recursive: true, force: true });
+  }
+  mkdirSync(syncDir, { recursive: true });
+
+  // Initialize git in sync dir if needed
+  const syncGit = (cmd) =>
+    execSync(`git ${cmd}`, { cwd: syncDir, encoding: 'utf-8', stdio: 'pipe' });
+
+  // Get all tracked files
+  const allFiles = getTrackedFiles();
+
+  // Filter based on layer
+  let includedFiles;
+  if (layer === 1) {
+    // Layer 1: only allowlisted files
+    includedFiles = allFiles.filter((f) => matchesPattern(f, allowlist));
+  } else {
+    // Layer 2: allowlisted + premium (exclude Layer 3 personal data)
+    const layer3Exclusions = [
+      'inbox/',
+      'logs/',
+      '.env',
+      '.mcp.json',
+      '.claude/agent-memory/',
+      '.claude/aios/',
+      '.claude/sessions/',
+      '.claude/monitoring/',
+      '.claude/learning-system/',
+      '.claude/mission-control/',
+      'system/backups/',
+      'system/jarvis-voice/audiobooks/',
+      'system/jarvis-voice/voice_id',
+      'system/jarvis-voice/vapi_config.json',
+      'system/registry/',
+      'system/temp/',
+      'system/archive/',
+    ];
+    includedFiles = allFiles.filter(
+      (f) => !layer3Exclusions.some((excl) => f.startsWith(excl) || f === excl.replace(/\/$/, ''))
+    );
+  }
+
+  console.log(`  ${includedFiles.length} arquivos selecionados para Layer ${layer}`);
+
+  // Copy selected files to sync dir
+  let copied = 0;
+  for (const file of includedFiles) {
+    const srcPath = resolve(PROJECT_ROOT, file);
+    const destPath = resolve(syncDir, file);
+    const destDir = dirname(destPath);
+
+    if (!existsSync(srcPath)) continue;
+
+    if (!existsSync(destDir)) {
+      mkdirSync(destDir, { recursive: true });
+    }
+
+    try {
+      cpSync(srcPath, destPath);
+      copied++;
+    } catch {
+      // Skip files that can't be copied
+    }
+  }
+
+  console.log(`  ${copied} arquivos copiados para staging`);
+
+  // Initialize git repo in sync dir and push
+  try {
+    syncGit('init');
+    syncGit('add -A');
+
+    // Get current commit message from main repo
+    const lastMsg = git('log -1 --format=%s', { silent: true, stdio: 'pipe' }).trim();
+    const commitMsg = `[Layer ${layer}] ${lastMsg}`;
+
+    syncGit(`commit -m "${commitMsg.replace(/"/g, '\\"')}" --allow-empty`);
+
+    // Get remote URL
+    const remotes = getRemotes();
+    const remoteUrl = remotes[remoteName];
+
+    if (!remoteUrl) {
+      console.error(`\n  ERRO: Remote "${remoteName}" não configurado.`);
+      console.error('  Configure com: git remote add ' + remoteName + ' <url>\n');
+      process.exit(1);
+    }
+
+    syncGit(`remote add ${remoteName} ${remoteUrl}`);
+    console.log(`\n  Enviando para ${remoteName}...`);
+
+    execSync(`git push ${remoteName} HEAD:${branch} --force`, {
+      cwd: syncDir,
+      encoding: 'utf-8',
+      stdio: 'inherit',
+    });
+
+    console.log(`\n  Layer ${layer} enviada com sucesso!`);
+  } finally {
+    // Cleanup
+    try {
+      rmSync(syncDir, { recursive: true, force: true });
+    } catch {
+      // Ignore cleanup errors
+    }
+  }
+}
+
+async function main() {
+  const args = process.argv.slice(2).filter((a) => a !== 'push');
+
+  console.log(`
+  ┌──────────────────────────────────────────────────────────────┐
+  │          MEGA BRAIN — 3-LAYER PUSH SYSTEM                    │
+  └──────────────────────────────────────────────────────────────┘`);
+
+  // Check for uncommitted changes
+  const status = git('status --porcelain', { silent: true, stdio: 'pipe' }).trim();
+  if (status) {
+    console.log('\n  AVISO: Existem mudanças não commitadas:');
+    console.log(
+      status
+        .split('\n')
+        .slice(0, 5)
+        .map((l) => `    ${l}`)
+        .join('\n')
+    );
+    if (status.split('\n').length > 5) {
+      console.log(`    ... e mais ${status.split('\n').length - 5} arquivos`);
+    }
+    const proceed = await prompt('\n  Continuar mesmo assim? (s/n): ');
+    if (proceed.toLowerCase() !== 's') {
+      console.log('\n  Push cancelado. Faça commit primeiro.\n');
+      process.exit(0);
+    }
+  }
+
+  const layer = await selectLayer(args);
+  const remoteName = getRemoteName(layer);
+  const branch = git('rev-parse --abbrev-ref HEAD', { silent: true, stdio: 'pipe' }).trim() || 'main';
+
+  // Verify remote exists
+  const remotes = getRemotes();
+  if (!remotes[remoteName]) {
+    console.error(`\n  ERRO: Remote "${remoteName}" não existe.`);
+    console.error(`\n  Remotes disponíveis:`);
+    for (const [name, url] of Object.entries(remotes)) {
+      console.error(`    ${name} → ${url}`);
+    }
+    console.error(`\n  Adicione com: git remote add ${remoteName} <url>\n`);
+    process.exit(1);
+  }
+
+  console.log(`\n  Layer:  ${getLayerLabel(layer)}`);
+  console.log(`  Remote: ${remoteName} → ${remotes[remoteName]}`);
+  console.log(`  Branch: ${branch}`);
+
+  const confirm = await prompt('\n  Confirmar push? (s/n): ');
+  if (confirm.toLowerCase() !== 's') {
+    console.log('\n  Push cancelado.\n');
+    process.exit(0);
+  }
+
+  if (layer === 3) {
+    await pushLayer3(remoteName, branch);
+  } else {
+    await pushFiltered(layer, remoteName, branch);
+  }
+
+  console.log(`
+  ┌──────────────────────────────────────────────────────────────┐
+  │  PUSH CONCLUÍDO                                              │
+  │  Layer ${layer} → ${remoteName} (${branch})${' '.repeat(Math.max(0, 35 - remoteName.length - branch.length))}│
+  └──────────────────────────────────────────────────────────────┘
+`);
+}
+
+main().catch((err) => {
+  console.error(`\n  Erro: ${err.message}\n`);
+  process.exit(1);
+});

package/bin/templates/env.example

@@ -0,0 +1,38 @@
+# Mega Brain - Environment Configuration
+# Copy this file to .env and fill in your API keys
+# Run /setup in Claude Code for guided configuration
+
+# ═══════════════════════════════════════════════════════
+# REQUIRED - Without this, video transcription won't work
+# ═══════════════════════════════════════════════════════
+
+# OpenAI API (Whisper) - Video & audio transcription
+# Essential for /ingest with YouTube videos and audio files
+# The system uploads media and transcribes via Whisper API
+# Get yours at: https://platform.openai.com/api-keys
+OPENAI_API_KEY=
+
+# ═══════════════════════════════════════════════════════
+# RECOMMENDED - Highly recommended for full functionality
+# ═══════════════════════════════════════════════════════
+
+# Voyage AI - Semantic search in knowledge base
+# Enables Conclave and agents to find evidence in your materials
+# Powers the RAG (Retrieval Augmented Generation) pipeline
+# Get yours at: https://dash.voyageai.com/api-keys
+VOYAGE_API_KEY=
+
+# ═══════════════════════════════════════════════════════
+# OPTIONAL - Enable additional features
+# ═══════════════════════════════════════════════════════
+
+# Anthropic API (Claude) - NOT needed with Claude Code Max/Pro
+# Only required for standalone scripts outside Claude Code
+# Get yours at: https://console.anthropic.com/settings/keys
+ANTHROPIC_API_KEY=
+
+# Google Drive Import - Import content from Google Drive
+# PDFs, documents, spreadsheets directly from your Drive
+# Setup at: https://console.cloud.google.com/apis/credentials
+GOOGLE_CLIENT_ID=
+GOOGLE_CLIENT_SECRET=

package/integrations/README.md

@@ -0,0 +1,46 @@
+# integrations - MCP Hub & Notifications
+
+> **Versao:** 1.0.0
+> **Status:** Em construcao (SPEC-004)
+
+## Descricao
+
+Central de integrações do [SUA EMPRESA] OS, incluindo MCPs e sistemas de notificação.
+
+## Estrutura
+
+```
+integrations/
+├── mcps/                           # MCP Hub
+│   ├── MCP-REGISTRY.md             # Registro central (a criar)
+│   ├── gdrive/                     # Google Drive + Sheets (ATIVO)
+│   ├── excalidraw/                 # Diagramas (ATIVO)
+│   ├── playwright/                 # Automacao web (AIOS)
+│   ├── desktop-commander/          # Controle desktop (AIOS)
+│   └── exa/                        # Search avancado (AIOS)
+└── notifications/                  # Sistema de notificacoes
+    ├── ntfy/                       # Push notifications (Ralph Inferno)
+    └── discord/                    # Webhooks (Ralph Inferno)
+```
+
+## MCPs Ativos
+
+| MCP | Status | Descricao |
+|-----|--------|-----------|
+| gdrive | ✅ ATIVO | Google Drive + Sheets |
+| excalidraw | ✅ ATIVO | Diagramas |
+
+## MCPs Pendentes (AIOS)
+
+| MCP | Fonte | Descricao |
+|-----|-------|-----------|
+| playwright | AIOS | Automacao web, screenshots |
+| desktop-commander | AIOS | Controle de desktop |
+| exa | AIOS | Search avancado |
+
+## Notifications Pendentes (Ralph Inferno)
+
+| Sistema | Descricao |
+|---------|-----------|
+| ntfy | Push notifications para celular |
+| discord | Webhooks para canal |

package/integrations/mcps/MCP-REGISTRY.md

@@ -0,0 +1,56 @@
+# MCP Registry - [SUA EMPRESA] OS
+
+> **Versao:** 1.0.0
+> **Atualizado:** 2026-01-17
+
+## MCPs Registrados
+
+### ATIVOS
+
+| MCP | Comandos | Fonte |
+|-----|----------|-------|
+| **gdrive** | `gdrive_search`, `gdrive_read_file`, `gsheets_read`, `gsheets_update_cell`, `gdocs_create` | Mega Brain |
+| **excalidraw** | `create_element`, `update_element`, `delete_element`, `query_elements`, `create_from_mermaid` | Mega Brain |
+
+### PENDENTES (A Configurar)
+
+| MCP | Comandos Previstos | Fonte |
+|-----|-------------------|-------|
+| **playwright** | `navigate`, `screenshot`, `click`, `fill`, `extract` | AIOS |
+| **desktop-commander** | `execute`, `read_file`, `write_file`, `list_dir` | AIOS |
+| **exa** | `search`, `get_contents` | AIOS |
+
+## Como Usar
+
+### gdrive
+
+```
+# Buscar arquivos
+mcp__gdrive__gdrive_search(query="nome do arquivo")
+
+# Ler arquivo
+mcp__gdrive__gdrive_read_file(fileId="...")
+
+# Ler planilha
+mcp__gdrive__gsheets_read(spreadsheetId="...")
+
+# Atualizar celula
+mcp__gdrive__gsheets_update_cell(fileId="...", range="A1", value="...")
+```
+
+### excalidraw
+
+```
+# Criar elemento
+mcp__excalidraw__create_element(type="rectangle", x=0, y=0, width=100, height=50)
+
+# Criar de Mermaid
+mcp__excalidraw__create_from_mermaid(mermaidDiagram="graph TD; A-->B")
+```
+
+## Adicionar Novo MCP
+
+1. Criar pasta em `/integrations/mcps/[nome]/`
+2. Criar `CONFIG.md` com instrucoes
+3. Atualizar este registry
+4. Configurar em `settings.json` se necessario

package/integrations/mcps/excalidraw/CONFIG.md

@@ -0,0 +1,56 @@
+# Excalidraw MCP
+
+> **Status:** ✅ ATIVO
+> **Fonte:** Mega Brain (nativo)
+
+## Comandos Disponiveis
+
+| Comando | Descricao |
+|---------|-----------|
+| `create_element` | Criar novo elemento |
+| `update_element` | Atualizar elemento existente |
+| `delete_element` | Deletar elemento |
+| `query_elements` | Buscar elementos |
+| `get_resource` | Obter recurso (scene, library, theme) |
+| `group_elements` | Agrupar elementos |
+| `ungroup_elements` | Desagrupar |
+| `align_elements` | Alinhar elementos |
+| `distribute_elements` | Distribuir elementos |
+| `lock_elements` | Travar elementos |
+| `unlock_elements` | Destravar elementos |
+| `create_from_mermaid` | Criar diagrama de Mermaid |
+| `batch_create_elements` | Criar multiplos elementos |
+
+## Tipos de Elementos
+
+- `rectangle`
+- `ellipse`
+- `diamond`
+- `arrow`
+- `text`
+- `label`
+- `freedraw`
+- `line`
+
+## Exemplos
+
+```python
+# Criar retangulo
+mcp__excalidraw__create_element(
+    type="rectangle",
+    x=100, y=100,
+    width=200, height=100,
+    backgroundColor="#e3f2fd"
+)
+
+# Criar de Mermaid
+mcp__excalidraw__create_from_mermaid(
+    mermaidDiagram="graph TD; A[Start]-->B[Process]; B-->C[End]"
+)
+
+# Criar multiplos elementos
+mcp__excalidraw__batch_create_elements(elements=[
+    {"type": "rectangle", "x": 0, "y": 0, "width": 100, "height": 50},
+    {"type": "text", "x": 10, "y": 20, "text": "Hello"}
+])
+```

package/integrations/mcps/gdrive/CONFIG.md

@@ -0,0 +1,38 @@
+# Google Drive MCP
+
+> **Status:** ✅ ATIVO
+> **Fonte:** Mega Brain (nativo)
+
+## Comandos Disponiveis
+
+| Comando | Descricao |
+|---------|-----------|
+| `gdrive_search` | Buscar arquivos no Drive |
+| `gdrive_read_file` | Ler conteudo de arquivo |
+| `gsheets_read` | Ler planilha completa ou ranges |
+| `gsheets_update_cell` | Atualizar celula de planilha |
+| `gdocs_create` | Criar documento Google Docs |
+
+## IDs Importantes ([SUA EMPRESA])
+
+```yaml
+kpis_master: "1I2GR7npvdEamVZJdGPbh1IfyYPW-_KcRyWFMCrs-OXo"
+dre_2025: "1kjSCf0m9sJ-3n8n9zXJg7jdfM4RP01OQ8-QS5HdiMhc"
+hiring_folder: "1GWbhrQZZwSToq7oLfHQ34vCf5VyjcxWL"
+```
+
+## Exemplos
+
+```python
+# Buscar arquivo
+result = mcp__gdrive__gdrive_search(query="nome do arquivo")
+
+# Ler planilha inteira
+data = mcp__gdrive__gsheets_read(spreadsheetId="ID_AQUI")
+
+# Ler ranges especificos
+data = mcp__gdrive__gsheets_read(
+    spreadsheetId="ID_AQUI",
+    ranges=["Sheet1!A1:B10", "Sheet2!C1:D5"]
+)
+```