@maestro-ai/cli 1.1.0 → 1.3.0

package/content/workflows/05-nova-feature.md

@@ -0,0 +1,39 @@
+---
+description: Adicionar nova feature com fluxo estruturado (Análise → Implementação → Deploy)
+---
+
+# 🆕 /nova-feature - Workflow de Nova Feature
+
+## 1. Preparação (Análise de Impacto)
+
+*   **Estratégia:** Verifique a complexidade. Se envolver múltiplos domínios ou alto risco, consulte `guides/guide-orquestracao.md` para ativar o **Modo Squad**.
+*   **Ação:** Pergunte ao usuário a descrição da feature e o impacto estimado (baixo/médio/alto).
+*   **Ação:** Crie o diretório `docs/features/{FEATURE-ID}/`.
+*   **Ação:** Crie o arquivo `docs/features/{FEATURE-ID}/01-analise.md` com a análise inicial:
+    *   Tabelas afetadas
+    *   Novos Endpoints
+    *   Componentes de UI necessários
+
+## 2. Refinamento e Design
+
+*   **Instrução:** Use o workflow padrão `/02-avancar-fase` para mover a feature para Design.
+*   **Entregável Esperado:** Contrato de Interface (OpenAPI) e Mockups/Wireframes se necessário.
+
+## 3. Implementação (O "Core")
+
+> Aqui usamos o workflow especializado de granularidade fina.
+
+*   **Ação:** Quebre a feature em Histórias de Usuário (ex: `US-01: Criar API`, `US-02: Tela de Listagem`).
+*   **Para cada História:**
+    *   Execute o workflow: **`/04-implementar-historia`**
+    *   Siga ordenadamente: Types -> Mocks -> Frontend -> Backend -> Integração.
+
+## 4. Testes e Validação
+
+*   **Verificação de Segurança:** Antes de finalizar, leia `rules/security-rules.md` e revise o código.
+*   **Testes:** Garanta que os testes criados na fase de implementação estão passando.
+
+## 5. Deploy e Encerramento
+
+*   **Ação:** Atualize o `estado.json` (ou use `/02-avancar-fase`) para marcar a feature como CONCLUÍDA.
+*   **Resumo:** Atualize `.maestro/resumo.json` adicionando a feature ao histórico.

package/content/workflows/06-corrigir-bug.md

@@ -0,0 +1,34 @@
+---
+description: Workflow para correção de bugs com análise de causa raiz e segurança
+---
+
+# 🐛 /corrigir-bug - Workflow de Correção
+
+## 1. Reprodução e Análise
+
+*   **Estratégia:** Se o bug for crítico, arquitetural ou envolver múltiplos serviços, consulte `guides/guide-orquestracao.md` para ativar o **Modo Squad**.
+*   **Ação:** Crie um caso de teste que reproduza o erro (se possível).
+*   **Ação:** Analise a causa raiz.
+
+## 2. Classificação de Segurança
+
+*   **Ação:** O bug é uma vulnerabilidade de segurança?
+    *   **Sim:** Leia imediatamente `rules/security-rules.md` para entender a categoria (ex: SQL Injection, XSS).
+    *   **Não:** Prossiga normalmente.
+
+## 3. Implementação da Correção
+
+*   **Ação:** Implemente o fix.
+*   **Regra:** Não altere comportamento não relacionado (escopo fechado).
+
+## 4. Verificação
+
+*   **Ação:** Rode o teste de reprodução (deve passar).
+*   **Ação:** Rode testes de regressão (não deve quebrar nada existente).
+*   **Revisão (Self-Code-Review):**
+    *   Verifique se não deixou `console.log` (Regra `SEC-LOG`).
+    *   Verifique se não hardcodou credenciais (Regra `A02-SECRET`).
+
+## 5. Finalização
+
+*   **Ação:** Atualize o histórico em `.maestro/resumo.json` registrando o bug fix.

package/content/workflows/07-refatorar-codigo.md

@@ -0,0 +1,34 @@
+---
+description: Workflow para refatoração segura de código existente
+---
+
+# 🧹 /refatorar-codigo - Workflow de Refatoração
+
+## 1. Análise Prévia
+
+*   **Estratégia:** Se a refatoração for estrutural ou de alto risco, consulte `guides/guide-orquestracao.md` para ativar o **Modo Squad**.
+*   **Ação:** Identifique a área a ser refatorada (arquivo, função, módulo).
+*   **Ação:** Entenda o "Motivo" (Legibilidade, Performance, Segurança, Estrutura).
+*   **Ação:** **Importante**: Garanta que existem testes cobrindo essa área. Se não houver, crie um "Teste de Caracterização" (Snapshot/Unitário) antes de tocar no código.
+
+## 2. Consulta de Regras
+
+*   **Ação:** Se for refatoração de Segurança, leia `rules/security-rules.md`.
+*   **Ação:** Se for refatoração de Estrutura, consulte `.maestro/mapa.md` para entender dependências.
+
+## 3. Execução (Ciclo Red-Green-Refactor)
+
+*   **Passo 1:** Rode os testes (Devem passar: 🟢).
+*   **Passo 2:** Aplique uma pequena mudança de refatoração.
+*   **Passo 3:** Rode os testes (Devem passar: 🟢).
+*   **Passo 4:** Repita.
+
+## 4. Atualização de Mapa
+
+*   **Ação:** Se você alterou nomes de classes, arquivos ou assinaturas de API:
+    *   Execute `guides/internal/automated-map.md`.
+*   **Ação:** Registre o evento de refatoração via `guides/internal/automated-events.md`.
+
+## 5. Registro
+
+*   **Ação:** Registre a refatoração no `.maestro/resumo.json`.

package/dist/commands/init.d.ts

@@ -1,7 +1,7 @@
 interface InitOptions {
     force?: boolean;
     minimal?: boolean;
-    ide?: 'gemini' | 'cursor' | 'copilot' | 'windsurf' | 'all';
+    ide?: 'windsurf' | 'cursor' | 'antigravity';
 }
-export declare function init(options?: InitOptions): Promise<void>;
+export declare function init(options: InitOptions): Promise<void>;
 export {};

package/dist/commands/init.js

@@ -6,24 +6,26 @@ import chalk from 'chalk';
 import ora from 'ora';
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const IDE_CONFIGS = {
-    gemini: {
-        path: '.gemini/GEMINI.md',
-        header: '---\ntrigger: always_on\nsystem: maestro\nversion: 1.0.0\n---\n\n'
+    windsurf: {
+        path: '.windsurfrules',
+        header: '',
+        workflowsDir: '.windsurf/workflows',
+        skillsDir: '.windsurf/skills'
     },
     cursor: {
         path: '.cursorrules',
-        header: ''
+        header: '',
+        workflowsDir: '.cursor/commands',
+        skillsDir: '.cursor/skills'
     },
-    copilot: {
-        path: '.github/copilot-instructions.md',
-        header: ''
-    },
-    windsurf: {
-        path: '.windsurfrules',
-        header: ''
+    antigravity: {
+        path: '.gemini/GEMINI.md',
+        header: '---\ntrigger: always_on\nsystem: maestro\nversion: 1.0.0\n---\n\n',
+        workflowsDir: '.agent/workflows',
+        skillsDir: '.agent/skills'
     }
 };
-export async function init(options = {}) {
+export async function init(options) {
     const cwd = process.cwd();
     const spinner = ora();
     console.log(chalk.blue.bold('\n🎯 Maestro - Inicializando projeto\n'));
@@ -41,9 +43,10 @@ export async function init(options = {}) {
         await fse.ensureDir(join(cwd, '.maestro'));
         await fse.ensureDir(join(cwd, '.maestro', 'history'));
         await fse.writeJSON(join(cwd, '.maestro', 'config.json'), {
-            version: '1.0.0',
+            version: '1.3.0',
             initialized: new Date().toISOString(),
-            mcpServer: 'https://maestro.deluna.dev.br/mcp'
+            ide: options.ide || 'windsurf',
+            mcpFree: true
         }, { spaces: 2 });
         spinner.succeed('Estrutura .maestro/ criada');
         // 2. Copiar content para .maestro/content/ (se não minimal)
@@ -60,27 +63,9 @@ export async function init(options = {}) {
             }
             spinner.succeed('Content copiado para .maestro/content/');
         }
-        // 3. Copiar skills para .agent/skills/
-        spinner.start('Copiando skills para .agent/skills/...');
-        const skillsSrc = join(contentSource, 'skills');
-        const skillsDest = join(cwd, '.agent', 'skills');
-        if (await fse.pathExists(skillsSrc)) {
-            await fse.copy(skillsSrc, skillsDest, { overwrite: options.force });
-        }
-        spinner.succeed('Skills copiados para .agent/skills/');
-        // 4. Copiar workflows para .agent/workflows/
-        spinner.start('Copiando workflows para .agent/workflows/...');
-        const workflowsSrc = join(contentSource, 'workflows');
-        const workflowsDest = join(cwd, '.agent', 'workflows');
-        if (await fse.pathExists(workflowsSrc)) {
-            await fse.copy(workflowsSrc, workflowsDest, { overwrite: options.force });
-        }
-        spinner.succeed('Workflows copiados para .agent/workflows/');
-        // 5. Gerar arquivos de regras por IDE
-        const targetIdes = options.ide === 'all'
-            ? Object.keys(IDE_CONFIGS)
-            : [options.ide || 'gemini'];
-        spinner.start(`Gerando regras para IDE(s): ${targetIdes.join(', ')}...`);
+        // 4. Configurar IDE específica
+        const ideConfig = IDE_CONFIGS[options.ide];
+        spinner.start(`Configurando IDE: ${options.ide}...`);
         // Ler RULES.md base
         const rulesPath = join(contentSource, 'rules', 'RULES.md');
         let rulesContent = '';
@@ -90,17 +75,29 @@ export async function init(options = {}) {
         else {
             rulesContent = generateDefaultRules();
         }
-        // Gerar arquivo para cada IDE alvo
-        for (const ide of targetIdes) {
-            const config = IDE_CONFIGS[ide];
-            const targetPath = join(cwd, config.path);
-            await fse.ensureDir(dirname(targetPath));
-            const content = config.header + rulesContent;
-            await fse.writeFile(targetPath, content);
+        // Criar diretórios específicos da IDE
+        await fse.ensureDir(join(cwd, dirname(ideConfig.path)));
+        await fse.ensureDir(join(cwd, ideConfig.workflowsDir));
+        await fse.ensureDir(join(cwd, ideConfig.skillsDir));
+        // Copiar workflows para diretório específico da IDE
+        const workflowsSrc = join(contentSource, 'workflows');
+        const workflowsDest = join(cwd, ideConfig.workflowsDir);
+        if (await fse.pathExists(workflowsSrc)) {
+            await fse.copy(workflowsSrc, workflowsDest, { overwrite: options.force });
+        }
+        // Copiar skills para diretório específico da IDE
+        const skillsSrc = join(contentSource, 'skills');
+        const skillsDest = join(cwd, ideConfig.skillsDir);
+        if (await fse.pathExists(skillsSrc)) {
+            await fse.copy(skillsSrc, skillsDest, { overwrite: options.force });
         }
-        spinner.succeed(`Regras geradas para: ${targetIdes.join(', ')}`);
+        // Gerar arquivo de regras
+        const targetPath = join(cwd, ideConfig.path);
+        const content = ideConfig.header + rulesContent;
+        await fse.writeFile(targetPath, content);
+        spinner.succeed(`IDE ${options.ide} configurada com sucesso!`);
         // Resumo
-        console.log(chalk.green.bold('\n✅ Maestro inicializado com sucesso!\n'));
+        console.log(chalk.green.bold(`\n✅ Maestro inicializado para ${options.ide}\n`));
         console.log(chalk.dim('Estrutura criada:'));
         console.log(chalk.dim('  .maestro/'));
         console.log(chalk.dim('    ├── config.json'));
@@ -112,16 +109,13 @@ export async function init(options = {}) {
             console.log(chalk.dim('        ├── guides/'));
             console.log(chalk.dim('        └── prompts/'));
         }
-        console.log(chalk.dim('  .agent/'));
-        console.log(chalk.dim('    ├── skills/'));
-        console.log(chalk.dim('    └── workflows/'));
-        for (const ide of targetIdes) {
-            console.log(chalk.dim(`  ${IDE_CONFIGS[ide].path}`));
-        }
-        console.log(chalk.blue('\n📋 Próximos passos:'));
-        console.log('  1. Configure o MCP na sua IDE:');
-        console.log(chalk.gray('     "mcpServers": { "maestro": { "serverUrl": "https://maestro.deluna.dev.br/mcp" } }'));
-        console.log('  2. Inicie um novo projeto com: @mcp:maestro iniciar_projeto');
+        console.log(chalk.dim(`  ${ideConfig.workflowsDir}/`));
+        console.log(chalk.dim(`  ${ideConfig.skillsDir}/`));
+        console.log(chalk.dim(`  ${ideConfig.path}`));
+        console.log(chalk.blue('\n🎯 Próximos passos:'));
+        console.log(`  1. Abra sua ${options.ide}`);
+        console.log('  2. Digite: /maestro');
+        console.log(' 3. Comece a desenvolver!');
         console.log('');
     }
     catch (error) {
@@ -131,40 +125,59 @@ export async function init(options = {}) {
     }
 }
 function generateDefaultRules() {
-    return `# MCP Maestro Development Kit - AI Rules
-
-> Este arquivo define como a IA deve se comportar ao trabalhar com o sistema MCP Maestro.
+    return `# Maestro File System - AI Rules
 
-## Configuração MCP
-
-\`\`\`json
-{
-  "mcpServers": {
-    "maestro": {
-      "serverUrl": "https://maestro.deluna.dev.br/mcp"
-    }
-  }
-}
-\`\`\`
+> Este arquivo define como a IA deve se comportar ao trabalhar com o sistema Maestro File System.
 
 ## Como Usar
 
-1. **Iniciar projeto**: Use \`iniciar_projeto\` para começar
-2. **Avançar fases**: Use \`proximo\` para salvar e avançar
-3. **Ver status**: Use \`status\` para ver onde está
+1. **Ver status**: Use \`/00-maestro\` para ver progresso
+2. **Iniciar projeto**: Use \`/01-iniciar-projeto\` para começar
+3. **Avançar fases**: Use \`/02-avancar-fase\` para avançar
+4. **Continuar**: Use \`/03-continuar-fase\` para retomar trabalho
 
 ## Estrutura Local
 
 | Pasta | Conteúdo |
 |-------|----------|
 | \`.maestro/estado.json\` | Estado do projeto (fonte da verdade) |
-| \`.maestro/SYSTEM.md\` | Contexto atual para IA |
-| \`.maestro/content/\` | Especialistas, templates, prompts |
-| \`.agent/skills/\` | Skills disponíveis |
-| \`.agent/workflows/\` | Workflows automatizados |
+| \`.maestro/content/\` | Especialistas, templates, guides |
+| \`.windsurf/workflows/\` | Workflows para Windsurf |
+| \`.windsurf/skills/\` | Skills especializadas |
+| \`.cursor/commands/\` | Commands para Cursor |
+| \`.cursor/skills/\` | Skills especializadas |
+| \`.agent/workflows/\` | Workflows Principais (00-08) |
+| \`.agent/skills/\` | Skills especializadas |
+
+## Comandos Disponíveis
+
+### Gestão de Projeto
+- \`/00-maestro\` - Router Inteligente (Status)
+- \`/01-iniciar-projeto\` - Setup Inicial
+- \`/02-avancar-fase\` - Transição de Fase (com automações)
+- \`/03-continuar-fase\` - Retomada de Trabalho
+- \`/08-deploy-projeto\` - Deploy e Encerramento
+
+### Desenvolvimento
+- \`/04-implementar-historia\` - Frontend-First Dev
+- \`/05-nova-feature\` - Grandes Funcionalidades
+- \`/06-corrigir-bug\` - Fix com análise de causa
+- \`/07-refatorar-codigo\` - Melhoria técnica segura
+
+## Especialistas IA
+
+- Gestão de Produto
+- Engenharia de Requisitos
+- UX Design
+- Arquitetura de Software
+- E mais 20 especialistas disponíveis
+
+## Orquestração Local
+
+Este sistema opera 100% localmente, sem dependência de MCP remoto. A IA detecta automaticamente os arquivos e workflows disponíveis.
 
 ## Estado do Projeto
 
-O estado é mantido em \`.maestro/estado.json\` e deve ser passado como \`estado_json\` em todos os tools MCP.
+O estado é mantido em \`.maestro/estado.json\` e serve como fonte da verdade para o progresso do projeto.
 `;
 }

package/dist/index.js

@@ -2,6 +2,62 @@
 import { Command } from 'commander';
 import { init } from './commands/init.js';
 import { update } from './commands/update.js';
+import chalk from 'chalk';
+import { createInterface } from 'readline';
+const VALID_IDES = ['windsurf', 'cursor', 'antigravity'];
+async function promptForIDE() {
+    while (true) {
+        console.log(chalk.cyan('\n🎯 Selecione sua IDE de desenvolvimento:\n'));
+        VALID_IDES.forEach((ide, index) => {
+            console.log(chalk.white(`${index + 1}. ${ide}`));
+        });
+        console.log(chalk.yellow('\nDigite o número da IDE desejada:'));
+        const answer = await new Promise((resolve) => {
+            const rl = createInterface({
+                input: process.stdin,
+                output: process.stdout
+            });
+            rl.question('', (answer) => {
+                rl.close();
+                resolve(answer.trim());
+            });
+        });
+        const choice = parseInt(answer);
+        if (choice >= 1 && choice <= VALID_IDES.length) {
+            return VALID_IDES[choice - 1];
+        }
+        console.log(chalk.red('❌ Opção inválida. Por favor, digite um número entre 1 e 3.'));
+        // Loop continua para perguntar novamente
+    }
+}
+async function promptForIDEWithDefault() {
+    while (true) {
+        console.log(chalk.cyan('\n🎯 Selecione sua IDE de desenvolvimento:\n'));
+        VALID_IDES.forEach((ide, index) => {
+            console.log(chalk.white(`${index + 1}. ${ide}`));
+        });
+        console.log(chalk.yellow('\nDigite o número da IDE desejada (ou pressione Enter para Windsurf):'));
+        const answer = await new Promise((resolve) => {
+            const rl = createInterface({
+                input: process.stdin,
+                output: process.stdout
+            });
+            rl.question('', (answer) => {
+                rl.close();
+                resolve(answer.trim());
+            });
+        });
+        if (answer === '') {
+            return 'windsurf'; // Default
+        }
+        const numChoice = parseInt(answer);
+        if (numChoice >= 1 && numChoice <= VALID_IDES.length) {
+            return VALID_IDES[numChoice - 1];
+        }
+        console.log(chalk.red('❌ Opção inválida. Por favor, digite um número entre 1 e 3.'));
+        // Loop continua para perguntar novamente
+    }
+}
 const program = new Command();
 program
     .name('maestro')
@@ -9,18 +65,51 @@ program
     .version('1.0.0')
     .option('-f, --force', 'Sobrescreve arquivos existentes')
     .option('--minimal', 'Instala apenas workflows e rules')
-    .option('--ide <ide>', 'IDE alvo: gemini, cursor, copilot, windsurf, all (default: all)', 'all')
+    .option('--ide <ide>', `IDE alvo: ${VALID_IDES.join(', ')} (opcional)`)
     .action(async (options) => {
-    // Comportamento padrão: executa init quando chamado sem subcomando
-    await init(options);
+    let selectedIDE = options.ide;
+    // Se não foi especificada, perguntar ao usuário
+    if (!selectedIDE) {
+        selectedIDE = await promptForIDEWithDefault();
+    }
+    else {
+        // Validar IDE se foi especificada
+        if (!VALID_IDES.includes(selectedIDE)) {
+            console.error(`❌ IDE inválida. Use: ${VALID_IDES.join(', ')}`);
+            console.log(chalk.cyan('\nOpções válidas:'));
+            VALID_IDES.forEach((ide, index) => {
+                console.log(chalk.white(`  ${index + 1}. ${ide}`));
+            });
+            process.exit(1);
+        }
+    }
+    await init({ ...options, ide: selectedIDE });
 });
 program
     .command('init')
     .description('Inicializa Maestro no projeto atual')
     .option('-f, --force', 'Sobrescreve arquivos existentes')
     .option('--minimal', 'Instala apenas workflows e rules')
-    .option('--ide <ide>', 'IDE alvo: gemini, cursor, copilot, windsurf, all (default: all)', 'all')
-    .action(init);
+    .option('--ide <ide>', `IDE alvo: ${VALID_IDES.join(', ')} (opcional)`)
+    .action(async (options) => {
+    let selectedIDE = options.ide;
+    // Se não foi especificada, perguntar ao usuário
+    if (!selectedIDE) {
+        selectedIDE = await promptForIDE();
+    }
+    else {
+        // Validar IDE se foi especificada
+        if (!VALID_IDES.includes(selectedIDE)) {
+            console.error(`❌ IDE inválida. Use: ${VALID_IDES.join(', ')}`);
+            console.log(chalk.cyan('\nOpções válidas:'));
+            VALID_IDES.forEach((ide, index) => {
+                console.log(chalk.white(`  ${index + 1}. ${ide}`));
+            });
+            process.exit(1);
+        }
+    }
+    init({ ...options, ide: selectedIDE });
+});
 program
     .command('update')
     .description('Atualiza content para a última versão')

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@maestro-ai/cli",
-    "version": "1.1.0",
-    "description": "CLI para inicializar projetos com Maestro - Desenvolvimento assistido por IA",
+    "version": "1.3.0",
+    "description": "CLI para inicializar projetos Maestro File System - Orquestrador chat-first com workflows inteligentes",
     "type": "module",
     "main": "dist/index.js",
     "bin": {
@@ -40,8 +40,14 @@
         "maestro",
         "ai",
         "development",
-        "mcp",
-        "cli"
+        "file-system",
+        "chat-first",
+        "workflows",
+        "orchestrator",
+        "cli",
+        "windsurf",
+        "cursor",
+        "antigravity"
     ],
     "author": "Matheus Luna",
     "license": "MIT"