agents.dev 1.0.8 → 1.5.0

package/README.md

@@ -1,17 +1,23 @@
 # agents-dev (Universal Spec CLI)
 
-Ferramenta CLI para configurar automaticamente o ambiente de desenvolvimento e instalar agentes de IA (Auditor, Coder, etc.) para diversas ferramentas como Gemini CLI, Roo Code, Cline e Kilo Code.
+Ferramenta CLI para configurar automaticamente o ambiente de desenvolvimento e instalar agentes de IA (Auditor, Coder, etc.) para diversas ferramentas modernas de IA.
 
 ## Funcionalidades
 
 ### 1. Instalação de Agentes de IA
 Lê definições agnósticas (YAML) e converte para formatos específicos:
 *   **Gemini CLI:** Gera arquivos de configuração `.toml`.
-*   **Roo Code / Cline:** Gera modos customizados (`_custom_modes.json`).
+*   **Roo Code / Cline:** Gera modos customizados (`_custom_modes.json`) e regras de contexto em `.roo/` ou `.cline/`.
+*   **GitHub Copilot:** Gera instruções em `.github/copilot-instructions.md` e agentes em `.github/agents/`.
+*   **Cursor:** Gera regras em `.cursor/rules/*.mdc`.
+*   **Windsurf:** Gera regras em `.windsurfrules`.
+*   **Trae:** Gera instruções em `.trae/instructions.md`.
+*   **OpenCode:** Gera agentes em `.opencode/`.
+*   **OpenAI / Claude (Web):** Gera prompts em texto puro na pasta `prompts/`.
 *   **Kilo Code:** Gera prompts em Markdown (`.kilo/prompts/*.md`).
 
-### 2. Configuração
-Automatiza a criação de arquivos de configuração necessários para integrar agentes de IA ao seu fluxo de trabalho.
+### 2. Configuração de Workflow
+Automatiza a criação da estrutura de documentação (`docs/` e `docs/logs/`) para suportar o fluxo de trabalho dos agentes.
 
 ## Instalação e Uso
 
@@ -20,6 +26,7 @@ Você pode executar a ferramenta diretamente via `npx` sem instalação prévia:
 ```bash
 npx agents-dev
 ```
+*(ou `npx agents.dev`)*
 
 Ou instalar globalmente:
 
@@ -31,8 +38,8 @@ agents-dev
 ## Como funciona
 
 1.  Execute `npx agents-dev` na raiz do seu projeto.
-2.  A interface interativa perguntará quais configurações você deseja aplicar.
-3.  Os arquivos de configuração dos agentes serão gerados na pasta do seu projeto.
+2.  A interface interativa perguntará quais configurações você deseja aplicar e para qual ferramenta.
+3.  Os arquivos de configuração dos agentes serão gerados na pasta do seu projeto automaticamente.
 
 ## Estrutura do Projeto
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "agents.dev",
-    "version": "1.0.8",
+    "version": "1.5.0",
     "description": "Instalador automático dos agentes de desenvolvimento",
     "main": "src/index.js",
     "bin": {

package/src/index.js

@@ -1,134 +1,178 @@
 #!/usr/bin/env node
 
 const fs = require('fs');
+const fsp = require('fs/promises');
 const path = require('path');
-const yaml = require('js-yaml');
-const { intro, outro, multiselect, select, spinner, note } = require('@clack/prompts');
+const { intro, outro, multiselect, spinner, note } = require('@clack/prompts');
 const pc = require('picocolors');
 
 // Módulos Internos
-const { AgentSchema } = require('./lib/schema');
-const { toGeminiTOML, toRooConfig, toKiloMarkdown } = require('./lib/transformers');
+const { loadAgents } = require('./lib/agents');
+const { 
+    toGeminiTOML, 
+    toRooConfig, 
+    toKiloMarkdown, 
+    toCopilotInstructions,
+    toCursorMDC,
+    toWindsurfRules,
+    toPlainSystemPrompt,
+    toTraeRules
+} = require('./lib/transformers');
 const { generateWorkflowGuide } = require('./lib/docs');
 
 async function main() {
     console.clear();
     intro(pc.bgMagenta(pc.white(' UNIVERSAL SPEC CLI ')));
 
-    // 1. Seleção de Componentes
-    const components = await multiselect({
-        message: 'O que você deseja configurar?',
+    // 1. Scaffold Automático (Sempre executa)
+    const created = generateWorkflowGuide(process.cwd());
+    if (created) {
+        console.log(pc.green('✔ Estrutura de pastas (docs/) verificada.'));
+    }
+
+    // 2. Seleção de Ferramentas (Múltipla escolha)
+    const tools = await multiselect({
+        message: 'Para quais ferramentas você deseja instalar os Agentes?',
         options: [
-            { value: 'docs', label: 'Gerar Documentação de Workflow (docs/README.md)', hint: 'Essencial' },
-            { value: 'agents', label: 'Instalar Agentes de IA', hint: 'Recomendado' },
-            { value: 'vscode', label: 'Configurar VS Code', hint: '(Simulado)' },
+            { value: 'gemini', label: 'Gemini CLI', hint: '.gemini/commands/dev' },
+            { value: 'roo', label: 'Roo Code', hint: '.roo/ & custom_modes.json' },
+            { value: 'cline', label: 'Cline', hint: '.cline/ & custom_modes.json' },
+            { value: 'cursor', label: 'Cursor', hint: '.cursor/rules/*.mdc' },
+            { value: 'windsurf', label: 'Windsurf', hint: '.windsurfrules' },
+            { value: 'trae', label: 'Trae IDE', hint: '.trae/instructions.md' },
+            { value: 'kilo', label: 'Kilo Code', hint: '.kilo/prompts/*.md' },
+            { value: 'copilot', label: 'GitHub Copilot', hint: '.github/copilot-instructions.md' },
+            { value: 'web', label: 'OpenAI / Claude', hint: 'prompts/*.txt' },
+            { value: 'opencode', label: 'OpenCode', hint: '.opencode/*.md' },
         ],
         required: true,
+        hint: 'Espaço para selecionar, Enter para confirmar'
     });
 
-    if (!components) {
-        outro('Operação cancelada.');
+    if (!tools || tools.length === 0) {
+        outro('Nenhuma ferramenta selecionada. Operação cancelada.');
         process.exit(0);
     }
 
-    // 2. Instalação de Documentação
-    if (components.includes('docs')) {
-        const created = generateWorkflowGuide(process.cwd());
-        if (created) {
-            note('Documentação criada em docs/README.md', 'Docs');
-        } else {
-            console.log(pc.gray('ℹ️  Pasta docs/ já existe. Ignorando criação.'));
-        }
-    }
-
-    // 3. Instalação de Agentes
-    if (components.includes('agents')) {
-        const tool = await select({
-            message: 'Onde você deseja instalar os Agentes?',
-            options: [
-                { value: 'gemini', label: 'Gemini CLI', hint: '.gemini/commands/dev' },
-                { value: 'roo', label: 'Roo Code', hint: 'Gera roo_custom_modes.json' },
-                { value: 'cline', label: 'Cline', hint: 'Gera cline_custom_modes.json' },
-                { value: 'kilo', label: 'Kilo Code', hint: '.kilo/prompts/*.md' },
-            ],
-        });
-
-        if (!tool) process.exit(0);
-
-        await processAgentsInstallation(tool);
-    }
+    await processAgentsInstallation(tools);
 
     outro(pc.green('Configuração concluída com sucesso! 🚀'));
 }
 
-async function processAgentsInstallation(tool) {
+async function processAgentsInstallation(tools) {
     const s = spinner();
     s.start('Carregando definições...');
 
-    const definitionsDir = path.join(__dirname, '..', 'definitions');
-    if (!fs.existsSync(definitionsDir)) {
-        s.stop('Falha');
-        note(`Pasta de definições não encontrada: ${definitionsDir}`, 'Erro Fatal');
-        return;
-    }
-
-    const files = fs.readdirSync(definitionsDir).filter(f => f.endsWith('.yaml') || f.endsWith('.yml'));
-    const validAgents = [];
-
-    // Validação e Carregamento
-    for (const file of files) {
-        try {
-            const content = fs.readFileSync(path.join(definitionsDir, file), 'utf8');
-            const raw = yaml.load(content);
-            
-            // Validação com Zod
-            const parsed = AgentSchema.safeParse(raw);
-            if (!parsed.success) {
-                console.warn(pc.yellow(`⚠️  Ignorando ${file}: Inválido`));
-                continue;
-            }
-
-            const agent = parsed.data;
-            agent.slug = file.replace(/\.ya?ml$/, '').replace(/\./g, '-'); // dev.coder -> dev-coder
-            validAgents.push(agent);
+    try {
+        const validAgents = await loadAgents();
 
-        } catch (e) {
-            console.error(pc.red(`Erro ao ler ${file}: ${e.message}`));
+        if (validAgents.length === 0) {
+            s.stop('Nenhum agente válido encontrado.');
+            return;
         }
-    }
 
-    s.message(`Instalando ${validAgents.length} agentes para ${tool}...`);
+        s.message(`Instalando agentes para: ${tools.join(', ')}...`);
 
-    // Instalação Específica por Ferramenta
-    try {
-        if (tool === 'gemini') {
-            const targetDir = path.join(process.cwd(), '.gemini', 'commands', 'dev');
-            if (!fs.existsSync(targetDir)) fs.mkdirSync(targetDir, { recursive: true });
-
-            for (const agent of validAgents) {
-                const toml = toGeminiTOML(agent);
-                // Nome original com pontos (dev.coder.toml) é preferível para Gemini CLI
-                const fileName = `${agent.slug.replace(/-/g, '.')}.toml`; 
-                fs.writeFileSync(path.join(targetDir, fileName), toml);
+        // Itera sobre cada ferramenta selecionada
+        for (const tool of tools) {
+            
+            // Instalação Específica por Ferramenta
+            if (tool === 'gemini') {
+                const targetDir = path.join(process.cwd(), '.gemini', 'commands', 'dev');
+                await fsp.mkdir(targetDir, { recursive: true });
+
+                await Promise.all(validAgents.map(agent => {
+                    const toml = toGeminiTOML(agent);
+                    const fileName = `${agent.originalName}.toml`; 
+                    return fsp.writeFile(path.join(targetDir, fileName), toml);
+                }));
+            } 
+            else if (tool === 'roo' || tool === 'cline') {
+                const configDir = tool === 'roo' ? '.roo' : '.cline';
+                const targetDir = path.join(process.cwd(), configDir);
+                await fsp.mkdir(targetDir, { recursive: true });
+
+                await Promise.all(validAgents.map(agent => {
+                    const md = toKiloMarkdown(agent);
+                    return fsp.writeFile(path.join(targetDir, `${agent.slug}.md`), md);
+                }));
+
+                const modes = validAgents.map(agent => toRooConfig(agent, agent.slug));
+                const jsonContent = JSON.stringify({ customModes: modes }, null, 2);
+                const fileName = `${tool}_custom_modes.json`;
+                await fsp.writeFile(path.join(process.cwd(), fileName), jsonContent);
+            } 
+            else if (tool === 'kilo') {
+                const targetDir = path.join(process.cwd(), '.kilo', 'prompts');
+                await fsp.mkdir(targetDir, { recursive: true });
+
+                await Promise.all(validAgents.map(agent => {
+                    const md = toKiloMarkdown(agent);
+                    return fsp.writeFile(path.join(targetDir, `${agent.slug}.md`), md);
+                }));
+            }
+            else if (tool === 'copilot') {
+                const githubDir = path.join(process.cwd(), '.github');
+                const agentsDir = path.join(githubDir, 'agents');
+                await fsp.mkdir(agentsDir, { recursive: true });
+
+                await Promise.all(validAgents.map(agent => {
+                    const md = toCopilotInstructions(agent);
+                    return fsp.writeFile(path.join(agentsDir, `${agent.slug}.md`), md);
+                }));
+
+                const mainAgent = validAgents.find(a => a.slug.includes('coder')) || validAgents[0];
+                const mainInstructions = toCopilotInstructions(mainAgent);
+                await fsp.writeFile(path.join(githubDir, 'copilot-instructions.md'), mainInstructions);
             }
-        } 
-        else if (tool === 'roo' || tool === 'cline') {
-            const modes = validAgents.map(agent => toRooConfig(agent, agent.slug));
-            const jsonContent = JSON.stringify({ customModes: modes }, null, 2);
-            const fileName = `${tool}_custom_modes.json`;
-            fs.writeFileSync(path.join(process.cwd(), fileName), jsonContent);
-            note(`Copie o conteúdo de '${fileName}' para as configurações da extensão.`, 'Ação Manual');
-        } 
-        else if (tool === 'kilo') {
-            const targetDir = path.join(process.cwd(), '.kilo', 'prompts');
-            if (!fs.existsSync(targetDir)) fs.mkdirSync(targetDir, { recursive: true });
-
-            for (const agent of validAgents) {
-                const md = toKiloMarkdown(agent);
-                fs.writeFileSync(path.join(targetDir, `${agent.slug}.md`), md);
+            else if (tool === 'cursor') {
+                const rulesDir = path.join(process.cwd(), '.cursor', 'rules');
+                await fsp.mkdir(rulesDir, { recursive: true });
+
+                await Promise.all(validAgents.map(agent => {
+                    const mdc = toCursorMDC(agent);
+                    return fsp.writeFile(path.join(rulesDir, `${agent.slug}.mdc`), mdc);
+                }));
+            }
+            else if (tool === 'windsurf') {
+                const mainAgent = validAgents.find(a => a.slug.includes('coder')) || validAgents[0];
+                const rules = toWindsurfRules(mainAgent);
+                await fsp.writeFile(path.join(process.cwd(), '.windsurfrules'), rules);
+            }
+            else if (tool === 'trae') {
+                const traeDir = path.join(process.cwd(), '.trae');
+                await fsp.mkdir(traeDir, { recursive: true });
+                
+                const mainAgent = validAgents.find(a => a.slug.includes('coder')) || validAgents[0];
+                const rules = toTraeRules(mainAgent);
+                await fsp.writeFile(path.join(traeDir, 'instructions.md'), rules);
+            }
+            else if (tool === 'web') {
+                const targetDir = path.join(process.cwd(), 'prompts');
+                await fsp.mkdir(targetDir, { recursive: true });
+
+                await Promise.all(validAgents.map(agent => {
+                    const txt = toPlainSystemPrompt(agent);
+                    return fsp.writeFile(path.join(targetDir, `${agent.slug}.txt`), txt);
+                }));
+            }
+            else if (tool === 'opencode') {
+                const targetDir = path.join(process.cwd(), '.opencode');
+                await fsp.mkdir(targetDir, { recursive: true });
+
+                await Promise.all(validAgents.map(agent => {
+                    const md = toKiloMarkdown(agent);
+                    return fsp.writeFile(path.join(targetDir, `${agent.slug}.md`), md);
+                }));
             }
         }
+        
         s.stop('Instalação finalizada!');
+        
+        // Feedback consolidado
+        if (tools.includes('roo') || tools.includes('cline')) {
+            note('Lembre-se de configurar os Custom Modes no settings.json para Roo/Cline.', 'Aviso');
+        }
 
     } catch (e) {
         s.stop('Falha');

package/src/lib/agents.js

@@ -0,0 +1,68 @@
+const fs = require('fs/promises');
+const path = require('path');
+const yaml = require('js-yaml');
+const { AgentSchema } = require('./schema');
+const pc = require('picocolors');
+
+/**
+ * Carrega e valida todas as definições de agentes da pasta definitions
+ * @returns {Promise<Array>} Lista de agentes validados
+ */
+async function loadAgents() {
+    const definitionsDir = path.join(__dirname, '..', '..', 'definitions');
+    
+    try {
+        await fs.access(definitionsDir);
+    } catch {
+        throw new Error(`Pasta de definições não encontrada: ${definitionsDir}`);
+    }
+
+    const files = await fs.readdir(definitionsDir);
+    const yamlFiles = files.filter(f => f.endsWith('.yaml') || f.endsWith('.yml'));
+    
+    // Leitura e processamento em paralelo
+    const results = await Promise.all(yamlFiles.map(async (file) => {
+        try {
+            const content = await fs.readFile(path.join(definitionsDir, file), 'utf8');
+            const raw = yaml.load(content);
+            
+            const parsed = AgentSchema.safeParse(raw);
+            if (!parsed.success) {
+                return { 
+                    success: false, 
+                    file, 
+                    error: 'Validação do Schema falhou',
+                    details: parsed.error.format()
+                };
+            }
+
+            const agent = parsed.data;
+            // Normaliza o slug: dev.coder -> dev-coder
+            agent.slug = file.replace(/\.ya?ml$/, '').replace(/\./g, '-');
+            // Mantém o nome original do arquivo para referência (útil para Gemini CLI)
+            agent.originalName = file.replace(/\.ya?ml$/, '');
+            
+            return { success: true, agent };
+
+        } catch (e) {
+            return { success: false, file, error: e.message };
+        }
+    }));
+
+    // Separa sucessos e falhas
+    const validAgents = [];
+    const errors = [];
+
+    results.forEach(res => {
+        if (res.success) {
+            validAgents.push(res.agent);
+        } else {
+            errors.push(res);
+            console.warn(pc.yellow(`⚠️  Ignorando ${res.file}: ${res.error}`));
+        }
+    });
+
+    return validAgents;
+}
+
+module.exports = { loadAgents };

package/src/lib/docs.js

@@ -3,12 +3,18 @@ const path = require('path');
 const pc = require('picocolors');
 
 /**
- * Gera o guia de workflow do projeto
+ * Gera o guia de workflow e a estrutura de pastas necessária para os agentes
  */
 function generateWorkflowGuide(baseDir) {
     const docsDir = path.join(baseDir, 'docs');
+    const logsDir = path.join(docsDir, 'logs');
     
-    // Conteúdo baseado no exemplo provided
+    // Cria a estrutura de pastas recursivamente (Funciona em Windows, Mac e Linux)
+    if (!fs.existsSync(logsDir)) {
+        fs.mkdirSync(logsDir, { recursive: true });
+    }
+
+    // Conteúdo do README.md
     const content = `# 🤖 Agent Workflow Guide
 
 Este documento descreve o fluxo de desenvolvimento padrão usando os Agentes instalados.
@@ -86,12 +92,13 @@ O sistema segue um processo **Waterfall** para planejamento (precisão) e **Iter
 \`changelog.md\`
 `;
 
-    if (!fs.existsSync(docsDir)) {
-        fs.mkdirSync(docsDir, { recursive: true });
-        fs.writeFileSync(path.join(docsDir, 'README.md'), content);
+    const readmePath = path.join(docsDir, 'README.md');
+    if (!fs.existsSync(readmePath)) {
+        fs.writeFileSync(readmePath, content);
         return true;
     }
-    return false;
+    
+    return true; // Retorna true indicando que a estrutura foi garantida
 }
 
 module.exports = { generateWorkflowGuide };

package/src/lib/transformers.js

@@ -86,4 +86,114 @@ function toKiloMarkdown(agent) {
     return parts.join('\n');
 }
 
-module.exports = { toGeminiTOML, toRooConfig, toKiloMarkdown };
+/**
+ * Converte para Instruções do GitHub Copilot (.github/copilot-instructions.md)
+ */
+function toCopilotInstructions(agent) {
+    const parts = [
+        `<!-- GitHub Copilot Instructions for ${agent.name} -->`,
+        `# Identity and Role`,
+        `You are **${agent.name}** ${agent.emoji}.`,
+        `**Role**: ${agent.role}`,
+        `\n## Core Instructions`,
+        agent.systemPrompt.trim(),
+        '\n'
+    ];
+
+    if (agent.rules && agent.rules.length > 0) {
+        parts.push(`## Rules & Guidelines`);
+        agent.rules.forEach(rule => parts.push(`- ${rule}`));
+    }
+    
+    // Adiciona uma seção de estilo de resposta para garantir conformidade
+    parts.push(`\n## Response Style`);
+    parts.push(`- Be concise and objective.`);
+    parts.push(`- Use Portuguese (Brazil) unless told otherwise.`);
+    parts.push(`- Follow the project conventions defined in the workspace.`);
+
+    return parts.join('\n');
+}
+
+/**
+ * Converte para Cursor Rules (.mdc)
+ * Inclui Frontmatter para Contexto
+ */
+function toCursorMDC(agent) {
+    // Tenta inferir globs baseados no papel do agente
+    let globs = "*";
+    const roleLower = agent.slug.toLowerCase();
+    
+    if (roleLower.includes('test') || roleLower.includes('qa')) globs = "*.test.*, *.spec.*, **/tests/**";
+    if (roleLower.includes('css') || roleLower.includes('style')) globs = "*.css, *.scss, *.tailwind";
+    if (roleLower.includes('sql') || roleLower.includes('db')) globs = "*.sql, *.prisma, *.schema";
+
+    return `---
+description: ${agent.description || agent.role}
+globs: ${globs}
+---
+# ${agent.name} ${agent.emoji}
+
+Role: ${agent.role}
+
+## Instructions
+${agent.systemPrompt.trim()}
+
+${agent.rules && agent.rules.length > 0 ? '## Rules\n' + agent.rules.map(r => `- ${r}`).join('\n') : ''}
+`;
+}
+
+/**
+ * Converte para Windsurf (.windsurfrules)
+ */
+function toWindsurfRules(agent) {
+    return `# ${agent.name} ${agent.emoji} Rules
+
+Role: ${agent.role}
+
+## Core Logic
+${agent.systemPrompt.trim()}
+
+${agent.rules && agent.rules.length > 0 ? '## Guidelines\n' + agent.rules.map(r => `- ${r}`).join('\n') : ''}
+`;
+}
+
+/**
+ * Converte para System Prompt Puro (OpenAI/Claude/Web)
+ */
+function toPlainSystemPrompt(agent) {
+    return `You are ${agent.name} ${agent.emoji}
+Role: ${agent.role}
+
+[SYSTEM INSTRUCTIONS]
+${agent.systemPrompt.trim()}
+
+${agent.rules && agent.rules.length > 0 ? '[GUIDELINES]\n' + agent.rules.map(r => `- ${r}`).join('\n') : ''}
+`;
+}
+
+/**
+ * Converte para Trae Instructions
+ */
+function toTraeRules(agent) {
+    return `<!-- Trae Workspace Rules -->
+# ${agent.name} ${agent.emoji}
+
+**Role**: ${agent.role}
+
+## Context & Instructions
+${agent.systemPrompt.trim()}
+
+${agent.rules && agent.rules.length > 0 ? '## Constraints\n' + agent.rules.map(r => `- ${r}`).join('\n') : ''}
+`;
+}
+
+module.exports = { 
+    toGeminiTOML, 
+    toRooConfig, 
+    toKiloMarkdown, 
+    toCopilotInstructions,
+    toCursorMDC,
+    toWindsurfRules,
+    toPlainSystemPrompt,
+    toTraeRules
+};