sdd-toolkit 2.0.2 → 2.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "sdd-toolkit",
-    "version": "2.0.2",
+    "version": "2.1.0",
     "description": "Instalador automatico dos agentes de desenvolvimento",
     "main": "src/index.js",
     "bin": {

package/src/index.js

@@ -6,9 +6,9 @@ const path = require('path');
 const { intro, outro, multiselect, spinner, note, select, text } = require('@clack/prompts');
 const pc = require('picocolors');
 
-// Internal Modules
-const { loadAgents } = require('./lib/agents');
-const { setLocale, t, getLocale } = require('./lib/i18n');
+// Internal Modules
+const { loadAgents } = require('./lib/agents');
+const { setLocale, t, getLocale } = require('./lib/i18n');
 const {
     toGeminiTOML,
     toRooConfig,
@@ -19,7 +19,8 @@ const {
     toClaudeCommand,
     toPlainSystemPrompt,
     toTraeRules,
-    toOpenCodeAgent
+    toOpenCodeSkill,
+    toAntigravitySkill
 } = require('./lib/transformers');
 const { generateWorkflowGuide } = require('./lib/docs');
 const { view } = require('./commands/view');
@@ -71,11 +72,12 @@ async function main() {
         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(), '.kilocode'))) tools.push('kilo');
-        if (fs.existsSync(path.join(process.cwd(), '.github'))) tools.push('copilot');
+        if (fs.existsSync(path.join(process.cwd(), '.github'))) tools.push('copilot');
         if (fs.existsSync(path.join(process.cwd(), '.roo'))) tools.push('roo');
         if (fs.existsSync(path.join(process.cwd(), '.opencode'))) tools.push('opencode');
         if (fs.existsSync(path.join(process.cwd(), 'prompts'))) tools.push('web');
 
+        if (fs.existsSync(path.join(process.cwd(), '.antigravity'))) tools.push('antigravity');
         if (tools.length === 0) {
             note(t('UPGRADE.NO_CONFIG'), t('UPGRADE.NO_CONFIG_TITLE'));
         } else {
@@ -99,10 +101,10 @@ async function main() {
         }
     } catch (e) {
         s.stop(pc.red(t('SCAFFOLD.ERROR')));
-    }
-
-    // 2. Feature 3: Global Rules
-    const globalRules = await text({
+    }
+
+    // 2. Feature 3: Global Rules
+    const globalRules = await text({
         message: t('SETUP.GLOBAL_RULES'),
         placeholder: t('SETUP.GLOBAL_RULES_HINT'),
         required: false
@@ -127,7 +129,8 @@ async function main() {
             { value: 'kilo', label: t('TOOLS.KILO'), hint: '.kilocode/workflows/*.md' },
             { value: 'copilot', label: t('TOOLS.COPILOT'), hint: '.github/prompts/*.md' },
             { value: 'web', label: t('TOOLS.WEB'), hint: 'prompts/*.txt' },
-            { value: 'opencode', label: t('TOOLS.OPENCODE'), hint: '.opencode/commands/*.md' }
+            { value: 'opencode', label: t('TOOLS.OPENCODE'), hint: '.opencode/skills/*' },
+            { value: 'antigravity', label: t('TOOLS.ANTIGRAVITY'), hint: '.antigravity/skills/*' }
         ],
         required: true,
         hint: t('SETUP.TOOL_HINT')
@@ -175,17 +178,17 @@ async function processAgentsInstallation(tools, options) {
                     })
                 );
             },
-            roo: async (validAgents, options) => {
-                const targetDir = path.join(process.cwd(), '.roo', 'commands');
-                await fsp.mkdir(targetDir, { recursive: true });
-
-                await Promise.all(
-                    validAgents.map((agent) => {
-                        const md = toOpenCodeAgent(agent, options);
-                        return fsp.writeFile(path.join(targetDir, `${agent.slug}.md`), md);
-                    })
-                );
-            },
+            roo: async (validAgents, options) => {
+                const targetDir = path.join(process.cwd(), '.roo', 'commands');
+                await fsp.mkdir(targetDir, { recursive: true });
+
+                await Promise.all(
+                    validAgents.map((agent) => {
+                        const md = toOpenCodeAgent(agent, options);
+                        return fsp.writeFile(path.join(targetDir, `${agent.slug}.md`), md);
+                    })
+                );
+            },
             cline: async (validAgents, options) => {
                 const targetDir = path.join(process.cwd(), '.cline');
                 await fsp.mkdir(targetDir, { recursive: true });
@@ -212,31 +215,31 @@ async function processAgentsInstallation(tools, options) {
                     })
                 );
             },
-            claude: async (validAgents, options) => {
-                const targetDir = path.join(process.cwd(), '.claude', 'commands', 'agents');
-                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 commandsDir = path.join(process.cwd(), '.cursor', 'commands');
-                await fsp.mkdir(commandsDir, { recursive: true });
-
-                await Promise.all(
-                    validAgents.map((agent) => {
-                        const mdc = toCursorMDC(agent, options);
-                        return fsp.writeFile(path.join(commandsDir, `${agent.slug}.mdc`), mdc);
-                    })
-                );
-            },
-            kilo: async (validAgents, options) => {
-                const targetDir = path.join(process.cwd(), '.kilocode', 'workflows');
-                await fsp.mkdir(targetDir, { recursive: true });
+            claude: async (validAgents, options) => {
+                const targetDir = path.join(process.cwd(), '.claude', 'commands', 'agents');
+                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 commandsDir = path.join(process.cwd(), '.cursor', 'commands');
+                await fsp.mkdir(commandsDir, { recursive: true });
+
+                await Promise.all(
+                    validAgents.map((agent) => {
+                        const mdc = toCursorMDC(agent, options);
+                        return fsp.writeFile(path.join(commandsDir, `${agent.slug}.mdc`), mdc);
+                    })
+                );
+            },
+            kilo: async (validAgents, options) => {
+                const targetDir = path.join(process.cwd(), '.kilocode', 'workflows');
+                await fsp.mkdir(targetDir, { recursive: true });
 
                 await Promise.all(
                     validAgents.map((agent) => {
@@ -245,22 +248,22 @@ async function processAgentsInstallation(tools, options) {
                     })
                 );
             },
-            copilot: async (validAgents, options) => {
-                const githubDir = path.join(process.cwd(), '.github');
-                const promptsDir = path.join(githubDir, 'prompts');
-                await fsp.mkdir(promptsDir, { recursive: true });
-
-                await Promise.all(
-                    validAgents.map((agent) => {
-                        const md = toCopilotInstructions(agent, options);
-                        return fsp.writeFile(path.join(promptsDir, `${agent.slug}.md`), md);
-                    })
-                );
-
-                const mainAgent = validAgents.find((a) => a.slug.includes('coder')) || validAgents[0];
-                const mainInstructions = toCopilotInstructions(mainAgent, options);
-                await fsp.writeFile(path.join(githubDir, 'prompts.md'), mainInstructions);
-            },
+            copilot: async (validAgents, options) => {
+                const githubDir = path.join(process.cwd(), '.github');
+                const promptsDir = path.join(githubDir, 'prompts');
+                await fsp.mkdir(promptsDir, { recursive: true });
+
+                await Promise.all(
+                    validAgents.map((agent) => {
+                        const md = toCopilotInstructions(agent, options);
+                        return fsp.writeFile(path.join(promptsDir, `${agent.slug}.md`), md);
+                    })
+                );
+
+                const mainAgent = validAgents.find((a) => a.slug.includes('coder')) || validAgents[0];
+                const mainInstructions = toCopilotInstructions(mainAgent, options);
+                await fsp.writeFile(path.join(githubDir, 'prompts.md'), mainInstructions);
+            },
             trae: async (validAgents, options) => {
                 const traeDir = path.join(process.cwd(), '.trae');
                 await fsp.mkdir(traeDir, { recursive: true });
@@ -280,51 +283,43 @@ async function processAgentsInstallation(tools, options) {
                     })
                 );
             },
-            opencode: async (validAgents, options) => {
-                const targetDir = path.join(process.cwd(), '.opencode', 'commands');
-                await fsp.mkdir(targetDir, { recursive: true });
-
-                await Promise.all(
-                    validAgents.map((agent) => {
-                        const md = toOpenCodeAgent(agent, options);
-                        return fsp.writeFile(path.join(targetDir, `${agent.slug}.md`), md);
-                    })
-                );
-
-                // Generate AGENTS.md with interaction rules and agent location
-                const agentsMdPath = path.join(process.cwd(), 'AGENTS.md');
-                let agentsMdContent = `# Interaction Rules
-
-- Always respond to the user in the language they initially interact in; if they interact in English, respond in English, if they interact in Portuguese, respond in Portuguese.
-- If possible, display reasoning in the user's language as well.
-- Be didactic when explaining things, focus on providing complete responses and not just summaries.
-- Whenever possible, provide examples to illustrate concepts.
-
-# Allowed Commands
-
-- Never execute rm or rm -rf commands without confirming with the user.
-- Whenever possible, use more specific commands instead of generic ones.
-- Be cautious when using commands that may affect critical systems, such as shutdown or reboot.
-- For commands that may affect files or directories, always confirm with the user before executing.
-- Never execute commands that require administrative privileges (sudo, admin) without explicit permission from the user.
-- Avoid running background processes or daemons unless explicitly requested.
-- Be cautious when using commands that alter network settings, firewall configurations, or external connections.
-- Always quote file paths that contain spaces to avoid interpretation errors.
-- For package installation commands (npm install, pip install, etc.), confirm that the user has control over dependencies and versions.
-- Avoid irreversible git operations (such as force push or reset --hard) without confirmation.
-
-# Agent Location
-
-Custom agents are located in .opencode/commands/`;
-
-                let userRules = '';
-                if (options.globalRules && options.globalRules.trim()) {
-                    userRules = '\n\n# User Specified Rules\n\n' + options.globalRules.split('\n').filter(line => line.trim()).map(line => '- ' + line.trim()).join('\n');
-                }
-                agentsMdContent += userRules;
-
-                await fsp.writeFile(agentsMdPath, agentsMdContent);
-            }
+            opencode: async (validAgents, options) => {
+                const skillsDir = path.join(process.cwd(), '.opencode', 'skills');
+                
+                // Ensure base directory exists
+                await fsp.mkdir(skillsDir, { recursive: true });
+
+                await Promise.all(
+                    validAgents.map(async (agent) => {
+                         // Create specific folder for the skill: .opencode/skills/[agent-slug]/
+                         // Ensure compatibility with naming rules (lowercase, alphanumeric, single hyphens)
+                         const skillName = agent.slug.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '');
+                         const agentSkillDir = path.join(skillsDir, skillName);
+                         
+                         await fsp.mkdir(agentSkillDir, { recursive: true });
+
+                         const skillContent = toOpenCodeSkill(agent, options);
+                         return fsp.writeFile(path.join(agentSkillDir, 'SKILL.md'), skillContent);
+                    })
+                );
+            },
+            antigravity: async (validAgents, options) => {
+                const skillsDir = path.join(process.cwd(), '.antigravity', 'skills');
+                
+                // Ensure base directory exists (though we will mkdir for each agent)
+                await fsp.mkdir(skillsDir, { recursive: true });
+
+                await Promise.all(
+                    validAgents.map(async (agent) => {
+                         // Create specific folder for the skill: .antigravity/skills/[agent-slug]/
+                         const agentSkillDir = path.join(skillsDir, agent.slug);
+                         await fsp.mkdir(agentSkillDir, { recursive: true });
+
+                         const skillContent = toAntigravitySkill(agent, options);
+                         return fsp.writeFile(path.join(agentSkillDir, 'SKILL.md'), skillContent);
+                    })
+                );
+            }
         };
 
         for (const tool of tools) {

package/src/lib/messages.js

@@ -51,7 +51,8 @@ const EN = {
         KILO: 'Kilo Code',
         COPILOT: 'GitHub Copilot',
         WEB: 'OpenAI / Claude',
-        OPENCODE: 'OpenCode',
+        OPENCODE: 'OpenCode (Skills)',
+        ANTIGRAVITY: 'Antigravity (Skills)',
     },
     LANGUAGE_RULES: {
         EN: 'Always reply in English unless told otherwise.',
@@ -124,7 +125,8 @@ const PT_BR = {
         KILO: 'Kilo Code',
         COPILOT: 'GitHub Copilot',
         WEB: 'OpenAI / Claude',
-        OPENCODE: 'OpenCode',
+        OPENCODE: 'OpenCode (Skills)',
+        ANTIGRAVITY: 'Antigravity (Skills)',
     },
     LANGUAGE_RULES: {
         EN: 'Always reply in English unless told otherwise.',
@@ -197,7 +199,8 @@ const ES = {
         KILO: 'Kilo Code',
         COPILOT: 'GitHub Copilot',
         WEB: 'OpenAI / Claude',
-        OPENCODE: 'OpenCode',
+        OPENCODE: 'OpenCode (Skills)',
+        ANTIGRAVITY: 'Antigravity (Skills)',
     },
     LANGUAGE_RULES: {
         EN: 'Always reply in English unless told otherwise.',

package/src/lib/transformers.js

@@ -252,44 +252,34 @@ ${allRules.length > 0 ? '## Constraints\n' + allRules.map(r => `- ${r}`).join('\
 `;
 }
 
+
 /**
- * Converte para OpenCode Agent (.opencode/agent/*.md)
+ * Converte para OpenCode Skill (SKILL.md)
+ * Ref: https://opencode.ai/docs/skills/
  */
-function toOpenCodeAgent(agent, options = {}) {
+function toOpenCodeSkill(agent, options = {}) {
     const languageRule = getLanguageRule(options.locale);
     const allRules = [languageRule, ...(agent.rules || [])];
 
-    // Configurar permissões baseado no tipo de agente
-    const isReadOnly = agent.slug.includes('review') || agent.slug.includes('audit') || agent.name.includes('Architect') || agent.role.includes('QA') || agent.role.includes('Review');
-    const tools = {
-        write: !isReadOnly,
-        edit: !isReadOnly,
-        bash: !isReadOnly
-    };
-
-    const frontmatter = {
-        description: agent.description || agent.role,
-        mode: 'subagent',
-        temperature: 0.3,
-        tools
-    };
-
-    const frontmatterStr = Object.entries(frontmatter)
-        .map(([key, value]) => `${key}: ${JSON.stringify(value)}`)
-        .join('\n');
+    // Ensure slug is compliant (lowercase, alphanumeric, single hyphens)
+    const skillName = agent.slug.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '');
 
     return `---
-${frontmatterStr}
+name: ${skillName}
+description: ${agent.description || agent.role}
+license: MIT
+compatibility: opencode
+metadata:
+  role: ${agent.role}
 ---
-
 # ${agent.name} ${agent.emoji}
 
 **Role**: ${agent.role}
 
+## Instructions
 ${agent.systemPrompt.trim()}
 
-## Rules
-${allRules.map(rule => `- ${rule}`).join('\n')}
+${allRules.length > 0 ? '## Rules & Guidelines\n' + allRules.map(r => `- ${r}`).join('\n') : ''}
 `;
 }
 
@@ -312,6 +302,29 @@ ${allRules.length > 0 ? '## Constraints\n' + allRules.map(r => `- ${r}`).join('\
 `;
 }
 
+
+/**
+ * Converte para Antigravity Skill (SKILL.md)
+ */
+function toAntigravitySkill(agent, options = {}) {
+    const languageRule = getLanguageRule(options.locale);
+    const allRules = [languageRule, ...(agent.rules || [])];
+
+    return `---
+name: ${agent.name}
+description: ${agent.description || agent.role}
+---
+# ${agent.name} ${agent.emoji}
+
+**Role**: ${agent.role}
+
+## Instructions
+${agent.systemPrompt.trim()}
+
+${allRules.length > 0 ? '## Rules & Guidelines\n' + allRules.map(r => `- ${r}`).join('\n') : ''}
+`;
+}
+
 module.exports = {
     toGeminiTOML,
     toRooConfig,
@@ -321,6 +334,7 @@ module.exports = {
     toWindsurfRules,
     toClaudeCommand,
     toPlainSystemPrompt,
-    toOpenCodeAgent,
-    toTraeRules
+    toOpenCodeSkill,
+    toTraeRules,
+    toAntigravitySkill
 };