sdd-toolkit 1.1.0 → 1.6.0

package/src/index.js

@@ -6,201 +6,329 @@ const path = require('path');
 const { intro, outro, multiselect, spinner, note, select, text } = require('@clack/prompts');
 const pc = require('picocolors');
 
-// Módulos Internos
+// Internal Modules
 const { loadAgents } = require('./lib/agents');
 const { STACK_PROFILES } = require('./lib/profiles');
-const { 
-    toGeminiTOML, 
-    toRooConfig, 
-    toKiloMarkdown, 
+const { setLocale, t, getLocale } = require('./lib/i18n');
+const {
+    toGeminiTOML,
+    toRooConfig,
+    toKiloMarkdown,
     toCopilotInstructions,
     toCursorMDC,
     toWindsurfRules,
+    toClaudeCommand,
     toPlainSystemPrompt,
-    toTraeRules
+    toTraeRules,
+    toOpenCodeAgent
 } = require('./lib/transformers');
 const { generateWorkflowGuide } = require('./lib/docs');
+const { view } = require('./commands/view');
 
 async function main() {
     console.clear();
-    intro(pc.bgMagenta(pc.white(' UNIVERSAL SPEC CLI ')));
 
-    // 1. Scaffold Automático (Sempre executa)
-    const created = generateWorkflowGuide(process.cwd());
-    if (created) {
-        console.log(pc.green('✔ Estrutura de pastas (docs/) verificada.'));
+    const args = process.argv.slice(2);
+
+    if (args[0] === 'view') {
+        await view();
+        process.exit(0);
+    }
+
+    const isUpgrade = args.includes('upgrade') || args.includes('--upgrade');
+
+    // 0. Language Selection
+    if (!isUpgrade) {
+        intro(pc.bgMagenta(pc.white(' UNIVERSAL SPEC CLI ')));
+
+        const lang = await select({
+            message: 'Select Language / Selecione o Idioma / Seleccione el Idioma',
+            options: [
+                { value: 'en', label: 'English' },
+                { value: 'pt_br', label: 'Português (Brasil)' },
+                { value: 'es', label: 'Español' }
+            ]
+        });
+
+        if (typeof lang === 'symbol') {
+            outro(pc.yellow('Operation cancelled.'));
+            process.exit(0);
+        }
+
+        setLocale(lang);
+    } else {
+        setLocale('en');
+    }
+
+    if (isUpgrade) {
+        intro(pc.bgBlue(pc.white(t('INTRO.UPGRADE_TITLE'))));
+
+        const tools = [];
+        if (fs.existsSync(path.join(process.cwd(), '.gemini'))) tools.push('gemini');
+        if (fs.existsSync(path.join(process.cwd(), '.roo'))) tools.push('roo');
+        if (fs.existsSync(path.join(process.cwd(), '.cline'))) tools.push('cline');
+        if (fs.existsSync(path.join(process.cwd(), '.cursor'))) tools.push('cursor');
+        if (fs.existsSync(path.join(process.cwd(), '.windsurf'))) tools.push('windsurf');
+        if (fs.existsSync(path.join(process.cwd(), '.claude'))) tools.push('claude');
+        if (fs.existsSync(path.join(process.cwd(), '.trae'))) tools.push('trae');
+        if (fs.existsSync(path.join(process.cwd(), '.kilo'))) tools.push('kilo');
+        if (fs.existsSync(path.join(process.cwd(), '.github'))) tools.push('copilot');
+        if (fs.existsSync(path.join(process.cwd(), '.opencode'))) tools.push('opencode');
+        if (fs.existsSync(path.join(process.cwd(), 'prompts'))) tools.push('web');
+
+        if (tools.length === 0) {
+            note(t('UPGRADE.NO_CONFIG'), t('UPGRADE.NO_CONFIG_TITLE'));
+        } else {
+            note(t('UPGRADE.DETECTED_TOOLS', tools.join(', ')), t('UPGRADE.DETECTED_TITLE'));
+            await processAgentsInstallation(tools, { locale: getLocale() });
+            outro(pc.green(t('UPGRADE.SUCCESS')));
+            process.exit(0);
+        }
     }
 
-    // 2. Feature 5: Seleção de Stack (Profile)
+    // 1. Automatic Scaffold
+    const s = spinner();
+    s.start(t('SCAFFOLD.LOADING'));
+
+    try {
+        const stats = generateWorkflowGuide(process.cwd());
+        if (stats.created > 0) {
+            s.stop(`${t('SCAFFOLD.SUCCESS')} (${stats.created} new, ${stats.verified} verified)`);
+        } else {
+            s.stop(t('SCAFFOLD.ALREADY_EXISTS'));
+        }
+    } catch (e) {
+        s.stop(pc.red(t('SCAFFOLD.ERROR')));
+    }
+
+    // 2. Feature 5: Stack Selection
     const stackOptions = Object.entries(STACK_PROFILES).map(([key, profile]) => ({
         value: key,
         label: profile.label
     }));
 
     const stackProfile = await select({
-        message: 'Qual é o perfil da sua Stack tecnológica?',
+        message: t('SETUP.STACK_SELECT'),
         options: stackOptions,
         initialValue: 'generic'
     });
 
-    if (typeof stackProfile === 'symbol') { process.exit(0); } // Handle Cancel
+    if (typeof stackProfile === 'symbol') {
+        outro(pc.yellow(t('GENERAL.CANCELLED')));
+        process.exit(0);
+    }
 
-    // 3. Feature 3: Regras Globais (Opcional)
+    // 3. Feature 3: Global Rules
     const globalRules = await text({
-        message: 'Deseja adicionar alguma Regra Global para TODOS os agentes?',
-        placeholder: 'Ex: Responda sempre em pt-BR; Use Conventional Commits...',
+        message: t('SETUP.GLOBAL_RULES'),
+        placeholder: t('SETUP.GLOBAL_RULES_HINT'),
         required: false
     });
 
-    if (typeof globalRules === 'symbol') { process.exit(0); } // Handle Cancel
+    if (typeof globalRules === 'symbol') {
+        outro(pc.yellow(t('GENERAL.CANCELLED')));
+        process.exit(0);
+    }
 
-    // 4. Seleção de Ferramentas (Múltipla escolha)
+    // 4. Tool Selection
     const tools = await multiselect({
-        message: 'Para quais ferramentas você deseja instalar os Agentes?',
+        message: t('SETUP.TOOL_SELECT'),
         options: [
-            { 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' },
+            { value: 'gemini', label: t('TOOLS.GEMINI'), hint: '.gemini/commands/dev' },
+            { value: 'roo', label: t('TOOLS.ROO'), hint: '.roo/ & custom_modes.json' },
+            { value: 'cline', label: t('TOOLS.CLINE'), hint: '.cline/ & custom_modes.json' },
+            { value: 'cursor', label: t('TOOLS.CURSOR'), hint: '.cursor/rules/*.mdc' },
+            { value: 'windsurf', label: t('TOOLS.WINDSURF'), hint: '.windsurf/workflows/*.md' },
+            { value: 'claude', label: 'Claude Code', hint: '.claude/commands/openspec/*.md' },
+            { value: 'trae', label: t('TOOLS.TRAE'), hint: '.trae/instructions.md' },
+            { value: 'kilo', label: t('TOOLS.KILO'), hint: '.kilo/prompts/*.md' },
+            { value: 'copilot', label: t('TOOLS.COPILOT'), hint: '.github/copilot-instructions.md' },
+            { value: 'web', label: t('TOOLS.WEB'), hint: 'prompts/*.txt' },
+            { value: 'opencode', label: t('TOOLS.OPENCODE'), hint: '.opencode/*.md' }
         ],
         required: true,
-        hint: 'Espaço para selecionar, Enter para confirmar'
+        hint: t('SETUP.TOOL_HINT')
     });
 
+    if (typeof tools === 'symbol') {
+        outro(pc.yellow(t('GENERAL.CANCELLED')));
+        process.exit(0);
+    }
+
     if (!tools || tools.length === 0) {
-        outro('Nenhuma ferramenta selecionada. Operação cancelada.');
+        outro(t('SETUP.NO_TOOLS'));
         process.exit(0);
     }
 
-    await processAgentsInstallation(tools, { stackProfile, globalRules });
+    await processAgentsInstallation(tools, { stackProfile, globalRules, locale: getLocale() });
 
-    outro(pc.green('Configuração concluída com sucesso! 🚀'));
+    outro(pc.green(t('SETUP.SUCCESS')));
 }
 
 async function processAgentsInstallation(tools, options) {
     const s = spinner();
-    s.start('Carregando definições...');
+    s.start(t('INSTALL.LOADING'));
 
     try {
         const validAgents = await loadAgents(options);
 
         if (validAgents.length === 0) {
-            s.stop('Nenhum agente válido encontrado.');
+            s.stop(t('INSTALL.NO_AGENTS'));
             return;
         }
 
-        s.message(`Instalando agentes para: ${tools.join(', ')}...`);
+        s.message(t('INSTALL.INSTALLING', tools.join(', ')));
 
-        // Itera sobre cada ferramenta selecionada
-        for (const tool of tools) {
-            
-            // Instalação Específica por Ferramenta
-            if (tool === 'gemini') {
+        const toolHandlers = {
+            gemini: async (validAgents, options) => {
                 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 Promise.all(
+                    validAgents.map((agent) => {
+                        const toml = toGeminiTOML(agent, options);
+                        const fileName = `${agent.originalName}.toml`;
+                        return fsp.writeFile(path.join(targetDir, fileName), toml);
+                    })
+                );
+            },
+            roo: async (validAgents, options) => {
+                const targetDir = path.join(process.cwd(), '.roo');
                 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);
-                }));
+                await Promise.all(
+                    validAgents.map((agent) => {
+                        const md = toKiloMarkdown(agent, options);
+                        return fsp.writeFile(path.join(targetDir, `${agent.slug}.md`), md);
+                    })
+                );
 
-                const modes = validAgents.map(agent => toRooConfig(agent, agent.slug));
+                const modes = validAgents.map((agent) => toRooConfig(agent, agent.slug, options));
                 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') {
+                await fsp.writeFile(path.join(process.cwd(), 'roo_custom_modes.json'), jsonContent);
+            },
+            cline: async (validAgents, options) => {
+                const targetDir = path.join(process.cwd(), '.cline');
+                await fsp.mkdir(targetDir, { recursive: true });
+
+                await Promise.all(
+                    validAgents.map((agent) => {
+                        const md = toKiloMarkdown(agent, options);
+                        return fsp.writeFile(path.join(targetDir, `${agent.slug}.md`), md);
+                    })
+                );
+
+                const modes = validAgents.map((agent) => toRooConfig(agent, agent.slug, options));
+                const jsonContent = JSON.stringify({ customModes: modes }, null, 2);
+                await fsp.writeFile(path.join(process.cwd(), 'cline_custom_modes.json'), jsonContent);
+            },
+            windsurf: async (validAgents, options) => {
+                const targetDir = path.join(process.cwd(), '.windsurf', 'workflows');
+                await fsp.mkdir(targetDir, { recursive: true });
+
+                await Promise.all(
+                    validAgents.map((agent) => {
+                        const md = toWindsurfRules(agent, options);
+                        return fsp.writeFile(path.join(targetDir, `${agent.slug}.md`), md);
+                    })
+                );
+            },
+            claude: async (validAgents, options) => {
+                const targetDir = path.join(process.cwd(), '.claude', 'commands', 'openspec');
+                await fsp.mkdir(targetDir, { recursive: true });
+
+                await Promise.all(
+                    validAgents.map((agent) => {
+                        const md = toClaudeCommand(agent, options);
+                        return fsp.writeFile(path.join(targetDir, `${agent.slug}.md`), md);
+                    })
+                );
+            },
+            cursor: async (validAgents, options) => {
+                const rulesDir = path.join(process.cwd(), '.cursor', 'rules');
+                await fsp.mkdir(rulesDir, { recursive: true });
+
+                await Promise.all(
+                    validAgents.map((agent) => {
+                        const mdc = toCursorMDC(agent, options);
+                        return fsp.writeFile(path.join(rulesDir, `${agent.slug}.mdc`), mdc);
+                    })
+                );
+            },
+            kilo: async (validAgents, options) => {
                 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') {
+                await Promise.all(
+                    validAgents.map((agent) => {
+                        const md = toKiloMarkdown(agent, options);
+                        return fsp.writeFile(path.join(targetDir, `${agent.slug}.md`), md);
+                    })
+                );
+            },
+            copilot: async (validAgents, options) => {
                 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);
-                }));
+                await Promise.all(
+                    validAgents.map((agent) => {
+                        const md = toCopilotInstructions(agent, options);
+                        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);
+                const mainAgent = validAgents.find((a) => a.slug.includes('coder')) || validAgents[0];
+                const mainInstructions = toCopilotInstructions(mainAgent, options);
                 await fsp.writeFile(path.join(githubDir, 'copilot-instructions.md'), mainInstructions);
-            }
-            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') {
+            },
+            trae: async (validAgents, options) => {
                 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);
+
+                const mainAgent = validAgents.find((a) => a.slug.includes('coder')) || validAgents[0];
+                const rules = toTraeRules(mainAgent, options);
                 await fsp.writeFile(path.join(traeDir, 'instructions.md'), rules);
-            }
-            else if (tool === 'web') {
+            },
+            web: async (validAgents, options) => {
                 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 Promise.all(
+                    validAgents.map((agent) => {
+                        const txt = toPlainSystemPrompt(agent, options);
+                        return fsp.writeFile(path.join(targetDir, `${agent.slug}.txt`), txt);
+                    })
+                );
+            },
+            opencode: async (validAgents, options) => {
+                const targetDir = path.join(process.cwd(), '.opencode', 'agent');
                 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);
-                }));
+                await Promise.all(
+                    validAgents.map((agent) => {
+                        const md = toOpenCodeAgent(agent, options);
+                        return fsp.writeFile(path.join(targetDir, `${agent.slug}.md`), md);
+                    })
+                );
+            }
+        };
+
+        for (const tool of tools) {
+            const handler = toolHandlers[tool];
+            if (handler) {
+                await handler(validAgents, options);
             }
         }
-        
-        s.stop('Instalação finalizada!');
-        
-        // Feedback consolidado
+
+        s.stop(t('INSTALL.FINISHED'));
+
         if (tools.includes('roo') || tools.includes('cline')) {
-            note('Lembre-se de configurar os Custom Modes no settings.json para Roo/Cline.', 'Aviso');
+            note(t('INSTALL.ROO_WARNING'), t('INSTALL.ROO_WARNING_TITLE'));
         }
-
     } catch (e) {
-        s.stop('Falha');
-        console.error(pc.red(e.message));
+        s.stop(pc.red(`${t('INSTALL.FAILED')}: ${e.message}`));
+        process.exit(1);
     }
 }
 

package/src/lib/agents.js

@@ -6,45 +6,45 @@ const { STACK_PROFILES } = require('./profiles');
 const pc = require('picocolors');
 
 /**
- * Carrega e valida todas as definições de agentes da pasta definitions
- * Suporta sobrescrita local (.sdd/agents) e injeção de regras
+ * Loads and validates all agent definitions from the definitions folder.
+ * Supports local override (sdd-toolkit/agents) and rule injection.
  * 
  * @param {Object} options
- * @param {string} options.stackProfile - Chave do perfil de stack (ex: 'frontend-react')
- * @param {string} options.globalRules - Regras globais separadas por quebra de linha
- * @returns {Promise<Array>} Lista de agentes validados
+ * @param {string} options.stackProfile - Stack profile key (e.g., 'frontend-react')
+ * @param {string} options.globalRules - Global rules separated by newlines
+ * @returns {Promise<Array>} List of validated agents
  */
 async function loadAgents(options = {}) {
     const definitionsDir = path.join(__dirname, '..', '..', 'definitions');
-    const localDefinitionsDir = path.join(process.cwd(), '.sdd', 'agents');
+    const localDefinitionsDir = path.join(process.cwd(), '.sdd-toolkit', 'agents');
     
-    // Verifica diretório padrão
+    // Check default directory
     try {
         await fs.access(definitionsDir);
     } catch {
-        throw new Error(`Pasta de definições padrão não encontrada: ${definitionsDir}`);
+        throw new Error(`Default definitions folder not found: ${definitionsDir}`);
     }
 
-    // Identifica arquivos padrão
+    // Identify default files
     const files = await fs.readdir(definitionsDir);
     const yamlFiles = files.filter(f => f.endsWith('.yaml') || f.endsWith('.yml'));
 
-    // Verifica se existe diretório de sobrescrita local
+    // Check if local override directory exists
     let hasLocalOverrides = false;
     try {
         await fs.access(localDefinitionsDir);
         hasLocalOverrides = true;
     } catch {
-        // Ignora se não existir
+        // Ignore if it doesn't exist
     }
     
-    // Leitura e processamento em paralelo
+    // Parallel reading and processing
     const results = await Promise.all(yamlFiles.map(async (file) => {
         try {
             let content;
             let source = 'default';
 
-            // Feature 2: Sobrescrita Local
+            // Feature 2: Local Override
             if (hasLocalOverrides) {
                 try {
                     const localPath = path.join(localDefinitionsDir, file);
@@ -52,7 +52,7 @@ async function loadAgents(options = {}) {
                     content = await fs.readFile(localPath, 'utf8');
                     source = 'local';
                 } catch {
-                    // Arquivo local não existe, usa padrão
+                    // Local file doesn't exist, use default
                 }
             }
 
@@ -67,19 +67,19 @@ async function loadAgents(options = {}) {
                 return { 
                     success: false, 
                     file, 
-                    error: 'Validação do Schema falhou',
+                    error: 'Schema validation failed',
                     details: parsed.error.format()
                 };
             }
 
             const agent = parsed.data;
             
-            // Normaliza o slug
+            // Normalize slug
             agent.slug = file.replace(/\.ya?ml$/, '').replace(/\./g, '-');
             agent.originalName = file.replace(/\.ya?ml$/, '');
-            agent.source = source; // Metadata útil para logs
+            agent.source = source; // Useful metadata for logs
 
-            // Feature 5: Injeção de Regras de Stack
+            // Feature 5: Stack Rules Injection
             if (options.stackProfile && STACK_PROFILES[options.stackProfile]) {
                 const stackRules = STACK_PROFILES[options.stackProfile].rules;
                 if (stackRules && stackRules.length > 0) {
@@ -87,7 +87,7 @@ async function loadAgents(options = {}) {
                 }
             }
 
-            // Feature 3: Injeção de Regras Globais
+            // Feature 3: Global Rules Injection
             if (options.globalRules && typeof options.globalRules === 'string') {
                 const customRules = options.globalRules
                     .split('\n')
@@ -106,7 +106,7 @@ async function loadAgents(options = {}) {
         }
     }));
 
-    // Separa sucessos e falhas
+    // Separate successes and failures
     const validAgents = [];
     const errors = [];
 
@@ -115,7 +115,7 @@ async function loadAgents(options = {}) {
             validAgents.push(res.agent);
         } else {
             errors.push(res);
-            console.warn(pc.yellow(`⚠️  Ignorando ${res.file}: ${res.error}`));
+            console.warn(pc.yellow(`⚠️  Skipping ${res.file}: ${res.error}`));
         }
     });