rook-cli 1.0.3 → 1.2.0

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", "--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,14 +1,15 @@
 {
   "name": "rook-cli",
-  "version": "1.0.3",
-  "description": "CLI para instalar componentes Shopify de um repositório centralizado",
+  "version": "1.2.0",
+  "description": "CLI para instalar componentes Shopify",
   "repository": {
     "type": "git",
     "url": "https://github.com/chesslabdev/rook-cli.git"
   },
   "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

@@ -20,6 +20,8 @@ import { FileMapper } from './filesystem/FileMapper.js';
 import { ConflictResolver } from './filesystem/ConflictResolver.js';
 import { AddCommand } from './commands/AddCommand.js';
 import { ConfigCommand } from './commands/ConfigCommand.js';
+import { GenerateCommand } from './commands/GenerateCommand.js';
+import { ScaffoldService } from './services/ScaffoldService.js';
 import { CLI_NAME } from './config/constants.js';
 
 export class App {
@@ -50,6 +52,15 @@ export class App {
             this.logger,
             this.tokenManager
         );
+
+        this.scaffoldService = new ScaffoldService(this.logger);
+
+        this.generateCommand = new GenerateCommand(
+            this.logger,
+            this.promptUI,
+            this.scaffoldService,
+            this.conflictResolver
+        );
     }
 
     /**
@@ -63,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
@@ -80,6 +95,19 @@ export class App {
                 await this.configCommand.executar();
             });
 
+        // 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)')
+            .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, opcoes);
+            });
+
         // Comando padrão (sem argumentos) — abre o menu interativo
         this.programa
             .action(async () => {

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

@@ -0,0 +1,143 @@
+/**
+ * GenerateCommand — Comando "generate" do CLI.
+ * 
+ * Orquestra o fluxo de scaffold de componentes:
+ * 1. Recebe o nome do componente (argumento ou prompt)
+ * 2. Exibe menu multi-select para tipos de arquivo
+ * 3. Normaliza o nome para os formatos corretos (kebab, Pascal, snake)
+ * 4. Delega a geração ao ScaffoldService
+ * 5. Grava os arquivos via FileSystemManager (fs-extra)
+ * 6. Trata conflitos de sobrescrita
+ * 
+ * Princípio: Inversão de Dependência (DIP) — todas as dependências são injetadas
+ * Princípio: Responsabilidade Única (SRP) — orquestra apenas o fluxo do comando "generate"
+ */
+
+import path from 'path';
+import fs from 'fs-extra';
+import { generateNames } from '../utils/stringUtils.js';
+
+export class GenerateCommand {
+
+    /**
+     * @param {import('../utils/logger.js').Logger} logger
+     * @param {import('../ui/PromptUI.js').PromptUI} promptUI
+     * @param {import('../services/ScaffoldService.js').ScaffoldService} scaffoldService
+     * @param {import('../filesystem/ConflictResolver.js').ConflictResolver} conflictResolver
+     */
+    constructor(logger, promptUI, scaffoldService, conflictResolver) {
+        this.logger = logger;
+        this.promptUI = promptUI;
+        this.scaffoldService = scaffoldService;
+        this.conflictResolver = conflictResolver;
+    }
+
+    /**
+     * 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, 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();
+
+            if (!nome || nome.trim() === '') {
+                this.logger.erro('Nome do componente é obrigatório.');
+                return;
+            }
+
+            // 2. Normaliza os nomes
+            const names = generateNames(nome);
+
+            this.logger.destaque(`\n🔧 Gerando componente: ${names.PascalName} (${names.kebabName})\n`);
+
+            // 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.');
+                return;
+            }
+
+            // 4. Gera os arquivos via ScaffoldService
+            const arquivosGerados = await this.scaffoldService.generateMultiple(tiposSelecionados, names);
+
+            // 5. Grava os arquivos no disco
+            const diretorioAtual = process.cwd();
+            let totalGravados = 0;
+
+            // 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);
+                const destPath = path.join(destDir, arquivo.fileName);
+                const caminhoRelativo = path.join(arquivo.outputDir, arquivo.fileName);
+
+                // RF03: Verifica se já existe
+                if (await fs.pathExists(destPath)) {
+                    const sobrescrever = await this.conflictResolver.resolver(caminhoRelativo);
+
+                    if (!sobrescrever) {
+                        this.logger.aviso(`  ⏩ Pulando: ${caminhoRelativo}`);
+                        continue;
+                    }
+                }
+
+                // Cria o diretório se não existe e grava o arquivo
+                await fs.ensureDir(destDir);
+                await fs.writeFile(destPath, arquivo.content, 'utf-8');
+
+                this.logger.sucesso(`  ✅ ${caminhoRelativo}`);
+                totalGravados++;
+            }
+
+            // 6. Resumo final
+            console.log('');
+            this.logger.destaque('═══════════════════════════════════════════');
+            this.logger.sucesso(`🎉 ${totalGravados}/${arquivosGerados.length} arquivo(s) gerado(s) com sucesso!`);
+            this.logger.sutil(`Componente: ${names.PascalName} (${names.kebabName})`);
+            this.logger.destaque('═══════════════════════════════════════════');
+            console.log('');
+
+        } catch (erro) {
+            // Trata cancelamento do usuário (Ctrl+C)
+            if (erro.name === 'ExitPromptError') {
+                this.logger.aviso('Operação cancelada pelo usuário.');
+                return;
+            }
+            this.logger.erro(`Erro durante a geração: ${erro.message}`);
+        }
+    }
+}

package/src/mcp/server.js

@@ -0,0 +1,387 @@
+#!/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
+ */
+
+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/services/ScaffoldService.js

@@ -0,0 +1,131 @@
+/**
+ * ScaffoldService — Motor de geração de scaffold via templates.
+ * 
+ * Responsável por:
+ * - Ler os templates base da pasta src/templates/
+ * - Substituir placeholders ({{kebabName}}, {{PascalName}}, etc.)
+ * - Retornar o conteúdo final já renderizado
+ * 
+ * Princípio: Responsabilidade Única (SRP) — lida apenas com renderização de templates
+ * Princípio: Aberto/Fechado (OCP) — novos templates são adicionados sem alterar lógica existente
+ */
+
+import fs from 'fs-extra';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+/** Diretório onde os templates estão armazenados */
+const TEMPLATES_DIR = path.resolve(__dirname, '..', 'templates');
+
+/**
+ * Mapa de tipos para seus respectivos arquivos de template
+ * e destinos de saída.
+ * 
+ * @type {Object.<string, { templateFile: string, outputDir: string, outputFileName: (kebabName: string) => string }>}
+ */
+const TEMPLATE_MAP = {
+    section: {
+        templateFile: 'section.liquid.txt',
+        outputDir: 'sections',
+        outputFileName: (kebabName) => `${kebabName}.liquid`,
+    },
+    block: {
+        templateFile: 'block.liquid.txt',
+        outputDir: 'blocks',
+        outputFileName: (kebabName) => `${kebabName}-block.liquid`,
+    },
+    snippet: {
+        templateFile: 'snippet.liquid.txt',
+        outputDir: 'snippets',
+        outputFileName: (kebabName) => `${kebabName}.liquid`,
+    },
+    controller: {
+        templateFile: 'controller.js.txt',
+        outputDir: 'assets',
+        outputFileName: (kebabName) => `${kebabName}-controller.js`,
+    },
+};
+
+export class ScaffoldService {
+
+    /**
+     * @param {import('../utils/logger.js').Logger} logger
+     */
+    constructor(logger) {
+        this.logger = logger;
+    }
+
+    /**
+     * Retorna os tipos de componente disponíveis para geração.
+     * @returns {string[]} Lista de tipos disponíveis
+     */
+    getAvailableTypes() {
+        return Object.keys(TEMPLATE_MAP);
+    }
+
+    /**
+     * Renderiza um template substituindo todos os placeholders.
+     * Utiliza replace via regex (RF02 do PRD).
+     * 
+     * @param {string} templateContent - Conteúdo bruto do template
+     * @param {{ kebabName: string, PascalName: string, snake_name: string }} names - Nomes formatados
+     * @returns {string} Conteúdo final renderizado
+     */
+    render(templateContent, names) {
+        return templateContent
+            .replace(/\{\{kebabName\}\}/g, names.kebabName)
+            .replace(/\{\{PascalName\}\}/g, names.PascalName)
+            .replace(/\{\{snake_name\}\}/g, names.snake_name);
+    }
+
+    /**
+     * Gera um único componente: lê o template, renderiza e retorna
+     * o conteúdo com as informações de destino.
+     * 
+     * @param {string} type - Tipo do componente ('section', 'block', 'snippet', 'controller')
+     * @param {{ kebabName: string, PascalName: string, snake_name: string }} names - Nomes formatados
+     * @returns {Promise<{ content: string, outputDir: string, fileName: string }>}
+     * @throws {Error} Se o tipo não for suportado
+     */
+    async generate(type, names) {
+        const config = TEMPLATE_MAP[type];
+
+        if (!config) {
+            throw new Error(`Tipo de componente não suportado: "${type}". Tipos válidos: ${this.getAvailableTypes().join(', ')}`);
+        }
+
+        // Lê o template do disco
+        const templatePath = path.join(TEMPLATES_DIR, config.templateFile);
+        const templateContent = await fs.readFile(templatePath, 'utf-8');
+
+        // Renderiza com as variáveis
+        const content = this.render(templateContent, names);
+
+        return {
+            content,
+            outputDir: config.outputDir,
+            fileName: config.outputFileName(names.kebabName),
+        };
+    }
+
+    /**
+     * Gera múltiplos componentes de uma vez.
+     * 
+     * @param {string[]} types - Lista de tipos a serem gerados
+     * @param {{ kebabName: string, PascalName: string, snake_name: string }} names - Nomes formatados
+     * @returns {Promise<Array<{ content: string, outputDir: string, fileName: string }>>}
+     */
+    async generateMultiple(types, names) {
+        const results = [];
+
+        for (const type of types) {
+            const result = await this.generate(type, names);
+            results.push(result);
+        }
+
+        return results;
+    }
+}

package/src/templates/block.liquid.txt

@@ -0,0 +1,52 @@
+{% doc %}
+  Block: {{PascalName}} Block
+  Usage: Use inside sections that support blocks.
+{% enddoc %}
+
+{% liquid
+  assign block_id = block.id
+%}
+
+<{{kebabName}}-block
+  id="block-{{ block_id }}"
+  class="{{kebabName}}-block"
+  data-block-id="{{ block_id }}"
+  {{ block.shopify_attributes }}
+>
+  <div class="{{kebabName}}-block__inner">
+    {% if block.settings.title != blank %}
+      <h3 class="{{kebabName}}-block__title">{{ block.settings.title | escape }}</h3>
+    {% endif %}
+  </div>
+</{{kebabName}}-block>
+
+{% schema %}
+{
+  "name": "{{PascalName}} Block",
+  "target": "section",
+  "settings": [
+    {
+      "type": "text",
+      "id": "title",
+      "label": "Block Title",
+      "default": "Feature"
+    }
+  ]
+}
+{% endschema %}
+
+{% javascript %}
+  class {{PascalName}}Block extends HTMLElement {
+    connectedCallback() {
+      this.addEventListener('click', this.handleClick.bind(this));
+    }
+
+    handleClick() {
+      console.log('Block clicked:', this.dataset.blockId);
+    }
+  }
+
+  if (!customElements.get('{{kebabName}}-block')) {
+    customElements.define('{{kebabName}}-block', {{PascalName}}Block);
+  }
+{% endjavascript %}

package/src/templates/controller.js.txt

@@ -0,0 +1,27 @@
+/**
+ * Controller: {{PascalName}}Controller
+ * Path: assets/{{kebabName}}-controller.js
+ * Description: Logic separated for reuse across multiple sections/blocks
+ */
+
+class {{PascalName}}Controller extends HTMLElement {
+  connectedCallback() {
+    const sectionId = this.dataset.sectionId;
+    if (!sectionId) return;
+
+    this.root = document.getElementById(`section-${sectionId}`);
+    this.bindEvents();
+  }
+
+  bindEvents() {
+    // Add event listeners
+  }
+
+  disconnectedCallback() {
+    // Remove event listeners
+  }
+}
+
+if (!customElements.get('{{kebabName}}-controller')) {
+  customElements.define('{{kebabName}}-controller', {{PascalName}}Controller);
+}

package/src/templates/section.liquid.txt

@@ -0,0 +1,92 @@
+{% doc %}
+  Section: {{PascalName}}
+  Description: Componente principal controlado via Web Component.
+  Architecture:
+    - HTML: Semântico com IDs dinâmicos
+    - JS: Web Component desacoplado
+    - CSS: Scoped ou via Assets
+{% enddoc %}
+
+{% liquid
+  assign section_id = section.id
+  assign container_id = 'section-' | append: section_id
+%}
+
+<{{kebabName}}-section
+  id="{{ container_id }}"
+  class="{{kebabName}} section-container"
+  data-section-id="{{ section_id }}"
+>
+  <div class="{{kebabName}}__wrapper page-width">
+    {%- if section.settings.heading != blank -%}
+      <h2 class="{{kebabName}}__heading">{{ section.settings.heading | escape }}</h2>
+    {%- endif -%}
+
+    <div class="{{kebabName}}__content">
+      {% content_for 'blocks' %}
+    </div>
+  </div>
+</{{kebabName}}-section>
+
+{% schema %}
+{
+  "name": "{{PascalName}}",
+  "tag": "section",
+  "class": "section-{{kebabName}}",
+  "settings": [
+    {
+      "type": "text",
+      "id": "heading",
+      "label": "Heading",
+      "default": "{{PascalName}}"
+    }
+  ],
+  "blocks": [
+    {
+      "type": "@theme"
+    }
+  ],
+  "presets": [
+    {
+      "name": "{{PascalName}}"
+    }
+  ]
+}
+{% endschema %}
+
+{% stylesheet %}
+  /* BEM Styling */
+  .{{kebabName}} {
+    display: block;
+    position: relative;
+    padding: 2rem 0;
+  }
+  .{{kebabName}}__heading {
+    margin-bottom: 1.5rem;
+  }
+{% endstylesheet %}
+
+{% javascript %}
+  class {{PascalName}}Section extends HTMLElement {
+    constructor() {
+      super();
+    }
+
+    connectedCallback() {
+      this.init();
+    }
+
+    init() {
+      console.log('{{PascalName}} initialized', this.dataset.sectionId);
+      // Logic goes here
+    }
+
+    disconnectedCallback() {
+      // Cleanup events
+    }
+  }
+
+  if (!customElements.get('{{kebabName}}-section')) {
+    customElements.define('{{kebabName}}-section', {{PascalName}}Section);
+  }
+{% endjavascript %}

package/src/templates/snippet.liquid.txt

@@ -0,0 +1,21 @@
+{% doc %}
+  Snippet: {{PascalName}}
+  Renders a reusable UI component.
+
+  @param {string} id - Unique DOM id
+  @param {string} [modifier_class] - Optional CSS class
+  @param {string} [content] - Optional inner HTML
+
+  @example
+  {% render '{{kebabName}}', id: 'my-id', content: 'Hello' %}
+{% enddoc %}
+
+<div
+  id="{{ id | escape }}"
+  class="{{kebabName}} {{ modifier_class }}"
+  data-ui-component="{{kebabName}}"
+>
+  {% if content %}
+    {{ content }}
+  {% endif %}
+</div>

package/src/ui/PromptUI.js

@@ -8,10 +8,63 @@
  * Princípio: Aberto/Fechado (OCP) — fácil adicionar novos menus
  */
 
-import { select, checkbox } from '@inquirer/prompts';
+import { select, checkbox, input } from '@inquirer/prompts';
 
 export class PromptUI {
 
+    /**
+     * Pergunta o nome do componente ao usuário.
+     * Usado quando o nome não é fornecido via argumento CLI.
+     * 
+     * @returns {Promise<string>} Nome digitado pelo usuário
+     */
+    async perguntarNomeComponente() {
+        const nome = await input({
+            message: '📝 Qual o nome do componente?',
+            validate: (value) => {
+                if (!value || value.trim() === '') {
+                    return 'O nome do componente é obrigatório.';
+                }
+                return true;
+            },
+        });
+
+        return nome.trim();
+    }
+
+    /**
+     * Exibe menu multi-select para escolher os tipos de arquivo a serem gerados.
+     * Implementa o RF do PRD: "O que você deseja criar?"
+     * 
+     * @returns {Promise<string[]>} Tipos selecionados ('section', 'block', 'snippet', 'controller')
+     */
+    async selecionarTiposGerador() {
+        const tipos = await checkbox({
+            message: '🧱 O que você deseja criar?',
+            choices: [
+                {
+                    name: '📄 Section — Cria sections/[nome].liquid',
+                    value: 'section',
+                },
+                {
+                    name: '🧩 Block — Cria blocks/[nome]-block.liquid',
+                    value: 'block',
+                },
+                {
+                    name: '🔗 Snippet — Cria snippets/[nome].liquid',
+                    value: 'snippet',
+                },
+                {
+                    name: '⚡ Asset JS Controller — Cria assets/[nome]-controller.js',
+                    value: 'controller',
+                },
+            ],
+            required: true,
+        });
+
+        return tipos;
+    }
+
     /**
      * Exibe o menu principal com as opções de instalação.
      * 

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.1.1       ║')));
         console.log(pc.bold(pc.white('  ║   Shopify Component Tool     ║')));
         console.log(pc.bold(pc.white('  ╚══════════════════════════════╝')));
         console.log('');

package/src/utils/stringUtils.js

@@ -0,0 +1,86 @@
+/**
+ * stringUtils — Utilitários puros de manipulação de strings.
+ * 
+ * Responsável pelas conversões de casing necessárias
+ * no fluxo de geração de componentes (scaffold).
+ * 
+ * Princípio: Responsabilidade Única (SRP) — funções puras sem side-effects
+ * Princípio: Aberto/Fechado (OCP) — novos formatadores são adicionados sem alterar existentes
+ */
+
+/**
+ * Converte qualquer input para kebab-case.
+ * Usado em: nomes de arquivo, classes CSS (BEM), tags HTML.
+ * 
+ * Exemplos:
+ *   "hero banner"   → "hero-banner"
+ *   "HeroBanner"    → "hero-banner"
+ *   "hero_banner"   → "hero-banner"
+ *   "HERO-BANNER"   → "hero-banner"
+ * 
+ * @param {string} input - String para converter
+ * @returns {string} String em kebab-case
+ */
+export function toKebabCase(input) {
+    return input
+        // Insere hífen antes de letras maiúsculas em camelCase/PascalCase
+        .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
+        // Substitui espaços, underscores e múltiplos hífens por hífen único
+        .replace(/[\s_]+/g, '-')
+        // Remove múltiplos hífens consecutivos
+        .replace(/-+/g, '-')
+        // Remove hífens no início e final
+        .replace(/^-|-$/g, '')
+        .toLowerCase();
+}
+
+/**
+ * Converte qualquer input para PascalCase.
+ * Usado em: classes JS (Web Components), labels do Schema Shopify.
+ * 
+ * Exemplos:
+ *   "hero banner"   → "HeroBanner"
+ *   "hero-banner"   → "HeroBanner"
+ *   "hero_banner"   → "HeroBanner"
+ *   "HeroBanner"    → "HeroBanner"
+ * 
+ * @param {string} input - String para converter
+ * @returns {string} String em PascalCase
+ */
+export function toPascalCase(input) {
+    return toKebabCase(input)
+        .split('-')
+        .map(word => word.charAt(0).toUpperCase() + word.slice(1))
+        .join('');
+}
+
+/**
+ * Converte qualquer input para snake_case.
+ * Usado em: variáveis Liquid, IDs de settings.
+ * 
+ * Exemplos:
+ *   "hero banner"   → "hero_banner"
+ *   "hero-banner"   → "hero_banner"
+ *   "HeroBanner"    → "hero_banner"
+ * 
+ * @param {string} input - String para converter
+ * @returns {string} String em snake_case
+ */
+export function toSnakeCase(input) {
+    return toKebabCase(input).replace(/-/g, '_');
+}
+
+/**
+ * Gera todos os formatos de nome a partir de um input qualquer.
+ * Retorna um objeto padronizado usado nos templates.
+ * 
+ * @param {string} input - Nome original do componente
+ * @returns {{ kebabName: string, PascalName: string, snake_name: string }}
+ */
+export function generateNames(input) {
+    return {
+        kebabName: toKebabCase(input),
+        PascalName: toPascalCase(input),
+        snake_name: toSnakeCase(input),
+    };
+}