cli-ai-skills 1.9.0 → 1.10.0

package/bin/cli.js

@@ -8,6 +8,9 @@ const { installClaudeSkills } = require('../lib/claude');
 const { install: installCodexSkills } = require('../lib/codex');
 const { install: installOpenCodeSkills } = require('../lib/opencode');
 const { install: installGeminiSkills } = require('../lib/gemini');
+const { install: installAntigravitySkills } = require('../lib/antigravity');
+const { install: installCursorSkills } = require('../lib/cursor');
+const { install: installAdalSkills } = require('../lib/adal');
 const { listBundles, validateBundle } = require('../lib/bundles');
 const { searchSkills } = require('../lib/search');
 const { displayToolsTable } = require('../lib/ui/table');
@@ -94,16 +97,17 @@ async function main() {
     
     // Display tools table
     displayToolsTable(detected);
-    
-    const hasAny = detected.copilot.installed || detected.claude.installed || 
-                   detected.codex_cli.installed || detected.codex_app.installed || detected.opencode.installed || 
-                   detected.gemini.installed;
-    
+
+    const hasAny = detected.copilot.installed || detected.claude.installed ||
+                   detected.codex_cli.installed || detected.codex_app.installed || detected.opencode.installed ||
+                   detected.gemini.installed || detected.antigravity.installed ||
+                   detected.cursor.installed || detected.adal.installed;
+
     if (!hasAny) {
       console.log(getInstallInstructions());
       process.exit(1);
     }
-    
+
     // Check for --yes flag (skip prompts)
     const skipPrompt = args.includes('-y') || args.includes('--yes');
     
@@ -115,6 +119,9 @@ async function main() {
       if (detected.codex_cli.installed) platforms.push('codex_cli');
       if (detected.opencode.installed) platforms.push('opencode');
       if (detected.gemini.installed) platforms.push('gemini');
+      if (detected.antigravity.installed) platforms.push('antigravity');
+      if (detected.cursor.installed) platforms.push('cursor');
+      if (detected.adal.installed) platforms.push('adal');
     } else {
       platforms = await promptPlatforms(detected);
     }
@@ -149,6 +156,15 @@ async function main() {
       if (platforms.includes('gemini')) {
         installGeminiSkills(repoPath, [skill], quiet);
       }
+      if (platforms.includes('antigravity')) {
+        installAntigravitySkills(repoPath, [skill], quiet);
+      }
+      if (platforms.includes('cursor')) {
+        installCursorSkills(repoPath, [skill], quiet);
+      }
+      if (platforms.includes('adal')) {
+        installAdalSkills(repoPath, [skill], quiet);
+      }
     });
     
     if (!quiet) {
@@ -165,11 +181,12 @@ async function main() {
     
     // Display tools table
     displayToolsTable(detected);
-    
-    const hasAny = detected.copilot.installed || detected.claude.installed || 
-                   detected.codex_cli.installed || detected.codex_app.installed || detected.opencode.installed || 
-                   detected.gemini.installed;
-    
+
+    const hasAny = detected.copilot.installed || detected.claude.installed ||
+                   detected.codex_cli.installed || detected.codex_app.installed || detected.opencode.installed ||
+                   detected.gemini.installed || detected.antigravity.installed ||
+                   detected.cursor.installed || detected.adal.installed;
+
     if (!hasAny) {
       console.log(getInstallInstructions());
       process.exit(1);
@@ -231,6 +248,9 @@ async function main() {
       if (detected.codex_app.installed) platforms.push('codex_app');
       if (detected.opencode.installed) platforms.push('opencode');
       if (detected.gemini.installed) platforms.push('gemini');
+      if (detected.antigravity.installed) platforms.push('antigravity');
+      if (detected.cursor.installed) platforms.push('cursor');
+      if (detected.adal.installed) platforms.push('adal');
     } else {
       // Interactive selection
       platforms = await promptPlatforms(detected);
@@ -271,7 +291,19 @@ async function main() {
     if (platforms.includes('gemini')) {
       installGeminiSkills(repoPath, null, quiet);
     }
-    
+
+    if (platforms.includes('antigravity')) {
+      installAntigravitySkills(repoPath, null, quiet);
+    }
+
+    if (platforms.includes('cursor')) {
+      installCursorSkills(repoPath, null, quiet);
+    }
+
+    if (platforms.includes('adal')) {
+      installAdalSkills(repoPath, null, quiet);
+    }
+
     if (!quiet) {
       console.log(chalk.green(`\n✅ Instalação concluída com sucesso!\n`));
     }

package/lib/adal.js

@@ -0,0 +1,73 @@
+const fs = require('fs-extra');
+const path = require('path');
+const chalk = require('chalk');
+const os = require('os');
+const { getSkillsSourcePath, getUserSkillsPath } = require('./utils/path-resolver');
+
+/**
+ * Install skills for AdaL CLI
+ * @param {string} repoPath - Path to the cli-ai-skills repository
+ * @param {Array<string>|null} skills - Skills to install (null = all)
+ * @param {boolean} quiet - Suppress output
+ */
+function install(repoPath, skills = null, quiet = false) {
+  const targetDir = getUserSkillsPath('adal');
+
+  // Criar diretório se não existir
+  fs.ensureDirSync(targetDir);
+
+  const sourceDir = getSkillsSourcePath(repoPath, 'adal');
+  
+  if (!fs.existsSync(sourceDir)) {
+    if (!quiet) {
+      console.log(chalk.red('❌ Diretório .adal/skills não encontrado no repositório'));
+    }
+    return;
+  }
+  
+  // Listar skills disponíveis
+  const availableSkills = fs.readdirSync(sourceDir).filter(f => {
+    const fullPath = path.join(sourceDir, f);
+    return fs.statSync(fullPath).isDirectory() && f !== 'node_modules';
+  });
+  
+  const skillsToInstall = skills || availableSkills;
+  
+  let installed = 0;
+  let failed = 0;
+  
+  skillsToInstall.forEach(skill => {
+    const sourcePath = path.join(sourceDir, skill);
+    const targetPath = path.join(targetDir, skill);
+    
+    if (!fs.existsSync(sourcePath)) {
+      if (!quiet) {
+        console.log(chalk.yellow(`⚠️  Skill não encontrada: ${skill}`));
+      }
+      failed++;
+      return;
+    }
+    
+    // Criar symlink
+    try {
+      if (fs.existsSync(targetPath)) {
+        fs.removeSync(targetPath);
+      }
+      fs.symlinkSync(sourcePath, targetPath);
+      
+      if (!quiet) {
+        console.log(chalk.green(`  ✓ AdaL: ${skill}`));
+      }
+      installed++;
+    } catch (err) {
+      if (!quiet) {
+        console.log(chalk.red(`  ✗ Erro ao instalar ${skill}: ${err.message}`));
+      }
+      failed++;
+    }
+  });
+  
+  return { installed, failed };
+}
+
+module.exports = { install };

package/lib/antigravity.js

@@ -0,0 +1,77 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const chalk = require('chalk');
+const { getSkillsSourcePath, getUserSkillsPath } = require('./utils/path-resolver');
+
+/**
+ * Install skills for Google Antigravity
+ * @param {string} repoPath - Path to the cli-ai-skills repository
+ * @param {Array<string>|null} skills - Skills to install (null = all)
+ * @param {boolean} quiet - Suppress output
+ */
+function install(repoPath, skills = null, quiet = false) {
+  const targetDir = getUserSkillsPath('antigravity');
+
+  // Create directory if it doesn't exist
+  if (!fs.existsSync(targetDir)) {
+    fs.mkdirSync(targetDir, { recursive: true });
+  }
+
+  const sourceDir = getSkillsSourcePath(repoPath, 'antigravity');
+
+  if (!fs.existsSync(sourceDir)) {
+    if (!quiet) {
+      console.log(chalk.red('❌ Diretório .antigravity/skills não encontrado no repositório'));
+    }
+    return { installed: 0, failed: 0 };
+  }
+
+  // List available skills
+  const availableSkills = fs.readdirSync(sourceDir).filter(f => {
+    const fullPath = path.join(sourceDir, f);
+    return fs.statSync(fullPath).isDirectory() && f !== 'node_modules';
+  });
+
+  const skillsToInstall = skills || availableSkills;
+
+  let installed = 0;
+  let failed = 0;
+
+  skillsToInstall.forEach(skill => {
+    const sourcePath = path.join(sourceDir, skill);
+    const targetPath = path.join(targetDir, skill);
+
+    if (!fs.existsSync(sourcePath)) {
+      if (!quiet) {
+        console.log(chalk.yellow(`⚠️  Skill não encontrada: ${skill}`));
+      }
+      failed++;
+      return;
+    }
+
+    // Create symlink (use absolute path to avoid broken symlinks)
+    try {
+      if (fs.existsSync(targetPath)) {
+        fs.rmSync(targetPath, { recursive: true, force: true });
+      }
+      // Use absolute path for symlink target
+      const absoluteSourcePath = path.isAbsolute(sourcePath) ? sourcePath : path.resolve(sourcePath);
+      fs.symlinkSync(absoluteSourcePath, targetPath);
+
+      if (!quiet) {
+        console.log(chalk.green(`  ✓ Antigravity: ${skill}`));
+      }
+      installed++;
+    } catch (err) {
+      if (!quiet) {
+        console.log(chalk.red(`  ✗ Erro ao instalar ${skill}: ${err.message}`));
+      }
+      failed++;
+    }
+  });
+
+  return { installed, failed };
+}
+
+module.exports = { install };

package/lib/cursor.js

@@ -0,0 +1,73 @@
+const fs = require('fs-extra');
+const path = require('path');
+const chalk = require('chalk');
+const os = require('os');
+const { getSkillsSourcePath, getUserSkillsPath } = require('./utils/path-resolver');
+
+/**
+ * Install skills for Cursor IDE
+ * @param {string} repoPath - Path to the cli-ai-skills repository
+ * @param {Array<string>|null} skills - Skills to install (null = all)
+ * @param {boolean} quiet - Suppress output
+ */
+function install(repoPath, skills = null, quiet = false) {
+  const targetDir = getUserSkillsPath('cursor');
+
+  // Criar diretório se não existir
+  fs.ensureDirSync(targetDir);
+
+  const sourceDir = getSkillsSourcePath(repoPath, 'cursor');
+  
+  if (!fs.existsSync(sourceDir)) {
+    if (!quiet) {
+      console.log(chalk.red('❌ Diretório .cursor/skills não encontrado no repositório'));
+    }
+    return;
+  }
+  
+  // Listar skills disponíveis
+  const availableSkills = fs.readdirSync(sourceDir).filter(f => {
+    const fullPath = path.join(sourceDir, f);
+    return fs.statSync(fullPath).isDirectory() && f !== 'node_modules';
+  });
+  
+  const skillsToInstall = skills || availableSkills;
+  
+  let installed = 0;
+  let failed = 0;
+  
+  skillsToInstall.forEach(skill => {
+    const sourcePath = path.join(sourceDir, skill);
+    const targetPath = path.join(targetDir, skill);
+    
+    if (!fs.existsSync(sourcePath)) {
+      if (!quiet) {
+        console.log(chalk.yellow(`⚠️  Skill não encontrada: ${skill}`));
+      }
+      failed++;
+      return;
+    }
+    
+    // Criar symlink
+    try {
+      if (fs.existsSync(targetPath)) {
+        fs.removeSync(targetPath);
+      }
+      fs.symlinkSync(sourcePath, targetPath);
+      
+      if (!quiet) {
+        console.log(chalk.green(`  ✓ Cursor: ${skill}`));
+      }
+      installed++;
+    } catch (err) {
+      if (!quiet) {
+        console.log(chalk.red(`  ✗ Erro ao instalar ${skill}: ${err.message}`));
+      }
+      failed++;
+    }
+  });
+  
+  return { installed, failed };
+}
+
+module.exports = { install };

package/lib/detector.js

@@ -14,7 +14,10 @@ function detectTools() {
     codex_cli: detectCodexCli(),
     codex_app: detectCodexApp(),
     opencode: detectOpenCode(),
-    gemini: detectGemini()
+    gemini: detectGemini(),
+    antigravity: detectAntigravity(),
+    cursor: detectCursor(),
+    adal: detectAdal()
   };
 
   return tools;
@@ -153,6 +156,63 @@ function detectGemini() {
   }
 }
 
+/**
+ * Detect Google Antigravity installation
+ */
+function detectAntigravity() {
+  try {
+    const version = execSync('antigravity --version', { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'ignore'] }).trim();
+    const pathExec = execSync('which antigravity', { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'ignore'] }).trim();
+    return { installed: true, version, path: pathExec };
+  } catch {
+    return { installed: false, version: null, path: null };
+  }
+}
+
+/**
+ * Detect Cursor IDE
+ */
+function detectCursor() {
+  // Check macOS Application
+  if (os.platform() === 'darwin') {
+    const appPath = '/Applications/Cursor.app';
+    if (fs.existsSync(appPath)) {
+      return { installed: true, version: 'Cursor IDE', path: appPath };
+    }
+  }
+
+  // Check for 'cursor' command
+  try {
+    const pathExec = execSync('which cursor', { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'ignore'] }).trim();
+    return { installed: true, version: 'Cursor CLI', path: pathExec };
+  } catch {
+    // Check for ~/.cursor directory
+    const homeDir = os.homedir();
+    if (fs.existsSync(path.join(homeDir, '.cursor'))) {
+        return { installed: true, version: 'Unknown', path: path.join(homeDir, '.cursor') };
+    }
+    return { installed: false, version: null, path: null };
+  }
+}
+
+/**
+ * Detect AdaL CLI
+ */
+function detectAdal() {
+  try {
+    const version = execSync('adal --version', { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'ignore'] }).trim();
+    const pathExec = execSync('which adal', { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'ignore'] }).trim();
+    return { installed: true, version, path: pathExec };
+  } catch {
+    // Check for ~/.adal directory
+    const homeDir = os.homedir();
+    if (fs.existsSync(path.join(homeDir, '.adal'))) {
+        return { installed: true, version: 'Unknown', path: path.join(homeDir, '.adal') };
+    }
+    return { installed: false, version: null, path: null };
+  }
+}
+
 /**
  * Retorna mensagem de ajuda para ferramentas não instaladas
  */
@@ -179,9 +239,12 @@ Instale ao menos uma das seguintes ferramentas:
 📦 Gemini CLI:
    npm install -g @google/gemini-cli
 
+📦 Google Antigravity:
+   https://antigravity.google/download
+
 Após instalar, execute novamente: npx cli-ai-skills
   `;
 }
 
-module.exports = { detectTools, getInstallInstructions, detectCodex, detectCodexCli, detectCodexApp };
+module.exports = { detectTools, getInstallInstructions, detectCodex, detectCodexCli, detectCodexApp, detectAntigravity, detectCursor, detectAdal };
 

package/lib/interactive.js

@@ -93,7 +93,7 @@ async function promptPlatforms(detected) {
   
   if (detected.opencode && detected.opencode.installed) {
     choices.push({
-      name: '✅ OpenCode (~/.opencode/skills/)',
+      name: '✅ OpenCode (~/.agents/skills/)',
       value: 'opencode',
       checked: true
     });
@@ -107,6 +107,30 @@ async function promptPlatforms(detected) {
     });
   }
 
+  if (detected.antigravity && detected.antigravity.installed) {
+    choices.push({
+      name: '✅ Google Antigravity (~/.agent/skills/)',
+      value: 'antigravity',
+      checked: true
+    });
+  }
+
+  if (detected.cursor && detected.cursor.installed) {
+    choices.push({
+      name: '✅ Cursor IDE (~/.cursor/skills/)',
+      value: 'cursor',
+      checked: true
+    });
+  }
+
+  if (detected.adal && detected.adal.installed) {
+    choices.push({
+      name: '✅ AdaL CLI (~/.adal/skills/)',
+      value: 'adal',
+      checked: true
+    });
+  }
+
   if (choices.length === 0) {
     return [];
   }

package/lib/ui/table.js

@@ -16,7 +16,8 @@ function displayToolsTable(tools) {
     codex_cli: 'OpenAI Codex CLI',
     codex_app: 'OpenAI Codex App',
     opencode: 'OpenCode',
-    gemini: 'Gemini CLI'
+    gemini: 'Gemini CLI',
+    antigravity: 'Google Antigravity'
   };
   
   for (const [key, name] of Object.entries(toolNames)) {
@@ -45,16 +46,17 @@ function displayToolsTable(tools) {
  */
 function getToolsSummary(tools) {
   const installed = [];
-  
+
   if (tools.copilot && tools.copilot.installed) installed.push('copilot');
   if (tools.claude && tools.claude.installed) installed.push('claude');
   if (tools.codex_cli && tools.codex_cli.installed) installed.push('codex_cli');
   if (tools.codex_app && tools.codex_app.installed) installed.push('codex_app');
   if (tools.opencode && tools.opencode.installed) installed.push('opencode');
   if (tools.gemini && tools.gemini.installed) installed.push('gemini');
-  
+  if (tools.antigravity && tools.antigravity.installed) installed.push('antigravity');
+
   return {
-    total: 6,
+    total: 7,
     installed: installed.length,
     names: installed
   };

package/lib/utils/path-resolver.js

@@ -40,7 +40,10 @@ function getSkillsSourcePath(basePath, platform) {
     'claude': '.claude',
     'codex': '.codex',
     'opencode': '.opencode',
-    'gemini': '.gemini'
+    'gemini': '.gemini',
+    'antigravity': '.antigravity',
+    'cursor': '.cursor',
+    'adal': '.adal'
   };
 
   // For npm package: basePath/skills/{platform}/
@@ -92,8 +95,11 @@ function getUserSkillsPath(platform) {
   const platformDirs = {
     'copilot': path.join(home, '.github', 'skills'),
     'claude': path.join(home, '.claude', 'skills'),
-    'opencode': path.join(home, '.opencode', 'skills'),
-    'gemini': path.join(home, '.gemini', 'skills')
+    'opencode': path.join(home, '.agents', 'skills'),
+    'gemini': path.join(home, '.gemini', 'skills'),
+    'antigravity': path.join(home, '.agent', 'skills'),
+    'cursor': path.join(home, '.cursor', 'skills'),
+    'adal': path.join(home, '.adal', 'skills')
   };
 
   return platformDirs[platform] || path.join(home, `.${platform}`, 'skills');

package/lib/version-checker.js

@@ -19,11 +19,14 @@ function checkInstalledVersion() {
   const homeDir = os.homedir();
   
   const skillDirs = {
-    copilot: path.join(homeDir, '.copilot', 'skills'),
+    copilot: path.join(homeDir, '.github', 'skills'),
     claude: path.join(homeDir, '.claude', 'skills'),
     codex: path.join(homeDir, '.codex', 'skills'),
-    opencode: path.join(homeDir, '.opencode', 'skills'),
-    gemini: path.join(homeDir, '.gemini', 'skills')
+    opencode: path.join(homeDir, '.agents', 'skills'),
+    gemini: path.join(homeDir, '.gemini', 'skills'),
+    antigravity: path.join(homeDir, '.agent', 'skills'),
+    cursor: path.join(homeDir, '.cursor', 'skills'),
+    adal: path.join(homeDir, '.adal', 'skills')
   };
   
   for (const [platform, skillDir] of Object.entries(skillDirs)) {
@@ -90,11 +93,14 @@ function isUpdateAvailable(installInfo) {
 function checkPlatformInstallation(platform) {
   const homeDir = os.homedir();
   const platformMap = {
-    copilot: '.copilot',
+    copilot: '.github',
     claude: '.claude',
     codex: '.codex',
-    opencode: '.opencode',
-    gemini: '.gemini'
+    opencode: '.agents',
+    gemini: '.gemini',
+    antigravity: '.agent',
+    cursor: '.cursor',
+    adal: '.adal'
   };
   
   const dirName = platformMap[platform];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cli-ai-skills",
-  "version": "1.9.0",
+  "version": "1.10.0",
   "description": "Install AI skills for GitHub Copilot CLI, Claude Code, OpenAI Codex, OpenCode, and Gemini CLI",
   "main": "lib/index.js",
   "bin": {