vireum-spec-cli 0.1.0

package/dist/commands/setup.js

@@ -0,0 +1,436 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runSetup = runSetup;
+const chalk_1 = __importDefault(require("chalk"));
+const prompts_1 = require("@inquirer/prompts");
+const ora_1 = __importDefault(require("ora"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+async function runSetup() {
+    console.log(chalk_1.default.hex('#2D7DD2').bold('\n  Vireum Spec — Setup\n'));
+    console.log(chalk_1.default.gray('  Configure a stack e o protocolo da IA para este projeto\n'));
+    const specDir = path.join(process.cwd(), '.spec');
+    const vireumDir = path.join(process.cwd(), '.vireum');
+    const cursorDir = path.join(process.cwd(), '.cursor', 'rules');
+    if (!fs.existsSync(path.join(specDir, 'briefing.md'))) {
+        console.log(chalk_1.default.red('\n❌ briefing.md não encontrado.'));
+        console.log(chalk_1.default.gray('   Execute primeiro: ') + chalk_1.default.white('vireum-spec init\n'));
+        process.exit(1);
+    }
+    if (!fs.existsSync(path.join(specDir, 'INDEX.md'))) {
+        console.log(chalk_1.default.red('\n❌ Spec não gerado ainda.'));
+        console.log(chalk_1.default.gray('   Execute primeiro: ') + chalk_1.default.white('vireum-spec distill\n'));
+        process.exit(1);
+    }
+    // ── Stack ──────────────────────────────────────────────────────────────────
+    console.log(chalk_1.default.hex('#2D7DD2').bold('⚙️  Stack do Projeto\n'));
+    const stack = {
+        frontend: await (0, prompts_1.select)({
+            message: 'Frontend:',
+            choices: [
+                { value: 'Next.js' }, { value: 'React' }, { value: 'Vue' },
+                { value: 'Nuxt' }, { value: 'Outro' }, { value: 'Nenhum' },
+            ],
+        }),
+        backend: await (0, prompts_1.select)({
+            message: 'Backend:',
+            choices: [
+                { value: 'Node.js + Express' }, { value: 'Node.js + Fastify' },
+                { value: 'NestJS' }, { value: 'Python + FastAPI' },
+                { value: 'Outro' }, { value: 'Nenhum' },
+            ],
+        }),
+        banco: await (0, prompts_1.select)({
+            message: 'Banco de dados:',
+            choices: [
+                { value: 'PostgreSQL' }, { value: 'MySQL' },
+                { value: 'SQLite' }, { value: 'MongoDB' }, { value: 'Outro' },
+            ],
+        }),
+        orm: await (0, prompts_1.select)({
+            message: 'ORM / Query Builder:',
+            choices: [
+                { value: 'Prisma' }, { value: 'TypeORM' }, { value: 'Drizzle' },
+                { value: 'Sequelize' }, { value: 'Nenhum' }, { value: 'Outro' },
+            ],
+        }),
+        cache: await (0, prompts_1.select)({
+            message: 'Cache / Filas:',
+            choices: [
+                { value: 'Redis + BullMQ' }, { value: 'Redis simples' },
+                { value: 'Nenhum' }, { value: 'Outro' },
+            ],
+        }),
+        auth: await (0, prompts_1.select)({
+            message: 'Autenticação:',
+            choices: [
+                { value: 'JWT + Refresh Token' }, { value: 'NextAuth' },
+                { value: 'Supabase Auth' }, { value: 'Clerk' }, { value: 'Outro' },
+            ],
+        }),
+        multiTenant: await (0, prompts_1.confirm)({ message: 'Projeto multi-tenant?', default: false }),
+    };
+    stack.tenantStrategy = stack.multiTenant
+        ? await (0, prompts_1.select)({
+            message: 'Estratégia de multi-tenancy:',
+            choices: [
+                { value: 'Row-level (tenantId)' },
+                { value: 'Schema separado por tenant' },
+                { value: 'Banco separado por tenant' },
+            ],
+        })
+        : '';
+    // ── Infra ──────────────────────────────────────────────────────────────────
+    console.log(chalk_1.default.hex('#2D7DD2').bold('\n🏗️  Infraestrutura\n'));
+    const infra = {
+        hospedagem: await (0, prompts_1.select)({
+            message: 'Hospedagem:',
+            choices: [
+                { value: 'DigitalOcean' }, { value: 'Hetzner' }, { value: 'AWS' },
+                { value: 'Vercel + Railway' }, { value: 'Outro' },
+            ],
+        }),
+        containerizacao: await (0, prompts_1.select)({
+            message: 'Containerização:',
+            choices: [
+                { value: 'Docker + Docker Compose' },
+                { value: 'Docker simples' },
+                { value: 'Nenhum' },
+            ],
+        }),
+        cicd: await (0, prompts_1.confirm)({ message: 'CI/CD ativo desde o início?', default: false }),
+    };
+    infra.cicdFerramenta = infra.cicd
+        ? await (0, prompts_1.select)({
+            message: 'Ferramenta de CI/CD:',
+            choices: [
+                { value: 'GitHub Actions' }, { value: 'GitLab CI' }, { value: 'Outro' },
+            ],
+        })
+        : '';
+    // ── MCPs ───────────────────────────────────────────────────────────────────
+    console.log(chalk_1.default.hex('#2D7DD2').bold('\n🔌 MCPs — Ferramentas da IA\n'));
+    const mcpsSelecionados = await (0, prompts_1.checkbox)({
+        message: 'Selecione os MCPs para este projeto:',
+        choices: [
+            { name: 'github     — PRs, issues, branches', value: 'github', checked: true },
+            { name: 'database   — consultar banco em dev', value: 'database', checked: true },
+            { name: 'browser    — testar endpoints e fluxos', value: 'browser', checked: true },
+            { name: 'puppeteer  — testes de UI', value: 'puppeteer', checked: false },
+            { name: 'docker     — gerenciar containers', value: 'docker', checked: false },
+            { name: 'redis      — inspecionar cache e filas', value: 'redis', checked: false },
+        ],
+    });
+    // ── Gerar arquivos ─────────────────────────────────────────────────────────
+    console.log('');
+    const projeto = extrairProjeto(path.join(specDir, 'INDEX.md'));
+    const dados = { stack, infra, mcps: mcpsSelecionados, projeto };
+    for (const dir of [vireumDir, cursorDir]) {
+        if (!fs.existsSync(dir))
+            fs.mkdirSync(dir, { recursive: true });
+    }
+    const arquivos = [
+        { path: path.join(specDir, 'architecture.md'), conteudo: gerarArchitecture(dados), msg: 'Atualizando architecture.md...' },
+        { path: path.join(specDir, 'mcp-setup.md'), conteudo: gerarMcpSetup(dados), msg: 'Gerando mcp-setup.md...' },
+        { path: path.join(vireumDir, 'rules.md'), conteudo: gerarRulesGlobal(), msg: 'Gerando .vireum/rules.md...' },
+        { path: path.join(vireumDir, 'mcps.md'), conteudo: gerarMcpsGlobal(dados), msg: 'Gerando .vireum/mcps.md...' },
+        { path: path.join(process.cwd(), 'CLAUDE.md'), conteudo: gerarClaudeMd(dados), msg: 'Gerando CLAUDE.md...' },
+        { path: path.join(process.cwd(), 'AGENTS.md'), conteudo: gerarAgentsMd(dados), msg: 'Gerando AGENTS.md...' },
+        { path: path.join(cursorDir, 'vireum.mdc'), conteudo: gerarCursorRules(dados), msg: 'Gerando .cursor/rules/vireum.mdc...' },
+    ];
+    for (const arq of arquivos) {
+        const s = (0, ora_1.default)(arq.msg).start();
+        await sleep(400);
+        fs.writeFileSync(arq.path, arq.conteudo, 'utf-8');
+        s.succeed(path.relative(process.cwd(), arq.path));
+    }
+    console.log(chalk_1.default.green.bold('\n✅ Setup concluído!\n'));
+    console.log(chalk_1.default.gray('  Protocolo da IA configurado para Claude Code, Codex CLI e Cursor\n'));
+    console.log(chalk_1.default.gray('  Próximo passo: ') + chalk_1.default.white('vireum-spec prioritize') + chalk_1.default.gray(' para classificar as features\n'));
+}
+// ─── HELPERS ──────────────────────────────────────────────────────────────────
+function extrairProjeto(indexPath) {
+    try {
+        const content = fs.readFileSync(indexPath, 'utf-8');
+        const match = content.match(/# INDEX — (.+)/);
+        return match ? match[1].trim() : 'projeto';
+    }
+    catch {
+        return 'projeto';
+    }
+}
+function sleep(ms) {
+    return new Promise(r => setTimeout(r, ms));
+}
+// ─── GERADORES ────────────────────────────────────────────────────────────────
+function gerarArchitecture(d) {
+    const { stack, infra, mcps, projeto } = d;
+    const tenant = stack.multiTenant
+        ? `\n## Multi-Tenancy\n- Estratégia: ${stack.tenantStrategy}\n- Nunca fazer query sem filtro de tenantId`
+        : '';
+    return `# Architecture — ${projeto}
+
+> Atualizado via vireum-spec setup
+> A IA deve registrar aqui cada decisão técnica relevante
+
+## Stack
+- Frontend: ${stack.frontend}
+- Backend: ${stack.backend}
+- Banco de dados: ${stack.banco}
+- ORM: ${stack.orm}
+- Cache / Filas: ${stack.cache}
+- Auth: ${stack.auth}
+${tenant}
+
+## Infraestrutura
+- Hospedagem: ${infra.hospedagem}
+- Containerização: ${infra.containerizacao}
+- CI/CD: ${infra.cicd ? infra.cicdFerramenta : 'Não configurado'}
+
+## MCPs Ativos
+${mcps.map((m) => `- ${m}`).join('\n')}
+
+## Decisões Arquiteturais
+> A IA deve registrar aqui cada decisão técnica com justificativa
+
+| Data | Decisão | Alternativas descartadas | Motivo |
+|------|---------|--------------------------|--------|
+|      |         |                          |        |
+`;
+}
+function gerarMcpSetup(d) {
+    const mcpInfo = {
+        github: 'https://github.com/modelcontextprotocol/servers/tree/main/src/github',
+        database: 'https://github.com/modelcontextprotocol/servers/tree/main/src/postgres',
+        browser: 'https://github.com/modelcontextprotocol/servers/tree/main/src/puppeteer',
+        puppeteer: 'https://github.com/modelcontextprotocol/servers/tree/main/src/puppeteer',
+        docker: 'https://github.com/modelcontextprotocol/servers',
+        redis: 'https://github.com/modelcontextprotocol/servers',
+    };
+    const lista = d.mcps.map((m) => `### ${m}\n- Instalação: ${mcpInfo[m] || 'Ver documentação oficial'}\n- Credenciais: configurar manualmente após instalação`).join('\n\n');
+    return `# MCP Setup — ${d.projeto}
+
+> MCPs necessários para este projeto.
+> Instalação é feita manualmente — o framework não acessa credenciais.
+
+## MCPs do Projeto
+${lista}
+
+## Como instalar
+1. Acesse o link de cada MCP acima
+2. Siga as instruções de instalação
+3. Configure as credenciais manualmente no seu cliente (Claude Code / Cursor)
+4. Execute: vireum-spec verify-mcps (em breve)
+`;
+}
+function gerarRulesGlobal() {
+    return `# Rules — Global Vireum
+
+> Regras globais que se aplicam a TODOS os projetos Vireum.
+> Nunca editar por projeto. Em conflito com .spec/rules.md, estas prevalecem.
+
+## Regras de Escopo
+- Nunca implementar funcionalidade fora do requirements.md sem criar task [PENDING]
+- Nunca puxar task do backlog para active sem validação humana explícita
+- Sempre avisar escopo creep antes de implementar — parar e perguntar
+
+## Regras de Spec
+- Nunca marcar task como done sem validar os critérios de aceitação
+- Nunca tomar decisão de arquitetura sem registrar em architecture.md com justificativa
+- Sempre definir contrato de interface antes de implementar features com frontend e backend
+- Ao identificar risco novo, adicionar em risks.md antes de continuar
+
+## Regras de Contexto
+- Sempre ler INDEX.md no início de cada sessão
+- Carregar outros arquivos de spec apenas quando a task exigir
+- Registrar decisões relevantes em changelog.md com data
+
+## Regras de Tasks
+- Bugs viram hotfix com tag [H] — nunca são tratados como tasks normais
+- Demandas novas do cliente viram [PENDING] no backlog — nunca vão direto para active
+- Task só é done quando critérios de aceitação estão validados
+
+## Nunca
+- Implementar sem ler o spec primeiro
+- Tomar decisão de lib ou stack sem documentar o porquê
+- Responder dúvida de escopo sem consultar requirements.md
+- Comunicar diretamente com o cliente — isso é papel do dev
+`;
+}
+function gerarMcpsGlobal(d) {
+    return `# MCPs — Global Vireum
+
+> MCPs padrão disponíveis nos projetos Vireum.
+> MCPs ativos por projeto estão em .spec/architecture.md
+
+## Stack Padrão
+- filesystem  — leitura e escrita no projeto (nativo)
+- github      — PRs, issues, branches referenciando tasks
+- database    — validar schema e dados em desenvolvimento
+- browser     — testar endpoints e validar fluxos
+- puppeteer   — testes de jornada de UI
+- docker      — gerenciar containers em desenvolvimento
+- redis       — inspecionar cache e filas (quando aplicável)
+
+## MCPs Ativos Neste Projeto
+${d.mcps.map((m) => `- ${m}`).join('\n')}
+
+## Quando usar cada MCP
+- Task concluída → github: criar PR referenciando a task
+- Bug identificado → github: abrir issue com contexto
+- Decisão de schema → database: validar antes de implementar
+- Feature implementada → browser: testar endpoint ou fluxo
+- Jornada de UI → puppeteer: validar fluxo completo
+`;
+}
+function gerarClaudeMd(d) {
+    const { projeto, stack, mcps } = d;
+    const tenant = stack.multiTenant
+        ? '\n- NUNCA fazer query sem filtro de tenantId — projeto multi-tenant' : '';
+    return `# ${projeto} — Vireum Spec Protocol
+
+> Este projeto usa Spec Driven Development pela Vireum Desenvolvimento.
+> Leia este arquivo completamente antes de qualquer ação.
+
+## Início de cada sessão
+1. Leia \`.spec/INDEX.md\` — estado atual do projeto
+2. Identifique o modo da sessão pela solicitação do dev
+3. Carregue arquivos adicionais apenas se a task exigir
+
+## Modos de operação
+
+### Modo 1 — Implementar
+Acionado por: "desenvolve", "implementa", "cria", + nome de task
+1. Leia \`.spec/tasks/active.md\`
+2. Leia \`.spec/requirements.md\` para contexto da feature
+3. Implemente seguindo os critérios de aceitação da task
+4. Ao concluir: marque como done, mova para \`tasks/done.md\`, atualize \`INDEX.md\`
+5. Se decisão arquitetural tomada: registre em \`architecture.md\`
+
+### Modo 2 — Bug
+Acionado por: "erro", "bug", "quebrou", "não funciona"
+1. Crie hotfix em \`tasks/active.md\` com tag [H] e prioridade crítica
+2. Identifique e resolva a causa raiz
+3. Registre causa raiz em \`changelog.md\`
+4. Verifique se o bug afeta outras tasks em \`tasks/active.md\`
+
+### Modo 3 — Nova demanda
+Acionado por: "cliente pediu", "adiciona", "quero incluir" (fora do spec)
+1. Verifique se já existe em \`.spec/requirements.md\`
+2. Se não existir: crie task com tag [PENDING] em \`tasks/backlog.md\`
+3. Informe o impacto estimado e aguarde decisão do dev
+4. NUNCA implemente demanda nova sem aprovação explícita
+
+### Modo 4 — Dúvida de escopo
+Acionado por: "como deve funcionar", "o que foi combinado", "qual o comportamento"
+1. Leia \`.spec/requirements.md\`
+2. Responda com base no spec — não invente comportamento
+
+## Regras globais
+Leia \`.vireum/rules.md\` — aplicam-se a todas as sessões.
+
+## Regras do projeto
+Leia \`.spec/rules.md\` — regras específicas deste projeto.
+
+## Stack
+- Frontend: ${stack.frontend}
+- Backend: ${stack.backend}
+- Banco: ${stack.banco}
+- Auth: ${stack.auth}${tenant}
+
+## MCPs ativos
+${mcps.map((m) => `- ${m}`).join('\n')}
+
+## Alertas
+- Escopo creep: se a solicitação não está em requirements.md → PARAR e avisar
+- Decisão de lib nova: registrar em architecture.md antes de usar
+- Risco identificado: adicionar em risks.md antes de continuar
+`;
+}
+function gerarAgentsMd(d) {
+    return `# ${d.projeto} — Vireum Spec Protocol (Codex CLI / Agents)
+
+> Mesmo protocolo do CLAUDE.md adaptado para Codex CLI e outros agentes.
+> Leia CLAUDE.md para o protocolo completo.
+
+## Início de cada sessão
+1. Leia \`.spec/INDEX.md\`
+2. Identifique o modo pela solicitação
+3. Siga o protocolo em CLAUDE.md
+
+## Regras globais
+Ver \`.vireum/rules.md\`
+
+## Regras do projeto  
+Ver \`.spec/rules.md\`
+
+## Stack
+- Frontend: ${d.stack.frontend}
+- Backend: ${d.stack.backend}
+- Banco: ${d.stack.banco}
+`;
+}
+function gerarCursorRules(d) {
+    return `---
+description: Vireum Spec Protocol — ${d.projeto}
+globs: ["**/*"]
+alwaysApply: true
+---
+
+# Vireum Spec Protocol
+
+Este projeto usa Spec Driven Development pela Vireum Desenvolvimento.
+
+## Início de sessão
+- Sempre leia \`.spec/INDEX.md\` primeiro
+- Carregue outros arquivos de spec apenas quando necessário
+
+## Modos
+- Implementar → leia tasks/active.md, siga critérios de aceitação
+- Bug → crie hotfix [H] em active.md, registre causa raiz em changelog.md  
+- Nova demanda → crie [PENDING] em backlog.md, aguarde aprovação
+- Dúvida de escopo → consulte requirements.md
+
+## Regras
+- Ver \`.vireum/rules.md\` — regras globais
+- Ver \`.spec/rules.md\` — regras do projeto
+- Nunca implementar fora do spec sem [PENDING] aprovado
+- Nunca marcar done sem critérios validados
+`;
+}

package/dist/commands/skills.js

@@ -0,0 +1,147 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runSkills = runSkills;
+const chalk_1 = __importDefault(require("chalk"));
+const prompts_1 = require("@inquirer/prompts");
+const ora_1 = __importDefault(require("ora"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const SKILLS = [
+    'task-implement',
+    'bug-fix',
+    'new-demand',
+    'spec-update',
+    'contract-first',
+    'scope-check',
+];
+async function runSkills() {
+    console.log(chalk_1.default.hex('#2D7DD2').bold('\n  Vireum Spec — Skills\n'));
+    console.log(chalk_1.default.gray('  Instala as skills do framework no seu cliente de IA\n'));
+    const cliente = await (0, prompts_1.select)({
+        message: 'Instalar skills para qual cliente:',
+        choices: [
+            { name: 'Claude Code  — ~/.claude/skills/', value: 'claude' },
+            { name: 'Cursor       — .cursor/rules/ (no projeto)', value: 'cursor' },
+            { name: 'Codex CLI    — ~/.codex/skills/', value: 'codex' },
+            { name: 'Todos', value: 'todos' },
+        ],
+    });
+    console.log('');
+    if (cliente === 'claude' || cliente === 'todos') {
+        await instalarClaudeCode();
+    }
+    if (cliente === 'cursor' || cliente === 'todos') {
+        await instalarCursor();
+    }
+    if (cliente === 'codex' || cliente === 'todos') {
+        await instalarCodex();
+    }
+    console.log(chalk_1.default.green.bold('\n✅ Skills instaladas!\n'));
+    console.log(chalk_1.default.gray('  A IA agora conhece o protocolo Vireum para tarefas específicas\n'));
+}
+// ─── INSTALADORES ─────────────────────────────────────────────────────────────
+async function instalarClaudeCode() {
+    console.log(chalk_1.default.white.bold('  Claude Code\n'));
+    const skillsDir = path.join(os.homedir(), '.claude', 'skills', 'vireum');
+    if (!fs.existsSync(skillsDir)) {
+        fs.mkdirSync(skillsDir, { recursive: true });
+    }
+    for (const skill of SKILLS) {
+        const s = (0, ora_1.default)(`  Instalando ${skill}...`).start();
+        await sleep(300);
+        const origem = path.join(__dirname, '..', 'skills', `${skill}.md`);
+        const destino = path.join(skillsDir, `${skill}.md`);
+        if (fs.existsSync(origem)) {
+            fs.copyFileSync(origem, destino);
+            s.succeed(`  ${skill}.md → ~/.claude/skills/vireum/`);
+        }
+        else {
+            s.warn(`  ${skill}.md não encontrado no framework`);
+        }
+    }
+    console.log('');
+}
+async function instalarCursor() {
+    console.log(chalk_1.default.white.bold('  Cursor\n'));
+    const cursorDir = path.join(process.cwd(), '.cursor', 'rules', 'skills');
+    if (!fs.existsSync(cursorDir)) {
+        fs.mkdirSync(cursorDir, { recursive: true });
+    }
+    for (const skill of SKILLS) {
+        const s = (0, ora_1.default)(`  Instalando ${skill}...`).start();
+        await sleep(300);
+        const origem = path.join(__dirname, '..', 'skills', `${skill}.md`);
+        const destino = path.join(cursorDir, `${skill}.mdc`);
+        if (fs.existsSync(origem)) {
+            const conteudo = fs.readFileSync(origem, 'utf-8');
+            const comHeader = `---\ndescription: Vireum Skill — ${skill}\nglobs: ["**/*"]\nalwaysApply: false\n---\n\n${conteudo}`;
+            fs.writeFileSync(destino, comHeader, 'utf-8');
+            s.succeed(`  ${skill}.mdc → .cursor/rules/skills/`);
+        }
+        else {
+            s.warn(`  ${skill}.md não encontrado no framework`);
+        }
+    }
+    console.log('');
+}
+async function instalarCodex() {
+    console.log(chalk_1.default.white.bold('  Codex CLI\n'));
+    const skillsDir = path.join(os.homedir(), '.codex', 'skills', 'vireum');
+    if (!fs.existsSync(skillsDir)) {
+        fs.mkdirSync(skillsDir, { recursive: true });
+    }
+    for (const skill of SKILLS) {
+        const s = (0, ora_1.default)(`  Instalando ${skill}...`).start();
+        await sleep(300);
+        const origem = path.join(__dirname, '..', 'skills', `${skill}.md`);
+        const destino = path.join(skillsDir, `${skill}.md`);
+        if (fs.existsSync(origem)) {
+            fs.copyFileSync(origem, destino);
+            s.succeed(`  ${skill}.md → ~/.codex/skills/vireum/`);
+        }
+        else {
+            s.warn(`  ${skill}.md não encontrado no framework`);
+        }
+    }
+    console.log('');
+}
+function sleep(ms) {
+    return new Promise(r => setTimeout(r, ms));
+}