create-genia-mission-control 1.0.0

package/README.md

@@ -0,0 +1,47 @@
+# create-genia-mission-control
+
+> Instale o GEN.IA Mission Control com um único comando.
+
+## Uso
+
+```bash
+npx create-genia-mission-control
+```
+
+**Pré-requisito único:** Node.js 18+ — instale em [nodejs.org](https://nodejs.org)
+
+## O que instala
+
+O wizard configura automaticamente:
+
+1. **Claude Code CLI** — se não estiver instalado
+2. **Autenticação** — login via browser ou API key
+3. **Segundo Cérebro** — seu repositório privado de contexto
+4. **GEN.IA SQUAD OS** — 9 agentes de dev + 13 Xquads consultores
+5. **Mission Control** — interface visual estilo Gather Town
+
+## Após a instalação
+
+```bash
+cd seu-projeto/mission-control
+node server.js
+# Abre localhost:3001
+```
+
+## O Segundo Cérebro
+
+Repositório privado no seu GitHub que os agentes leem em toda sessão.
+Criado automaticamente a partir do template:
+[segundo-cerebro-template](https://github.com/elidyizzy/segundo-cerebro-template)
+
+## Três caminhos para o Segundo Cérebro
+
+| Situação | Caminho |
+|----------|---------|
+| Tem GitHub + repo existente | Clona direto |
+| Tem GitHub + sem repo | Cria repo privado via API |
+| Sem GitHub / não quer agora | Cria localmente (pode conectar depois) |
+
+---
+
+Criado por [Elidy Izidio](https://github.com/elidyizzy) — GEN.IA SQUAD

package/bin/index.js

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+
+// Verificar Node.js >= 18
+const [major] = process.versions.node.split('.').map(Number);
+if (major < 18) {
+  console.error('\n❌ Node.js 18 ou superior é necessário.');
+  console.error(`   Versão atual: ${process.version}`);
+  console.error('   Instale em: https://nodejs.org\n');
+  process.exit(1);
+}
+
+// Entry point
+import('../lib/main.js').catch(err => {
+  console.error('\n❌ Erro fatal:', err.message);
+  process.exit(1);
+});

package/lib/auth.js

@@ -0,0 +1,75 @@
+import { execa } from 'execa';
+import { prompt } from 'enquirer';
+import { ui } from './ui.js';
+
+export async function authenticate() {
+  ui.nl();
+  console.log(ui.gold('Como você quer autenticar com o Claude?'));
+  ui.nl();
+
+  const { method } = await prompt({
+    type: 'select',
+    name: 'method',
+    message: 'Método de autenticação:',
+    choices: [
+      { name: 'browser', message: '🌐 Login pelo browser (recomendado)' },
+      { name: 'apikey',  message: '🔑 Usar API key da Anthropic' },
+    ],
+  });
+
+  if (method === 'browser') {
+    return await authBrowser();
+  } else {
+    return await authAPIKey();
+  }
+}
+
+async function authBrowser() {
+  console.log(ui.info('Abrindo autenticação no browser...'));
+  console.log(ui.dim('  O browser vai abrir. Faça login e volte aqui.'));
+  ui.nl();
+
+  try {
+    // claude login abre o browser automaticamente
+    // No Windows, tenta 'claude.cmd' se 'claude' falhar
+    for (const cmd of ['claude', 'claude.cmd']) {
+      try {
+        await execa(cmd, ['login'], { stdio: 'inherit' });
+        console.log(ui.ok('Autenticado com sucesso'));
+        return { method: 'browser' };
+      } catch (e) {
+        if (e.code !== 'ENOENT') throw e;
+      }
+    }
+    throw new Error('Claude CLI não encontrado');
+  } catch (err) {
+    console.log(ui.warn('Não foi possível autenticar automaticamente'));
+    console.log(ui.dim('  Execute manualmente: claude login'));
+    return null;
+  }
+}
+
+async function authAPIKey() {
+  const { apiKey } = await prompt({
+    type: 'password',
+    name: 'apiKey',
+    message: 'Cole sua API key da Anthropic:',
+    validate: (v) => v.startsWith('sk-ant-') ? true : 'API key inválida (deve começar com sk-ant-)',
+  });
+
+  // Salvar na variável de ambiente para uso durante a instalação
+  process.env.ANTHROPIC_API_KEY = apiKey;
+
+  // Tentar configurar no claude CLI
+  for (const cmd of ['claude', 'claude.cmd']) {
+    try {
+      await execa(cmd, ['config', 'set', 'apiKey', apiKey], { stdio: 'pipe' });
+      break;
+    } catch {
+      // continua
+    }
+  }
+
+  console.log(ui.ok('API key configurada'));
+  return { method: 'apikey', apiKey };
+}

package/lib/checks.js

@@ -0,0 +1,50 @@
+import { execa } from 'execa';
+import { ui } from './ui.js';
+
+export async function checkEnvironment() {
+  const results = {
+    node: false,
+    git: false,
+    claudeCLI: false,
+  };
+
+  // Node.js (já verificado no bin, mas confirma versão)
+  const [major] = process.versions.node.split('.').map(Number);
+  results.node = major >= 18;
+
+  // Git
+  try {
+    await execa('git', ['--version']);
+    results.git = true;
+  } catch {
+    results.git = false;
+  }
+
+  // Claude Code CLI — tenta 'claude' e 'claude.cmd' (Windows)
+  for (const cmd of ['claude', 'claude.cmd']) {
+    try {
+      await execa(cmd, ['--version']);
+      results.claudeCLI = true;
+      results.claudeCmd = cmd;
+      break;
+    } catch {
+      // continua
+    }
+  }
+
+  return results;
+}
+
+export function printCheckResults(results) {
+  console.log(results.node
+    ? ui.ok(`Node.js ${process.version}`)
+    : ui.fail('Node.js < 18'));
+
+  console.log(results.git
+    ? ui.ok('Git instalado')
+    : ui.fail('Git não encontrado — instale em https://git-scm.com'));
+
+  console.log(results.claudeCLI
+    ? ui.ok('Claude Code CLI instalado')
+    : ui.warn('Claude Code CLI não encontrado — será instalado'));
+}

package/lib/install-claude.js

@@ -0,0 +1,23 @@
+import { execa } from 'execa';
+import ora from 'ora';
+import { ui } from './ui.js';
+
+export async function installClaudeCLI() {
+  const spinner = ora({
+    text: 'Instalando Claude Code CLI...',
+    color: 'yellow',
+  }).start();
+
+  try {
+    await execa('npm', ['install', '-g', '@anthropic-ai/claude-code'], {
+      stdio: 'pipe',
+    });
+    spinner.succeed(ui.ok('Claude Code CLI instalado'));
+    return true;
+  } catch (err) {
+    spinner.fail(ui.fail('Falha ao instalar Claude Code CLI'));
+    console.error(ui.dim('  Tente manualmente: npm i -g @anthropic-ai/claude-code'));
+    console.error(ui.dim(`  Erro: ${err.message}`));
+    return false;
+  }
+}

package/lib/launch.js

@@ -0,0 +1,41 @@
+import { execa } from 'execa';
+import path from 'path';
+import open from 'open';
+import { ui } from './ui.js';
+
+export async function launch(projectDir) {
+  const mcDir = path.join(projectDir, 'mission-control');
+  const serverPath = path.join(mcDir, 'server.js');
+
+  ui.nl();
+  ui.separator();
+  console.log(ui.gold('  🚀 INICIANDO MISSION CONTROL'));
+  ui.separator();
+  ui.nl();
+  console.log(ui.ok('Projeto configurado em: ' + projectDir));
+  console.log(ui.ok('Servidor: localhost:3001'));
+  ui.nl();
+  console.log(ui.dim('  Para iniciar novamente no futuro:'));
+  console.log(ui.dim(`  cd ${path.basename(projectDir)}/mission-control`));
+  console.log(ui.dim('  node server.js'));
+  ui.nl();
+
+  // Abrir browser após 2 segundos
+  setTimeout(async () => {
+    await open('http://localhost:3001');
+  }, 2000);
+
+  console.log(ui.gold('Iniciando servidor... (Ctrl+C para parar)\n'));
+
+  try {
+    await execa('node', [serverPath], {
+      cwd: mcDir,
+      stdio: 'inherit',
+    });
+  } catch (err) {
+    // 130 = Ctrl+C (SIGINT) — saída esperada
+    if (err.exitCode !== 130) {
+      console.error(ui.fail('Servidor encerrou com erro: ' + err.message));
+    }
+  }
+}

package/lib/main.js

@@ -0,0 +1,87 @@
+import path from 'path';
+import { prompt } from 'enquirer';
+import { ui } from './ui.js';
+import { checkEnvironment, printCheckResults } from './checks.js';
+import { installClaudeCLI } from './install-claude.js';
+import { authenticate } from './auth.js';
+import { setupSegundoCerebro } from './segundo-cerebro.js';
+import { setupGenieOS } from './setup.js';
+import { launch } from './launch.js';
+
+async function main() {
+  // Banner
+  ui.banner();
+  console.log(ui.dim('  Instalando seu time de agentes IA em alguns passos.\n'));
+
+  // ── STEP 1: Verificar ambiente ──
+  console.log(ui.step('1/5', 'Verificando ambiente...'));
+  const env = await checkEnvironment();
+  printCheckResults(env);
+
+  if (!env.git) {
+    console.log(ui.fail('\nGit é necessário. Instale em: https://git-scm.com'));
+    process.exit(1);
+  }
+
+  // ── STEP 2: Instalar Claude Code CLI ──
+  if (!env.claudeCLI) {
+    console.log(ui.step('2/5', 'Instalando Claude Code CLI...'));
+    const ok = await installClaudeCLI();
+    if (!ok) {
+      console.log(ui.warn('\nInstale manualmente e rode novamente:'));
+      console.log(ui.dim('  npm i -g @anthropic-ai/claude-code'));
+      console.log(ui.dim('  npx create-genia-mission-control'));
+      process.exit(1);
+    }
+  } else {
+    console.log(ui.step('2/5', 'Claude Code CLI ✅ (já instalado)'));
+  }
+
+  // ── STEP 3: Autenticação ──
+  console.log(ui.step('3/5', 'Autenticação com Claude'));
+  await authenticate();
+
+  // ── STEP 4a: Nome do projeto ──
+  ui.nl();
+  const { projectName } = await prompt({
+    type: 'input',
+    name: 'projectName',
+    message: 'Nome da pasta do projeto:',
+    initial: 'meu-projeto-genia',
+    validate: (v) => /^[a-z0-9\-_]+$/i.test(v) ? true : 'Use apenas letras, números e hífens',
+  });
+
+  const projectDir = path.join(process.cwd(), projectName);
+
+  // ── STEP 4b: Segundo Cérebro ──
+  console.log(ui.step('4/5', 'Segundo Cérebro — seu contexto persistente'));
+  const cerebroResult = await setupSegundoCerebro(projectDir);
+
+  // ── STEP 5: GEN.IA OS + Mission Control ──
+  console.log(ui.step('5/5', 'Instalando GEN.IA OS e Mission Control...'));
+  await setupGenieOS(projectDir, cerebroResult.businessDir);
+
+  // ── Resumo ──
+  ui.nl();
+  ui.separator();
+  console.log(ui.gold('  ✅ INSTALAÇÃO CONCLUÍDA'));
+  ui.separator();
+  ui.nl();
+  console.log(ui.ok('Projeto: ' + projectDir));
+  if (cerebroResult.repoUrl) {
+    console.log(ui.ok('Segundo Cérebro: ' + cerebroResult.repoUrl));
+  } else {
+    console.log(ui.ok('Segundo Cérebro: local (sem GitHub)'));
+    console.log(ui.dim('   Para conectar ao GitHub depois: veja .business/README.md'));
+  }
+  ui.nl();
+
+  // ── Launch ──
+  await launch(projectDir);
+}
+
+main().catch(err => {
+  console.error(ui.fail('\nErro inesperado: ' + err.message));
+  if (process.env.DEBUG) console.error(err.stack);
+  process.exit(1);
+});

package/lib/segundo-cerebro.js

@@ -0,0 +1,302 @@
+import { prompt } from 'enquirer';
+import { execa } from 'execa';
+import fs from 'fs-extra';
+import path from 'path';
+import fetch from 'node-fetch';
+import open from 'open';
+import ora from 'ora';
+import { ui } from './ui.js';
+
+const TEMPLATE_REPO = 'elidyizzy/segundo-cerebro-template';
+
+export async function setupSegundoCerebro(projectDir) {
+  ui.nl();
+  console.log(ui.gold('Segundo Cérebro — Seu contexto persistente'));
+  console.log(ui.dim('  Os agentes lerão isso em toda sessão para te conhecer.'));
+  ui.nl();
+
+  const { useGitHub } = await prompt({
+    type: 'confirm',
+    name: 'useGitHub',
+    message: 'Quer conectar o Segundo Cérebro ao GitHub? (persiste entre máquinas)',
+    initial: true,
+  });
+
+  if (!useGitHub) {
+    return await createLocalOnly(projectDir);
+  }
+
+  const { hasRepo } = await prompt({
+    type: 'confirm',
+    name: 'hasRepo',
+    message: 'Você já tem um repositório "segundo-cerebro" no GitHub?',
+    initial: false,
+  });
+
+  if (hasRepo) {
+    return await cloneExistingCerebro(projectDir);
+  } else {
+    return await createNewCerebro(projectDir);
+  }
+}
+
+// ── Caminho local (sem GitHub) ──────────────────────────────────────────────
+async function createLocalOnly(projectDir) {
+  ui.nl();
+  console.log(ui.info('Criando Segundo Cérebro localmente.'));
+  console.log(ui.dim('  Você pode conectar ao GitHub depois quando quiser.'));
+  ui.nl();
+
+  const answers = await prompt([
+    {
+      type: 'input',
+      name: 'name',
+      message: 'Seu nome:',
+      validate: (v) => v.length > 0 ? true : 'Obrigatório',
+    },
+    {
+      type: 'input',
+      name: 'empresa',
+      message: 'Nome da sua empresa:',
+      validate: (v) => v.length > 0 ? true : 'Obrigatório',
+    },
+    {
+      type: 'input',
+      name: 'cargo',
+      message: 'Seu cargo/role:',
+      initial: 'Fundador(a)',
+    },
+    {
+      type: 'input',
+      name: 'descricao',
+      message: 'Em uma frase: o que você faz?',
+      validate: (v) => v.length > 0 ? true : 'Obrigatório',
+    },
+  ]);
+
+  const businessDir = path.join(projectDir, '.business');
+  const spinner = ora('Criando Segundo Cérebro local...').start();
+
+  try {
+    await execa('git', ['clone', `https://github.com/${TEMPLATE_REPO}.git`, businessDir]);
+    await fs.remove(path.join(businessDir, '.git'));
+    await fillPlaceholders(businessDir, { ...answers, githubUser: '' });
+    spinner.succeed(ui.ok('Segundo Cérebro criado localmente'));
+  } catch {
+    spinner.warn(ui.warn('Criando estrutura mínima...'));
+    await createMinimalBusiness(businessDir, answers);
+  }
+
+  ui.nl();
+  console.log(ui.dim('  📁 Localização: ' + businessDir));
+  console.log(ui.dim('  ✏️  Edite OWNER.md e EMPRESA.md para personalizar.'));
+  console.log(ui.dim('  🔗 Para conectar ao GitHub depois: git init && git remote add origin <url>'));
+  ui.nl();
+
+  return { businessDir, repoUrl: null, isLocal: true };
+}
+
+// ── Clonar repo existente ───────────────────────────────────────────────────
+async function cloneExistingCerebro(projectDir) {
+  const { repoUrl } = await prompt({
+    type: 'input',
+    name: 'repoUrl',
+    message: 'URL do repositório (ex: https://github.com/seunome/segundo-cerebro):',
+    validate: (v) => v.includes('github.com') ? true : 'URL inválida',
+  });
+
+  const spinner = ora('Clonando Segundo Cérebro...').start();
+  const businessDir = path.join(projectDir, '.business');
+
+  try {
+    await execa('git', ['clone', repoUrl, businessDir]);
+    spinner.succeed(ui.ok('Segundo Cérebro conectado'));
+    return { businessDir, repoUrl };
+  } catch (err) {
+    spinner.fail(ui.fail('Erro ao clonar repositório'));
+    console.error(ui.dim('  Certifique-se de ter acesso ao repositório'));
+    console.error(ui.dim(`  Erro: ${err.message}`));
+    process.exit(1);
+  }
+}
+
+// ── Criar novo repo via API do GitHub ──────────────────────────────────────
+async function createNewCerebro(projectDir) {
+  console.log(ui.info('Vamos criar seu Segundo Cérebro no GitHub.'));
+  ui.nl();
+
+  const answers = await prompt([
+    {
+      type: 'input',
+      name: 'githubUser',
+      message: 'Seu usuário do GitHub:',
+      validate: (v) => v.length > 0 ? true : 'Obrigatório',
+    },
+    {
+      type: 'input',
+      name: 'name',
+      message: 'Seu nome completo:',
+      validate: (v) => v.length > 0 ? true : 'Obrigatório',
+    },
+    {
+      type: 'input',
+      name: 'empresa',
+      message: 'Nome da sua empresa:',
+      validate: (v) => v.length > 0 ? true : 'Obrigatório',
+    },
+    {
+      type: 'input',
+      name: 'cargo',
+      message: 'Seu cargo/role:',
+      initial: 'Fundador(a)',
+    },
+    {
+      type: 'input',
+      name: 'descricao',
+      message: 'Em uma frase: o que você faz?',
+      validate: (v) => v.length > 0 ? true : 'Obrigatório',
+    },
+    {
+      type: 'password',
+      name: 'githubToken',
+      message: 'GitHub Personal Access Token (para criar o repo privado):',
+      hint: 'Gere em: github.com/settings/tokens — permissão: repo',
+      validate: (v) => v.startsWith('ghp_') || v.startsWith('github_pat_')
+        ? true
+        : 'Token inválido (deve começar com ghp_ ou github_pat_)',
+    },
+  ]);
+
+  const spinner = ora('Criando repositório privado no GitHub...').start();
+
+  try {
+    // Criar repo a partir do template público
+    const createRes = await fetch(
+      `https://api.github.com/repos/${TEMPLATE_REPO}/generate`,
+      {
+        method: 'POST',
+        headers: {
+          'Authorization': `Bearer ${answers.githubToken}`,
+          'Accept': 'application/vnd.github+json',
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+          owner: answers.githubUser,
+          name: 'segundo-cerebro',
+          description: 'Meu contexto persistente para o GEN.IA Mission Control',
+          private: true,
+          include_all_branches: false,
+        }),
+      }
+    );
+
+    if (!createRes.ok) {
+      const err = await createRes.json();
+      throw new Error(err.message || 'Erro na API do GitHub');
+    }
+
+    const repo = await createRes.json();
+    spinner.succeed(ui.ok(`Repositório criado: ${repo.html_url}`));
+
+    // Clonar localmente com token na URL
+    const businessDir = path.join(projectDir, '.business');
+    const cloneSpinner = ora('Clonando para o projeto...').start();
+    const authUrl = repo.clone_url.replace('https://', `https://${answers.githubToken}@`);
+    await execa('git', ['clone', authUrl, businessDir]);
+    cloneSpinner.succeed(ui.ok('Segundo Cérebro clonado'));
+
+    // Substituir placeholders
+    const fillSpinner = ora('Preenchendo informações básicas...').start();
+    await fillPlaceholders(businessDir, answers);
+    fillSpinner.succeed(ui.ok('Informações básicas preenchidas'));
+
+    // Commit inicial
+    const commitSpinner = ora('Salvando no GitHub...').start();
+    await execa('git', ['add', '.'], { cwd: businessDir });
+    await execa('git', ['commit', '-m', 'feat: configuração inicial do segundo cérebro'], { cwd: businessDir });
+    await execa('git', ['push'], { cwd: businessDir });
+    commitSpinner.succeed(ui.ok('Segundo Cérebro salvo no GitHub'));
+
+    // Oferecer abrir no browser para completar
+    ui.nl();
+    console.log(ui.gold('📝 Complete seu Segundo Cérebro:'));
+    console.log(ui.dim(`   ${repo.html_url}`));
+    console.log(ui.dim('   Preencha OWNER.md e EMPRESA.md com seus dados reais.'));
+    ui.nl();
+
+    const { openBrowser } = await prompt({
+      type: 'confirm',
+      name: 'openBrowser',
+      message: 'Abrir no browser agora para completar?',
+      initial: true,
+    });
+
+    if (openBrowser) {
+      await open(repo.html_url);
+      await prompt({
+        type: 'input',
+        name: '_',
+        message: 'Pressione ENTER quando terminar de preencher...',
+      });
+
+      const pullSpinner = ora('Sincronizando alterações...').start();
+      try {
+        await execa('git', ['pull'], { cwd: businessDir });
+        pullSpinner.succeed(ui.ok('Segundo Cérebro sincronizado'));
+      } catch {
+        pullSpinner.warn(ui.warn('Não foi possível sincronizar — continue assim mesmo'));
+      }
+    }
+
+    return { businessDir, repoUrl: repo.html_url };
+
+  } catch (err) {
+    spinner.fail(ui.fail('Erro ao criar repositório'));
+    console.error(ui.dim(`  ${err.message}`));
+
+    // Fallback: criar .business/ local
+    console.log(ui.warn('Criando .business/ localmente (sem GitHub)...'));
+    const businessDir = path.join(projectDir, '.business');
+    await createMinimalBusiness(businessDir, answers);
+    return { businessDir, repoUrl: null };
+  }
+}
+
+// ── Helpers ─────────────────────────────────────────────────────────────────
+async function fillPlaceholders(dir, answers) {
+  const files = await fs.readdir(dir);
+  for (const file of files) {
+    if (!file.endsWith('.md')) continue;
+    const filePath = path.join(dir, file);
+    let content = await fs.readFile(filePath, 'utf8');
+    content = content
+      .replace(/\{\{SEU_NOME\}\}/g, answers.name)
+      .replace(/\{\{SUA_EMPRESA\}\}/g, answers.empresa)
+      .replace(/\{\{NOME_DA_EMPRESA\}\}/g, answers.empresa)
+      .replace(/\{\{SEU_CARGO\}\}/g, answers.cargo)
+      .replace(/\{\{DESCREVA_EM_2_FRASES_O_QUE_VOCE_FAZ\}\}/g, answers.descricao)
+      .replace(/\{\{CIDADE\}\}/g, 'Brasil');
+    await fs.writeFile(filePath, content);
+  }
+}
+
+async function createMinimalBusiness(dir, answers) {
+  await fs.ensureDir(dir);
+  await fs.ensureDir(path.join(dir, 'clientes'));
+  await fs.writeFile(
+    path.join(dir, 'OWNER.md'),
+    `# ${answers.name}\n\n${answers.descricao}\n\n- **Empresa:** ${answers.empresa}\n- **Cargo:** ${answers.cargo}\n`
+  );
+  await fs.writeFile(
+    path.join(dir, 'EMPRESA.md'),
+    `# ${answers.empresa}\n\n> Preencha este arquivo com o contexto da sua empresa.\n`
+  );
+  await fs.writeFile(
+    path.join(dir, 'PRIORIDADES.md'),
+    `# Prioridades\n\n> Atualize semanalmente.\n\n## Esta semana\n- [ ] \n`
+  );
+  await fs.writeFile(
+    path.join(dir, 'ACORDOS.md'),
+    `# Acordos\n\n- Nunca assumir — perguntar antes\n- Sempre confirmar antes de deletar ou fazer push\n- Português brasileiro\n- Commits em português\n`
+  );
+}

package/lib/setup.js

@@ -0,0 +1,46 @@
+import { execa } from 'execa';
+import fs from 'fs-extra';
+import path from 'path';
+import ora from 'ora';
+import { ui } from './ui.js';
+
+const GENIA_OS_REPO = 'https://github.com/elidyizzy/GENIA-SQUAD-OS.git';
+
+export async function setupGenieOS(projectDir, businessDir) {
+  await fs.ensureDir(projectDir);
+
+  // Clonar GENIA-SQUAD-OS
+  const spinner = ora('Clonando GEN.IA SQUAD OS...').start();
+  try {
+    await execa('git', ['clone', GENIA_OS_REPO, '.'], { cwd: projectDir });
+    spinner.succeed(ui.ok('GEN.IA SQUAD OS clonado'));
+  } catch (err) {
+    spinner.fail(ui.fail('Erro ao clonar GENIA-SQUAD-OS'));
+    throw err;
+  }
+
+  // Substituir .business/ do repo clonado pelo Segundo Cérebro do usuário
+  const defaultBusiness = path.join(projectDir, '.business');
+  if (businessDir !== defaultBusiness) {
+    const linkSpinner = ora('Conectando Segundo Cérebro...').start();
+    try {
+      await fs.remove(defaultBusiness);
+      await fs.copy(businessDir, defaultBusiness);
+      linkSpinner.succeed(ui.ok('Segundo Cérebro conectado ao projeto'));
+    } catch (err) {
+      linkSpinner.warn(ui.warn('Segundo Cérebro: mantendo cópia local'));
+    }
+  }
+
+  // Instalar dependências do Mission Control (se existir)
+  const mcDir = path.join(projectDir, 'mission-control');
+  if (await fs.pathExists(mcDir)) {
+    const depsSpinner = ora('Instalando dependências do Mission Control...').start();
+    try {
+      await execa('npm', ['install'], { cwd: mcDir });
+      depsSpinner.succeed(ui.ok('Dependências instaladas'));
+    } catch {
+      depsSpinner.warn(ui.warn('Instale manualmente: cd mission-control && npm install'));
+    }
+  }
+}

package/lib/ui.js

@@ -0,0 +1,34 @@
+import chalk from 'chalk';
+
+export const ui = {
+  // Cores do sistema
+  gold:    (t) => chalk.hex('#D4A843')(t),
+  green:   (t) => chalk.hex('#3EE07A')(t),
+  dim:     (t) => chalk.hex('#6A6460')(t),
+  red:     (t) => chalk.red(t),
+  blue:    (t) => chalk.hex('#5A9EF5')(t),
+
+  // Ícones
+  ok:      (t) => `${chalk.hex('#3EE07A')('✅')} ${t}`,
+  fail:    (t) => `${chalk.red('❌')} ${t}`,
+  warn:    (t) => `${chalk.hex('#F0B824')('⚠️')} ${t}`,
+  info:    (t) => `${chalk.hex('#5A9EF5')('ℹ')}  ${t}`,
+  step:    (n, t) => `\n${chalk.hex('#D4A843')(`[${n}]`)} ${chalk.white(t)}`,
+
+  // Banner
+  banner: () => {
+    console.log('\n' + chalk.hex('#D4A843')(`
+╔══════════════════════════════════════════════╗
+║                                              ║
+║   GEN.IA  MISSION  CONTROL                  ║
+║   Instalador v1.0                            ║
+║                                              ║
+║   github.com/elidyizzy/GENIA-SQUAD-OS        ║
+║                                              ║
+╚══════════════════════════════════════════════╝
+`));
+  },
+
+  separator: () => console.log(chalk.hex('#6A6460')('─'.repeat(48))),
+  nl: () => console.log(),
+};

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "create-genia-mission-control",
+  "version": "1.0.0",
+  "description": "Instalador do GEN.IA Mission Control — um comando para ter seu time de agentes IA funcionando",
+  "bin": "./bin/index.js",
+  "scripts": {
+    "test": "node bin/index.js"
+  },
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "enquirer": "^2.4.1",
+    "ora": "^8.0.1",
+    "execa": "^8.0.1",
+    "open": "^10.1.0",
+    "node-fetch": "^3.3.2",
+    "fs-extra": "^11.2.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "keywords": ["claude", "ai", "genia", "mission-control", "claude-code"],
+  "author": "Elidy Izidio <elidy@geniasquad.com.br>",
+  "license": "MIT",
+  "type": "module"
+}