rook-cli 1.1.0 → 1.2.1

package/README.md

@@ -40,6 +40,53 @@ node bin/rook.js config
 node bin/rook.js add
 ```
 
+## Modo Headless (Automação / CI)
+
+Para rodar os comandos sem interação (útil para scripts ou MCP), utilize as flags adicionais:
+
+```bash
+# Adicionar componente/kit diretamente e sobrescrever conflitos
+rook add --type componente --name whatsapp-float --force
+
+# Gerar scaffold de arquivos Liquid diretamente
+rook generate hero-banner --type section --yes
+```
+
+## Integração com IA (MCP Server)
+
+O Rook CLI expõe todas as suas funcionalidades como ferramentas (*tools*) através do protocolo **Model Context Protocol (MCP)**. Isso permite que Inteligências Artificiais como Claude Desktop e Cursor instalem componentes e gerem arquivos no seu projeto automaticamente.
+
+Existem duas formas de configurar o servidor MCP dependendo de como você instalou o pacote:
+
+### Opção 1: Usando `npx` (Recomendada)
+Ideal se o pacote for instalado remotamente via NPM. O npx garante que a IA sempre fará o bypass do PATH sem problemas:
+
+**Em `claude_desktop_config.json` ou `.cursor/mcp.json`:**
+```json
+{
+  "mcpServers": {
+    "rook-cli": {
+      "command": "npx",
+      "args": ["-y", "-q", "--package", "rook-cli", "rook-mcp"]
+    }
+  }
+}
+```
+
+### Opção 2: Instalando globalmente (`npm install -g rook-cli`)
+Se você instalou o CLI como pacote global no seu sistema, o comando `rook-mcp` estará disponível nativamente.
+
+```json
+{
+  "mcpServers": {
+    "rook-cli": {
+      "command": "rook-mcp",
+      "args": []
+    }
+  }
+}
+```
+
 ## Estrutura do Projeto
 
 ```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rook-cli",
-  "version": "1.1.0",
+  "version": "1.2.1",
   "description": "CLI para instalar componentes Shopify",
   "repository": {
     "type": "git",
@@ -8,7 +8,8 @@
   },
   "type": "module",
   "bin": {
-    "rook": "bin/rook.js"
+    "rook": "bin/rook.js",
+    "rook-mcp": "src/mcp/server.js"
   },
   "files": [
     "bin",
@@ -16,6 +17,7 @@
   ],
   "scripts": {
     "start": "node bin/rook.js",
+    "mcp": "node src/mcp/server.js",
     "test": "echo \"No tests yet\" && exit 0"
   },
   "keywords": [
@@ -28,10 +30,12 @@
   "license": "ISC",
   "dependencies": {
     "@inquirer/prompts": "^8.3.0",
+    "@modelcontextprotocol/sdk": "^1.27.1",
     "commander": "^14.0.3",
     "dotenv": "^17.3.1",
     "fs-extra": "^11.3.3",
     "picocolors": "^1.1.1",
-    "tiged": "^2.12.7"
+    "tiged": "^2.12.7",
+    "zod": "^4.3.6"
   }
 }

package/src/app.js

@@ -74,12 +74,16 @@ export class App {
             .version('1.0.1');
 
         // Comando: rook add
+        // Flags de headless mode: --type, --name, --force
         this.programa
             .command('add')
             .description('Adiciona kits ou componentes ao tema Shopify atual')
-            .action(async () => {
+            .option('--type <tipo>', 'Tipo de instalação: "kit" ou "componente"')
+            .option('--name <nome>', 'Nome do kit ou componente a instalar')
+            .option('--force', 'Sobrescreve arquivos existentes sem perguntar')
+            .action(async (opcoes) => {
                 this.logger.banner();
-                await this.addCommand.executar();
+                await this.addCommand.executar(opcoes);
             });
 
         // Comando: rook config
@@ -92,13 +96,16 @@ export class App {
             });
 
         // Comando: rook generate [nome-do-componente]
+        // Flags de headless mode: --type, --yes
         this.programa
             .command('generate [nome]')
             .alias('g')
             .description('Gera scaffold de componentes Shopify (sections, blocks, snippets, assets)')
-            .action(async (nome) => {
+            .option('--type <tipo>', 'Tipo de componente: section, block, snippet, controller')
+            .option('--yes', 'Pula confirmações e sobrescreve arquivos existentes')
+            .action(async (nome, opcoes) => {
                 this.logger.banner();
-                await this.generateCommand.executar(nome);
+                await this.generateCommand.executar(nome, opcoes);
             });
 
         // Comando padrão (sem argumentos) — abre o menu interativo

package/src/commands/AddCommand.js

@@ -34,18 +34,32 @@ export class AddCommand {
 
     /**
      * Executa o fluxo principal do comando "add".
+     * 
+     * Suporta dois modos:
+     * - Interativo (padrão): exibe menus para o usuário
+     * - Headless (com flags): executa direto, sem prompts (para uso com MCP/IA)
+     * 
+     * @param {Object} [opcoes={}] - Opções passadas via flags do Commander
+     * @param {string} [opcoes.type] - Tipo de instalação ("kit" ou "componente")
+     * @param {string} [opcoes.name] - Nome do kit ou componente
+     * @param {boolean} [opcoes.force] - Sobrescreve sem perguntar
      * @returns {Promise<void>}
      */
-    async executar() {
+    async executar(opcoes = {}) {
         try {
-            // 1. Menu principal
-            const tipoInstalacao = await this.promptUI.menuPrincipal();
+            // Modo headless: se --force foi passado, configura o ConflictResolver
+            if (opcoes.force) {
+                this.fileMapper.conflictResolver?.definirDecisaoGlobal?.(true);
+            }
+
+            // 1. Determina o tipo (flag ou menu interativo)
+            const tipoInstalacao = opcoes.type || await this.promptUI.menuPrincipal();
 
             // 2. Delega para o fluxo correto
             if (tipoInstalacao === 'kit') {
-                await this._instalarKit();
+                await this._instalarKit(opcoes.name);
             } else {
-                await this._instalarComponentes();
+                await this._instalarComponentes(opcoes.name);
             }
 
         } catch (erro) {
@@ -63,13 +77,14 @@ export class AddCommand {
      * 
      * Segue o padrão descrito no PRD (Seção 5.3):
      * 1. Lista kits disponíveis (com dados do kit.json)
-     * 2. Usuário seleciona o kit
+     * 2. Usuário seleciona o kit (ou recebe via flag headless)
      * 3. Instala cada componente referenciado no manifesto
      * 4. Instala os arquivos locais exclusivos do kit
      * 
+     * @param {string} [nomeKit] - Nome do kit (modo headless). Se omitido, exibe menu.
      * @private
      */
-    async _instalarKit() {
+    async _instalarKit(nomeKit) {
         // 1. Lista kits disponíveis (já enriquecidos com dados do kit.json)
         const kits = await this.githubService.listarKits();
 
@@ -78,8 +93,17 @@ export class AddCommand {
             return;
         }
 
-        // 2. Usuário seleciona o kit
-        const kitSelecionado = await this.promptUI.selecionarKit(kits);
+        // 2. Seleciona o kit (headless ou interativo)
+        let kitSelecionado;
+        if (nomeKit) {
+            kitSelecionado = kits.find(k => k.slug === nomeKit || k.nome === nomeKit);
+            if (!kitSelecionado) {
+                this.logger.erro(`Kit "${nomeKit}" não encontrado.`);
+                return;
+            }
+        } else {
+            kitSelecionado = await this.promptUI.selecionarKit(kits);
+        }
 
         this.logger.destaque(`\n📥 Instalando kit: ${kitSelecionado.nome}\n`);
 
@@ -132,12 +156,26 @@ export class AddCommand {
 
     /**
      * Fluxo de instalação de componentes individuais.
+     * 
+     * @param {string} [nomeComponente] - Nome do componente (modo headless). Se omitido, exibe menu.
      * @private
      */
-    async _instalarComponentes() {
+    async _instalarComponentes(nomeComponente) {
         // Lista componentes disponíveis
         const componentes = await this.githubService.listarComponentes();
-        const selecionados = await this.promptUI.selecionarComponentes(componentes);
+
+        let selecionados;
+        if (nomeComponente) {
+            // Modo headless: busca pelo nome diretamente
+            const encontrado = componentes.find(c => c.nome === nomeComponente);
+            if (!encontrado) {
+                this.logger.erro(`Componente "${nomeComponente}" não encontrado no repositório.`);
+                return;
+            }
+            selecionados = [encontrado];
+        } else {
+            selecionados = await this.promptUI.selecionarComponentes(componentes);
+        }
 
         this.logger.destaque(`\n📥 Instalando ${selecionados.length} componente(s)...\n`);
 

package/src/commands/GenerateCommand.js

@@ -35,11 +35,23 @@ export class GenerateCommand {
     /**
      * Executa o fluxo principal do comando "generate".
      * 
+     * Suporta dois modos:
+     * - Interativo (padrão): pergunta nome e tipos ao usuário
+     * - Headless (com flags): executa direto, sem prompts (para uso com MCP/IA)
+     * 
      * @param {string} [nomeComponente] - Nome passado como argumento CLI (opcional)
+     * @param {Object} [opcoes={}] - Opções passadas via flags do Commander
+     * @param {string} [opcoes.type] - Tipo de componente (pula multi-select)
+     * @param {boolean} [opcoes.yes] - Sobrescreve arquivos sem perguntar
      * @returns {Promise<void>}
      */
-    async executar(nomeComponente) {
+    async executar(nomeComponente, opcoes = {}) {
         try {
+            // Modo headless: se --yes foi passado, sobrescreve tudo
+            if (opcoes.yes) {
+                this.conflictResolver.definirDecisaoGlobal(true);
+            }
+
             // 1. Se o nome não veio como argumento, pergunta ao usuário
             const nome = nomeComponente || await this.promptUI.perguntarNomeComponente();
 
@@ -53,8 +65,23 @@ export class GenerateCommand {
 
             this.logger.destaque(`\n🔧 Gerando componente: ${names.PascalName} (${names.kebabName})\n`);
 
-            // 3. Pergunta quais tipos gerar
-            const tiposSelecionados = await this.promptUI.selecionarTiposGerador();
+            // 3. Determina os tipos (flag headless ou multi-select interativo)
+            let tiposSelecionados;
+            if (opcoes.type) {
+                // Headless: aceita tipo único ou múltiplos separados por vírgula
+                tiposSelecionados = opcoes.type.split(',').map(t => t.trim());
+
+                // Valida tipos
+                const tiposValidos = this.scaffoldService.getAvailableTypes();
+                for (const tipo of tiposSelecionados) {
+                    if (!tiposValidos.includes(tipo)) {
+                        this.logger.erro(`Tipo inválido: "${tipo}". Tipos válidos: ${tiposValidos.join(', ')}`);
+                        return;
+                    }
+                }
+            } else {
+                tiposSelecionados = await this.promptUI.selecionarTiposGerador();
+            }
 
             if (tiposSelecionados.length === 0) {
                 this.logger.aviso('Nenhum tipo selecionado. Operação cancelada.');
@@ -68,8 +95,10 @@ export class GenerateCommand {
             const diretorioAtual = process.cwd();
             let totalGravados = 0;
 
-            // Reseta decisões anteriores do ConflictResolver
-            this.conflictResolver.resetar();
+            // Reseta decisões anteriores do ConflictResolver (se não é headless)
+            if (!opcoes.yes) {
+                this.conflictResolver.resetar();
+            }
 
             for (const arquivo of arquivosGerados) {
                 const destDir = path.join(diretorioAtual, arquivo.outputDir);

package/src/mcp/server.js

@@ -0,0 +1,399 @@
+#!/usr/bin/env node
+
+/**
+ * Rook MCP Server — Ponte entre IA e o CLI Rook.
+ * 
+ * Expõe as funcionalidades do CLI como Tools que clientes MCP
+ * (Claude Desktop, Cursor, etc.) podem descobrir e executar.
+ * 
+ * Tools disponíveis:
+ * - list_components: Lista kits e componentes do repositório remoto
+ * - install_component: Instala um componente ou kit no tema local
+ * - generate_scaffold: Gera boilerplate de componentes Liquid
+ * 
+ * Princípio: Composição — reutiliza os serviços existentes do CLI
+ * Princípio: Responsabilidade Única (SRP) — apenas expõe tools via protocolo MCP
+ */
+
+// ═══════════════════════════════════════════════════════════════
+// IMPORTANTE: Redireciona saídas puramente textuais para stderr
+// MCP requer que o stdout seja estritamente usado para o protocolo JSON-RPC.
+// Geração de logs da própria aplicação (como nosso logger interno ou o dotenv)
+// quebrará o handshake do Cursor/Claude Desktop, portanto desviamos 
+// tudo que é visual para stderr.
+// ═══════════════════════════════════════════════════════════════
+console.log = console.error;
+console.info = console.error;
+console.warn = console.error;
+console.debug = console.error;
+
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import {
+    CallToolRequestSchema,
+    ListToolsRequestSchema,
+} from '@modelcontextprotocol/sdk/types.js';
+import { z } from 'zod';
+
+// --- Dependências internas do CLI (reutilizadas) ---
+import { Logger } from '../utils/logger.js';
+import { TokenManager } from '../auth/TokenManager.js';
+import { GitHubService } from '../services/GitHubService.js';
+import { DownloadService } from '../services/DownloadService.js';
+import { ScaffoldService } from '../services/ScaffoldService.js';
+import { FileMapper } from '../filesystem/FileMapper.js';
+import { ConflictResolver } from '../filesystem/ConflictResolver.js';
+import { generateNames } from '../utils/stringUtils.js';
+
+import path from 'path';
+import os from 'os';
+import fs from 'fs-extra';
+import { fileURLToPath } from 'url';
+
+// -- Resolve .env relativo ao diretório do CLI --
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const cliRoot = path.resolve(__dirname, '..', '..');
+
+import dotenv from 'dotenv';
+dotenv.config({ path: path.join(cliRoot, '.env') });
+
+// ═══════════════════════════════════════════════════════════════
+//  Composition Root — instanciação de dependências (mesmo padrão do app.js)
+// ═══════════════════════════════════════════════════════════════
+
+const logger = new Logger();
+const tokenManager = new TokenManager(logger);
+const githubService = new GitHubService(logger, tokenManager);
+const downloadService = new DownloadService(logger, tokenManager);
+const conflictResolver = new ConflictResolver(logger);
+const fileMapper = new FileMapper(logger, conflictResolver);
+const scaffoldService = new ScaffoldService(logger);
+
+// No modo MCP, o ConflictResolver opera em modo headless (sobrescreve tudo)
+conflictResolver.definirDecisaoGlobal(true);
+
+// ═══════════════════════════════════════════════════════════════
+//  Schemas de validação (Zod)
+// ═══════════════════════════════════════════════════════════════
+
+const ListComponentsSchema = z.object({
+    category: z
+        .enum(['kits', 'components', 'all'])
+        .optional()
+        .default('all')
+        .describe('Filtrar por categoria: "kits", "components" ou "all" (padrão).'),
+});
+
+const InstallComponentSchema = z.object({
+    name: z
+        .string()
+        .min(1)
+        .describe('Nome do componente ou kit a ser instalado (ex: "whatsapp-float").'),
+    type: z
+        .enum(['component', 'kit'])
+        .describe('Tipo do pacote: "component" para componente individual, "kit" para kit completo.'),
+});
+
+const GenerateScaffoldSchema = z.object({
+    name: z
+        .string()
+        .min(1)
+        .describe('Nome do novo recurso (ex: "hero-banner"). Será convertido para kebab-case automaticamente.'),
+    elementType: z
+        .enum(['section', 'block', 'snippet', 'controller'])
+        .describe('Tipo de recurso Shopify a ser gerado.'),
+});
+
+// ═══════════════════════════════════════════════════════════════
+//  Funções Handler das Tools
+// ═══════════════════════════════════════════════════════════════
+
+/**
+ * Handler: list_components
+ * Lista kits e/ou componentes disponíveis no repositório remoto.
+ */
+async function handleListComponents(args) {
+    const { category } = ListComponentsSchema.parse(args);
+
+    const resultado = {};
+
+    if (category === 'kits' || category === 'all') {
+        const kits = await githubService.listarKits();
+        resultado.kits = kits.map(kit => ({
+            name: kit.nome,
+            slug: kit.slug,
+            description: kit.descricao,
+            components: kit.componentes,
+            path: kit.caminho,
+        }));
+    }
+
+    if (category === 'components' || category === 'all') {
+        const componentes = await githubService.listarComponentes();
+        resultado.components = componentes.map(comp => ({
+            name: comp.nome,
+            path: comp.caminho,
+        }));
+    }
+
+    const totalKits = resultado.kits?.length || 0;
+    const totalComponents = resultado.components?.length || 0;
+
+    return {
+        content: [{
+            type: 'text',
+            text: JSON.stringify({
+                summary: `Encontrados ${totalKits} kit(s) e ${totalComponents} componente(s).`,
+                ...resultado,
+            }, null, 2),
+        }],
+    };
+}
+
+/**
+ * Handler: install_component
+ * Instala um componente individual ou kit completo no tema do usuário.
+ */
+async function handleInstallComponent(args) {
+    const { name, type } = InstallComponentSchema.parse(args);
+    const diretorioAtual = process.cwd();
+
+    if (type === 'kit') {
+        // --- Instalação de Kit ---
+        const kits = await githubService.listarKits();
+        const kit = kits.find(k => k.slug === name || k.nome === name);
+
+        if (!kit) {
+            const disponiveis = kits.map(k => k.slug).join(', ');
+            throw new Error(`Kit "${name}" não encontrado. Kits disponíveis: ${disponiveis}`);
+        }
+
+        let totalComponentes = 0;
+        let totalArquivos = 0;
+
+        // Instala cada componente do manifesto
+        for (const nomeComponente of kit.componentes) {
+            const copiados = await baixarEDistribuir(`components/${nomeComponente}`, diretorioAtual);
+            totalArquivos += copiados;
+            totalComponentes++;
+        }
+
+        // Instala arquivos base do kit
+        const copiadosKit = await baixarEDistribuir(kit.caminho, diretorioAtual);
+        totalArquivos += copiadosKit;
+
+        return {
+            content: [{
+                type: 'text',
+                text: JSON.stringify({
+                    success: true,
+                    message: `Kit "${kit.nome}" instalado com sucesso.`,
+                    components_installed: totalComponentes,
+                    files_copied: totalArquivos,
+                }, null, 2),
+            }],
+        };
+
+    } else {
+        // --- Instalação de Componente Individual ---
+        const caminhoRemoto = `components/${name}`;
+        const copiados = await baixarEDistribuir(caminhoRemoto, diretorioAtual);
+
+        return {
+            content: [{
+                type: 'text',
+                text: JSON.stringify({
+                    success: true,
+                    message: `Componente "${name}" instalado com sucesso.`,
+                    files_copied: copiados,
+                }, null, 2),
+            }],
+        };
+    }
+}
+
+/**
+ * Handler: generate_scaffold
+ * Gera boilerplate de um componente Liquid (section, block, snippet, controller).
+ */
+async function handleGenerateScaffold(args) {
+    const { name, elementType } = GenerateScaffoldSchema.parse(args);
+
+    // Normaliza nomes (kebab, Pascal, snake)
+    const names = generateNames(name);
+
+    // Gera o conteúdo via ScaffoldService
+    const arquivo = await scaffoldService.generate(elementType, names);
+
+    // Grava no disco
+    const diretorioAtual = process.cwd();
+    const destDir = path.join(diretorioAtual, arquivo.outputDir);
+    const destPath = path.join(destDir, arquivo.fileName);
+    const caminhoRelativo = path.join(arquivo.outputDir, arquivo.fileName);
+
+    await fs.ensureDir(destDir);
+    await fs.writeFile(destPath, arquivo.content, 'utf-8');
+
+    return {
+        content: [{
+            type: 'text',
+            text: JSON.stringify({
+                success: true,
+                message: `Scaffold gerado com sucesso: ${caminhoRelativo}`,
+                file: caminhoRelativo,
+                names: {
+                    kebab: names.kebabName,
+                    pascal: names.PascalName,
+                    snake: names.snake_name,
+                },
+            }, null, 2),
+        }],
+    };
+}
+
+// ═══════════════════════════════════════════════════════════════
+//  Função auxiliar: Download + Distribuição
+// ═══════════════════════════════════════════════════════════════
+
+/**
+ * Processo genérico: baixa do repositório e distribui nas pastas locais.
+ * Reutiliza o mesmo padrão do AddCommand._baixarEDistribuir().
+ * 
+ * @param {string} caminhoRemoto - Caminho no repositório remoto
+ * @param {string} diretorioDestino - Diretório raiz do tema Shopify local
+ * @returns {Promise<number>} Número de arquivos copiados
+ */
+async function baixarEDistribuir(caminhoRemoto, diretorioDestino) {
+    const pastaTmp = path.join(os.tmpdir(), `rook-mcp-${Date.now()}`);
+
+    try {
+        await fs.ensureDir(pastaTmp);
+        await downloadService.baixar(caminhoRemoto, pastaTmp);
+        const totalCopiados = await fileMapper.distribuir(pastaTmp, diretorioDestino);
+        return totalCopiados;
+    } finally {
+        await fs.remove(pastaTmp);
+    }
+}
+
+// ═══════════════════════════════════════════════════════════════
+//  Inicialização do Servidor MCP
+// ═══════════════════════════════════════════════════════════════
+
+const server = new Server(
+    {
+        name: 'rook-cli-server',
+        version: '1.0.0',
+    },
+    {
+        capabilities: {
+            tools: {},
+        },
+    }
+);
+
+// --- Registrar lista de Tools disponíveis ---
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return {
+        tools: [
+            {
+                name: 'list_components',
+                description:
+                    'Lista componentes e kits disponíveis no repositório Rook. ' +
+                    'Use para descobrir o que pode ser instalado no tema Shopify do usuário.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        category: {
+                            type: 'string',
+                            enum: ['kits', 'components', 'all'],
+                            description: 'Filtrar por categoria: "kits", "components" ou "all" (padrão).',
+                            default: 'all',
+                        },
+                    },
+                },
+            },
+            {
+                name: 'install_component',
+                description:
+                    'Instala um componente individual ou kit completo no tema Shopify atual. ' +
+                    'Os arquivos são automaticamente distribuídos nas pastas corretas (sections/, snippets/, blocks/, assets/).',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        name: {
+                            type: 'string',
+                            description: 'Nome/slug do componente ou kit (ex: "whatsapp-float", "starter-base").',
+                        },
+                        type: {
+                            type: 'string',
+                            enum: ['component', 'kit'],
+                            description: 'Tipo do pacote: "component" ou "kit".',
+                        },
+                    },
+                    required: ['name', 'type'],
+                },
+            },
+            {
+                name: 'generate_scaffold',
+                description:
+                    'Gera a estrutura inicial (boilerplate) de um novo componente Liquid para Shopify. ' +
+                    'Cria o arquivo com template padronizado já preenchido com LiquidDoc e Web Components.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        name: {
+                            type: 'string',
+                            description: 'Nome do novo recurso em qualquer formato (ex: "hero-banner", "HeroBanner"). Será normalizado automaticamente.',
+                        },
+                        elementType: {
+                            type: 'string',
+                            enum: ['section', 'block', 'snippet', 'controller'],
+                            description: 'Tipo de recurso Shopify: section, block, snippet ou controller (JS asset).',
+                        },
+                    },
+                    required: ['name', 'elementType'],
+                },
+            },
+        ],
+    };
+});
+
+// --- Executar Tool solicitada pela IA ---
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+
+    try {
+        switch (name) {
+            case 'list_components':
+                return await handleListComponents(args || {});
+
+            case 'install_component':
+                return await handleInstallComponent(args);
+
+            case 'generate_scaffold':
+                return await handleGenerateScaffold(args);
+
+            default:
+                throw new Error(`Tool desconhecida: "${name}". Tools disponíveis: list_components, install_component, generate_scaffold`);
+        }
+    } catch (erro) {
+        // Retorna erro estruturado para a IA
+        return {
+            isError: true,
+            content: [{
+                type: 'text',
+                text: JSON.stringify({
+                    error: true,
+                    tool: name,
+                    message: erro.message,
+                }, null, 2),
+            }],
+        };
+    }
+});
+
+// --- Iniciar transporte Stdio ---
+const transport = new StdioServerTransport();
+await server.connect(transport);

package/src/utils/logger.js

@@ -49,7 +49,7 @@ export class Logger {
     banner() {
         console.log('');
         console.log(pc.bold(pc.white('  ╔══════════════════════════════╗')));
-        console.log(pc.bold(pc.white('  ║    ♟️  ROOK CLI  v1.0.3       ║')));
+        console.log(pc.bold(pc.white('  ║    ♟️  ROOK CLI  v1.2.1       ║')));
         console.log(pc.bold(pc.white('  ║   Shopify Component Tool     ║')));
         console.log(pc.bold(pc.white('  ╚══════════════════════════════╝')));
         console.log('');