cli-ai-skills 1.6.0 → 1.7.2

package/README.md

@@ -1,15 +1,21 @@
-# cli-ai-skills v1.5.0
+# cli-ai-skills v1.7.1
 
 🚀 **NPX Installer for AI Skills**
 
-Install reusable skills for GitHub Copilot CLI, Claude Code, and OpenAI Codex in one command.
+Install reusable skills for GitHub Copilot CLI, Claude Code, OpenAI Codex, OpenCode, and Gemini CLI in one command.
 
-![Version](https://img.shields.io/badge/version-1.5.0-blue.svg)
+![Version](https://img.shields.io/badge/version-1.7.1-blue.svg)
 ![License](https://img.shields.io/badge/license-MIT-green.svg)
 ![Node](https://img.shields.io/badge/node-%3E%3D14.0.0-green.svg)
 
 ## 🚀 Quick Start
 
+**Shell installer (recommended):**
+```bash
+curl -fsSL https://raw.githubusercontent.com/ericandrade/cli-ai-skills/main/scripts/install.sh | bash
+```
+
+**Or use NPX:**
 ```bash
 # Zero-config installation (interactive)
 npx cli-ai-skills
@@ -21,9 +27,11 @@ npx cli-ai-skills -y -q
 npx cli-ai-skills --bundle essential -y
 ```
 
+See [Installation Guide](../docs/INSTALLATION.md) for all methods.
+
 ## 📦 What It Does
 
-1. 🔍 **Detects** installed AI CLI tools (Copilot, Claude, Codex)
+1. 🔍 **Detects** installed AI CLI tools (Copilot, Claude, Codex, OpenCode, Gemini)
 2. 📋 **Lists** all 4 available AI skills
 3. ⚙️ **Installs** skills to the correct platform directories
 4. ✅ **Validates** installation success

package/bin/cli.js

@@ -1,15 +1,22 @@
 #!/usr/bin/env node
 
 const { detectTools, getInstallInstructions } = require('../lib/detector');
-const { promptPlatforms } = require('../lib/interactive');
+const { promptPlatforms, setupEscapeHandler } = require('../lib/interactive');
+const { setupCleanupHandler } = require('../lib/cleanup');
 const { installCopilotSkills } = require('../lib/copilot');
 const { installClaudeSkills } = require('../lib/claude');
 const { install: installCodexSkills } = require('../lib/codex');
+const { install: installOpenCodeSkills } = require('../lib/opencode');
+const { install: installGeminiSkills } = require('../lib/gemini');
 const { listBundles, validateBundle } = require('../lib/bundles');
 const { searchSkills } = require('../lib/search');
+const { displayToolsTable } = require('../lib/ui/table');
+const { checkInstalledVersion, isUpdateAvailable } = require('../lib/version-checker');
+const chalk = require('chalk');
+const inquirer = require('inquirer');
 const path = require('path');
 
-const VERSION = '1.5.0';
+const VERSION = '1.6.0';
 
 // Command aliases
 const commandAliases = {
@@ -32,7 +39,11 @@ const shortFlags = {
 async function main() {
   const args = process.argv.slice(2);
   
-  console.log(`\n🚀 cli-ai-skills v${VERSION} - Tri-Platform Installer\n`);
+  // Setup handlers
+  setupEscapeHandler();
+  setupCleanupHandler();
+  
+  console.log(chalk.cyan.bold(`\n🚀 cli-ai-skills v${VERSION} - Multi-Platform Installer\n`));
   
   // Handle help
   if (args.includes('--help') || args.includes('-h')) {
@@ -74,31 +85,32 @@ async function main() {
     const bundleName = args[bundleIdx + 1];
     const bundle = validateBundle(bundleName);
     
-    console.log(`🔍 Detectando ferramentas AI CLI instaladas...\n`);
+    console.log(chalk.cyan('🔍 Detectando ferramentas AI CLI instaladas...\n'));
     const detected = detectTools();
-    const hasAny = detected.copilot || detected.claude || detected.codex;
+    
+    // Display tools table
+    displayToolsTable(detected);
+    
+    const hasAny = detected.copilot.installed || detected.claude.installed || 
+                   detected.codex.installed || detected.opencode.installed || 
+                   detected.gemini.installed;
     
     if (!hasAny) {
       console.log(getInstallInstructions());
       process.exit(1);
     }
     
-    // Show detected tools
-    console.log('Ferramentas detectadas:');
-    if (detected.copilot) console.log('  ✅ GitHub Copilot CLI');
-    if (detected.claude) console.log('  ✅ Claude Code');
-    if (detected.codex) console.log('  ✅ OpenAI Codex');
-    console.log('');
-    
     // Check for --yes flag (skip prompts)
     const skipPrompt = args.includes('-y') || args.includes('--yes');
     
     let platforms;
     if (skipPrompt) {
       platforms = [];
-      if (detected.copilot) platforms.push('copilot');
-      if (detected.claude) platforms.push('claude');
-      if (detected.codex) platforms.push('codex');
+      if (detected.copilot.installed) platforms.push('copilot');
+      if (detected.claude.installed) platforms.push('claude');
+      if (detected.codex.installed) platforms.push('codex');
+      if (detected.opencode.installed) platforms.push('opencode');
+      if (detected.gemini.installed) platforms.push('gemini');
     } else {
       platforms = await promptPlatforms(detected);
     }
@@ -127,6 +139,12 @@ async function main() {
       if (platforms.includes('codex')) {
         installCodexSkills(repoPath, [skill], quiet);
       }
+      if (platforms.includes('opencode')) {
+        installOpenCodeSkills(repoPath, [skill], quiet);
+      }
+      if (platforms.includes('gemini')) {
+        installGeminiSkills(repoPath, [skill], quiet);
+      }
     });
     
     if (!quiet) {
@@ -137,22 +155,64 @@ async function main() {
   
   // Zero-config mode (no arguments)
   if (args.length === 0 || command === 'install') {
-    console.log('🔍 Detectando ferramentas AI CLI instaladas...\n');
+    console.log(chalk.cyan('🔍 Detectando ferramentas AI CLI instaladas...\n'));
     
     const detected = detectTools();
-    const hasAny = detected.copilot || detected.claude || detected.codex;
+    
+    // Display tools table
+    displayToolsTable(detected);
+    
+    const hasAny = detected.copilot.installed || detected.claude.installed || 
+                   detected.codex.installed || detected.opencode.installed || 
+                   detected.gemini.installed;
     
     if (!hasAny) {
       console.log(getInstallInstructions());
       process.exit(1);
     }
     
-    // Show detected tools
-    console.log('Ferramentas detectadas:');
-    if (detected.copilot) console.log('  ✅ GitHub Copilot CLI');
-    if (detected.claude) console.log('  ✅ Claude Code');
-    if (detected.codex) console.log('  ✅ OpenAI Codex');
-    console.log('');
+    // Check if already installed
+    const installInfo = checkInstalledVersion();
+    
+    if (installInfo.installed) {
+      console.log(chalk.cyan(`\nℹ️  cli-ai-skills já instalado nas seguintes plataformas:\n`));
+      
+      for (const platform of installInfo.platforms) {
+        const version = installInfo.versions[platform];
+        console.log(chalk.dim(`  • ${platform}: v${version}`));
+      }
+      
+      if (isUpdateAvailable(installInfo)) {
+        console.log(chalk.yellow(`\n⚠️  Nova versão disponível: v${installInfo.latestVersion}\n`));
+        
+        const { update } = await inquirer.prompt([{
+          type: 'confirm',
+          name: 'update',
+          message: 'Deseja atualizar agora?',
+          default: true
+        }]);
+        
+        if (!update) {
+          console.log(chalk.dim('\n❌ Atualização cancelada.\n'));
+          process.exit(0);
+        }
+        
+        console.log(chalk.cyan('\n🔄 Atualizando skills...\n'));
+      } else {
+        console.log(chalk.green(`\n✅ Você já possui a versão mais recente (v${installInfo.latestVersion})\n`));
+        
+        const { reinstall } = await inquirer.prompt([{
+          type: 'confirm',
+          name: 'reinstall',
+          message: 'Deseja reinstalar?',
+          default: false
+        }]);
+        
+        if (!reinstall) {
+          process.exit(0);
+        }
+      }
+    }
     
     // Check for --yes flag (zero-config mode)
     const skipPrompt = args.includes('-y') || args.includes('--yes');
@@ -161,20 +221,22 @@ async function main() {
     if (skipPrompt) {
       // Auto-select all detected platforms
       platforms = [];
-      if (detected.copilot) platforms.push('copilot');
-      if (detected.claude) platforms.push('claude');
-      if (detected.codex) platforms.push('codex');
+      if (detected.copilot.installed) platforms.push('copilot');
+      if (detected.claude.installed) platforms.push('claude');
+      if (detected.codex.installed) platforms.push('codex');
+      if (detected.opencode.installed) platforms.push('opencode');
+      if (detected.gemini.installed) platforms.push('gemini');
     } else {
       // Interactive selection
       platforms = await promptPlatforms(detected);
     }
     
     if (platforms.length === 0) {
-      console.log('\n❌ Instalação cancelada.\n');
+      console.log(chalk.red('\n❌ Instalação cancelada.\n'));
       process.exit(0);
     }
     
-    console.log(`\n📦 Instalando skills para: ${platforms.join(', ')}\n`);
+    console.log(chalk.cyan(`\n📦 Instalando skills para: ${platforms.join(', ')}\n`));
     
     const repoPath = path.resolve(__dirname, '../..');
     const quiet = args.includes('-q') || args.includes('--quiet');
@@ -192,8 +254,16 @@ async function main() {
       installCodexSkills(repoPath, null, quiet);
     }
     
+    if (platforms.includes('opencode')) {
+      installOpenCodeSkills(repoPath, null, quiet);
+    }
+    
+    if (platforms.includes('gemini')) {
+      installGeminiSkills(repoPath, null, quiet);
+    }
+    
     if (!quiet) {
-      console.log(`\n✅ Instalação concluída com sucesso!\n`);
+      console.log(chalk.green(`\n✅ Instalação concluída com sucesso!\n`));
     }
     return;
   }

package/lib/cleanup.js

@@ -0,0 +1,92 @@
+const fs = require('fs-extra');
+const chalk = require('chalk');
+
+/**
+ * Track of partial installations for cleanup on cancellation
+ */
+const partialInstalls = [];
+
+/**
+ * Register a path as partially installed
+ * @param {string} installPath - Path to the installed skill
+ */
+function registerPartialInstall(installPath) {
+  if (!partialInstalls.includes(installPath)) {
+    partialInstalls.push(installPath);
+  }
+}
+
+/**
+ * Clear the partial installs registry
+ */
+function clearPartialInstalls() {
+  partialInstalls.length = 0;
+}
+
+/**
+ * Reverte instalações parciais em caso de cancelamento
+ * @returns {Promise<void>}
+ */
+async function revertPartialInstalls() {
+  if (partialInstalls.length === 0) return;
+  
+  console.log(chalk.cyan('\n🧹 Limpando instalações parciais...\n'));
+  
+  let removed = 0;
+  let failed = 0;
+  
+  for (const installPath of partialInstalls) {
+    try {
+      if (await fs.pathExists(installPath)) {
+        // Check if it's a symlink
+        const stats = await fs.lstat(installPath);
+        
+        if (stats.isSymbolicLink()) {
+          await fs.unlink(installPath);
+        } else {
+          await fs.remove(installPath);
+        }
+        
+        console.log(chalk.green(`  ✓ Removido: ${installPath}`));
+        removed++;
+      }
+    } catch (err) {
+      console.log(chalk.red(`  ✗ Erro ao remover ${installPath}: ${err.message}`));
+      failed++;
+    }
+  }
+  
+  if (removed > 0) {
+    console.log(chalk.green(`\n✅ Cleanup concluído (${removed} removidos).\n`));
+  }
+  
+  if (failed > 0) {
+    console.log(chalk.yellow(`⚠️  ${failed} itens falharam ao remover.\n`));
+  }
+  
+  clearPartialInstalls();
+}
+
+/**
+ * Setup cleanup handler for process termination
+ */
+function setupCleanupHandler() {
+  // Handle Ctrl+C
+  process.on('SIGINT', async () => {
+    await revertPartialInstalls();
+    process.exit(0);
+  });
+  
+  // Handle termination
+  process.on('SIGTERM', async () => {
+    await revertPartialInstalls();
+    process.exit(0);
+  });
+}
+
+module.exports = {
+  registerPartialInstall,
+  clearPartialInstalls,
+  revertPartialInstalls,
+  setupCleanupHandler
+};

package/lib/commands/uninstall.js

@@ -27,8 +27,8 @@ async function uninstallCommand(skillName, options) {
     // If specific skill name provided, only check that one
     const skillsToCheck = skillName ? [skillName] : await getInstalledSkillNames();
 
-    for (const platform of ['copilot', 'claude']) {
-      if (!platforms[platform].installed) continue;
+    for (const platform of ['copilot', 'claude', 'opencode', 'gemini']) {
+      if (!platforms[platform] || !platforms[platform].installed) continue;
 
       for (const skill of skillsToCheck) {
         const status = await versionChecker.checkVersion(skill, platform, '999.999.999');
@@ -184,31 +184,38 @@ async function uninstallCommand(skillName, options) {
 function getSkillPath(skillName, platform) {
   const homeDir = os.homedir();
   
-  if (platform === 'copilot') {
-    return path.join(homeDir, '.copilot', 'skills', skillName);
-  } else if (platform === 'claude') {
-    return path.join(homeDir, '.claude', 'skills', skillName);
+  const platformPaths = {
+    copilot: path.join(homeDir, '.copilot', 'skills', skillName),
+    claude: path.join(homeDir, '.claude', 'skills', skillName),
+    opencode: path.join(homeDir, '.opencode', 'skills', skillName),
+    gemini: path.join(homeDir, '.gemini', 'skills', skillName)
+  };
+  
+  if (!platformPaths[platform]) {
+    throw new Error(`Unknown platform: ${platform}`);
   }
   
-  throw new Error(`Unknown platform: ${platform}`);
+  return platformPaths[platform];
 }
 
 async function getInstalledSkillNames() {
   const homeDir = os.homedir();
   const skills = new Set();
 
-  // Check Copilot skills
-  const copilotSkillsDir = path.join(homeDir, '.copilot', 'skills');
-  if (await fs.pathExists(copilotSkillsDir)) {
-    const copilotSkills = await fs.readdir(copilotSkillsDir);
-    copilotSkills.forEach(s => skills.add(s));
-  }
-
-  // Check Claude skills
-  const claudeSkillsDir = path.join(homeDir, '.claude', 'skills');
-  if (await fs.pathExists(claudeSkillsDir)) {
-    const claudeSkills = await fs.readdir(claudeSkillsDir);
-    claudeSkills.forEach(s => skills.add(s));
+  const platforms = ['copilot', 'claude', 'opencode', 'gemini'];
+  
+  for (const platform of platforms) {
+    const skillsDir = path.join(homeDir, `.${platform}`, 'skills');
+    
+    if (await fs.pathExists(skillsDir)) {
+      const platformSkills = await fs.readdir(skillsDir);
+      platformSkills.forEach(s => {
+        const fullPath = path.join(skillsDir, s);
+        if (fs.statSync(fullPath).isDirectory()) {
+          skills.add(s);
+        }
+      });
+    }
   }
 
   return Array.from(skills);

package/lib/commands/update.js

@@ -31,8 +31,8 @@ async function updateCommand(skillNames, options) {
     const availableSkills = await downloader.listAvailableSkills();
     const outdatedSkills = [];
 
-    for (const platform of ['copilot', 'claude']) {
-      if (!platforms[platform].installed) continue;
+    for (const platform of ['copilot', 'claude', 'opencode', 'gemini']) {
+      if (!platforms[platform] || !platforms[platform].installed) continue;
 
       for (const skillMeta of availableSkills) {
         const status = await versionChecker.checkVersion(skillMeta.name, platform, skillMeta.version);
@@ -54,6 +54,21 @@ async function updateCommand(skillNames, options) {
     if (outdatedSkills.length === 0) {
       gauge.complete('All skills are up to date');
       console.log(chalk.green('\n✨ All skills are already at the latest version!\n'));
+      
+      // Offer reinstall option
+      if (!options.yes) {
+        const { reinstall } = await inquirer.prompt([{
+          type: 'confirm',
+          name: 'reinstall',
+          message: 'Would you like to reinstall all skills?',
+          default: false
+        }]);
+        
+        if (reinstall) {
+          return await reinstallAllSkills(platforms, availableSkills, options);
+        }
+      }
+      
       return;
     }
 
@@ -140,3 +155,43 @@ async function updateCommand(skillNames, options) {
 }
 
 module.exports = updateCommand;
+
+/**
+ * Reinstall all skills for all platforms
+ */
+async function reinstallAllSkills(platforms, availableSkills, options) {
+  console.log(chalk.cyan('\n🔄 Reinstalling all skills...\n'));
+  
+  const installer = new SkillInstaller();
+  const results = { reinstalled: 0, failed: 0 };
+  
+  for (const platform of ['copilot', 'claude', 'opencode', 'gemini']) {
+    if (!platforms[platform] || !platforms[platform].installed) continue;
+    
+    for (const skill of availableSkills) {
+      try {
+        await installer.install(skill.name, platform, 'global', 'symlink');
+        results.reinstalled++;
+        console.log(chalk.green(`  ✓ ${skill.name} (${platform})`));
+      } catch (error) {
+        results.failed++;
+        console.log(chalk.red(`  ✗ ${skill.name} (${platform}): ${error.message}`));
+      }
+    }
+  }
+  
+  // Summary
+  console.log('\n' + ProgressGauge.summary({
+    completed: results.reinstalled,
+    failed: results.failed,
+    total: results.reinstalled + results.failed
+  }));
+  
+  if (results.reinstalled > 0) {
+    console.log(chalk.green(`\n✨ Successfully reinstalled ${results.reinstalled} skill(s)!\n`));
+  }
+  
+  if (results.failed > 0) {
+    console.log(chalk.yellow(`⚠️  ${results.failed} skill(s) failed to reinstall.\n`));
+  }
+}

package/lib/detector.js

@@ -2,40 +2,95 @@ const { execSync } = require('child_process');
 
 /**
  * Detecta ferramentas AI CLI instaladas no sistema
- * @returns {Object} { copilot: boolean, claude: boolean, codex: boolean }
+ * @returns {Object} { copilot: {installed, version, path}, claude: {...}, ... }
  */
 function detectTools() {
   const tools = {
-    copilot: false,
-    claude: false,
-    codex: false
+    copilot: detectCopilot(),
+    claude: detectClaude(),
+    codex: detectCodex(),
+    opencode: detectOpenCode(),
+    gemini: detectGemini()
   };
 
-  // Detectar GitHub Copilot CLI
+  return tools;
+}
+
+/**
+ * Detecta GitHub Copilot CLI
+ */
+function detectCopilot() {
   try {
-    execSync('gh copilot --version', { stdio: 'ignore' });
-    tools.copilot = true;
+    const version = execSync('gh copilot --version', { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'ignore'] }).trim();
+    const path = execSync('which gh', { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'ignore'] }).trim();
+    return { installed: true, version, path };
   } catch (e) {
-    // Não instalado
+    return { installed: false, version: null, path: null };
   }
+}
 
-  // Detectar Claude Code
+/**
+ * Detecta Claude Code
+ */
+function detectClaude() {
   try {
-    execSync('claude --version', { stdio: 'ignore' });
-    tools.claude = true;
+    const version = execSync('claude --version', { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'ignore'] }).trim();
+    const path = execSync('which claude', { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'ignore'] }).trim();
+    return { installed: true, version, path };
   } catch (e) {
-    // Não instalado
+    return { installed: false, version: null, path: null };
   }
+}
 
-  // Detectar OpenAI Codex
+/**
+ * Detecta OpenAI Codex
+ */
+function detectCodex() {
   try {
-    execSync('codex --version', { stdio: 'ignore' });
-    tools.codex = true;
+    const version = execSync('codex --version', { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'ignore'] }).trim();
+    const path = execSync('which codex', { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'ignore'] }).trim();
+    return { installed: true, version, path };
   } catch (e) {
-    // Não instalado
+    return { installed: false, version: null, path: null };
   }
+}
 
-  return tools;
+/**
+ * Detecta OpenCode
+ */
+function detectOpenCode() {
+  try {
+    const version = execSync('opencode --version', { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'ignore'] }).trim();
+    const path = execSync('which opencode', { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'ignore'] }).trim();
+    return { installed: true, version, path };
+  } catch (e) {
+    // Método alternativo: verificar via npm global
+    try {
+      execSync('npm list -g opencode', { stdio: 'ignore' });
+      return { installed: true, version: 'unknown', path: 'npm global' };
+    } catch {
+      return { installed: false, version: null, path: null };
+    }
+  }
+}
+
+/**
+ * Detecta Gemini CLI
+ */
+function detectGemini() {
+  try {
+    const version = execSync('gemini --version', { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'ignore'] }).trim();
+    const path = execSync('which gemini', { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'ignore'] }).trim();
+    return { installed: true, version, path };
+  } catch (e) {
+    // Método alternativo: verificar via npm global
+    try {
+      execSync('npm list -g gemini-cli', { stdio: 'ignore' });
+      return { installed: true, version: 'unknown', path: 'npm global' };
+    } catch {
+      return { installed: false, version: null, path: null };
+    }
+  }
 }
 
 /**
@@ -58,8 +113,15 @@ Instale ao menos uma das seguintes ferramentas:
 📦 OpenAI Codex:
    npm install -g @openai/codex
 
+📦 OpenCode:
+   npm install -g opencode
+
+📦 Gemini CLI:
+   npm install -g @google/gemini-cli
+
 Após instalar, execute novamente: npx cli-ai-skills
   `;
 }
 
 module.exports = { detectTools, getInstallInstructions };
+

package/lib/gemini.js

@@ -0,0 +1,73 @@
+const fs = require('fs-extra');
+const path = require('path');
+const chalk = require('chalk');
+const os = require('os');
+
+/**
+ * Install skills for Gemini 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 homeDir = os.homedir();
+  const targetDir = path.join(homeDir, '.gemini', 'skills');
+  
+  // Criar diretório se não existir
+  fs.ensureDirSync(targetDir);
+  
+  const sourceDir = path.join(repoPath, '.gemini', 'skills');
+  
+  if (!fs.existsSync(sourceDir)) {
+    if (!quiet) {
+      console.log(chalk.red('❌ Diretório .gemini/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(`  ✓ Gemini: ${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/interactive.js

@@ -1,8 +1,56 @@
 const inquirer = require('inquirer');
+const chalk = require('chalk');
+
+// ESC handler state
+let escListenerActive = false;
+let currentPrompt = null;
+
+/**
+ * Setup ESC key handler for cancelling prompts
+ */
+function setupEscapeHandler() {
+  if (escListenerActive) return;
+  
+  const readline = require('readline');
+  readline.emitKeypressEvents(process.stdin);
+  
+  if (process.stdin.isTTY) {
+    process.stdin.setRawMode(true);
+  }
+  
+  process.stdin.on('keypress', async (str, key) => {
+    if (key && key.name === 'escape') {
+      await confirmCancel();
+    }
+  });
+  
+  escListenerActive = true;
+}
+
+/**
+ * Confirm cancellation with user
+ */
+async function confirmCancel() {
+  console.log('\n'); // New line for better UX
+  
+  const { cancel } = await inquirer.prompt([{
+    type: 'confirm',
+    name: 'cancel',
+    message: chalk.yellow('⚠️  Deseja cancelar a instalação?'),
+    default: false
+  }]);
+  
+  if (cancel) {
+    console.log(chalk.red('\n❌ Instalação cancelada pelo usuário.\n'));
+    process.exit(0);
+  } else {
+    console.log(chalk.dim('Continuando...\n'));
+  }
+}
 
 /**
  * Pergunta ao usuário para quais plataformas instalar
- * @param {Object} detected - Ferramentas detectadas { copilot, claude, codex }
+ * @param {Object} detected - Ferramentas detectadas { copilot, claude, codex, opencode, gemini }
  * @returns {Promise<Array>} Plataformas escolhidas
  */
 async function promptPlatforms(detected) {
@@ -31,6 +79,22 @@ async function promptPlatforms(detected) {
       checked: true
     });
   }
+  
+  if (detected.opencode) {
+    choices.push({
+      name: '✅ OpenCode (.opencode/skills/)',
+      value: 'opencode',
+      checked: true
+    });
+  }
+  
+  if (detected.gemini) {
+    choices.push({
+      name: '✅ Gemini CLI (.gemini/skills/)',
+      value: 'gemini',
+      checked: true
+    });
+  }
 
   if (choices.length === 0) {
     return [];
@@ -40,7 +104,7 @@ async function promptPlatforms(detected) {
     {
       type: 'checkbox',
       name: 'platforms',
-      message: 'Instalar skills para quais plataformas?',
+      message: 'Instalar skills para quais plataformas? (Pressione ESC para cancelar)',
       choices: choices,
       validate: (answer) => {
         if (answer.length < 1) {
@@ -54,4 +118,4 @@ async function promptPlatforms(detected) {
   return answers.platforms;
 }
 
-module.exports = { promptPlatforms };
+module.exports = { promptPlatforms, setupEscapeHandler, confirmCancel };

package/lib/opencode.js

@@ -0,0 +1,73 @@
+const fs = require('fs-extra');
+const path = require('path');
+const chalk = require('chalk');
+const os = require('os');
+
+/**
+ * Install skills for OpenCode
+ * @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 homeDir = os.homedir();
+  const targetDir = path.join(homeDir, '.opencode', 'skills');
+  
+  // Criar diretório se não existir
+  fs.ensureDirSync(targetDir);
+  
+  const sourceDir = path.join(repoPath, '.opencode', 'skills');
+  
+  if (!fs.existsSync(sourceDir)) {
+    if (!quiet) {
+      console.log(chalk.red('❌ Diretório .opencode/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(`  ✓ OpenCode: ${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/ui/table.js

@@ -0,0 +1,58 @@
+const chalk = require('chalk');
+
+/**
+ * Exibe tabela formatada de ferramentas detectadas
+ * @param {Object} tools - Objeto retornado por detectTools()
+ */
+function displayToolsTable(tools) {
+  console.log('\n┌─────────────────────────────────────────────────────────────┐');
+  console.log('│ Ferramenta            │ Status   │ Versão              │');
+  console.log('├─────────────────────────────────────────────────────────────┤');
+  
+  const toolNames = {
+    copilot: 'GitHub Copilot CLI',
+    claude: 'Claude Code',
+    codex: 'OpenAI Codex',
+    opencode: 'OpenCode',
+    gemini: 'Gemini CLI'
+  };
+  
+  for (const [key, name] of Object.entries(toolNames)) {
+    const tool = tools[key];
+    const status = tool.installed ? chalk.green('✓') : chalk.red('✗');
+    const version = tool.version || chalk.gray('-');
+    
+    // Formatar linha com espaçamento fixo
+    const namePadded = name.padEnd(21);
+    const statusPadded = '  ' + status + '      ';
+    const versionStr = String(version).substring(0, 20);
+    const versionPadded = versionStr.padEnd(20);
+    
+    console.log(`│ ${namePadded} │${statusPadded}│ ${versionPadded}│`);
+  }
+  
+  console.log('└─────────────────────────────────────────────────────────────┘\n');
+}
+
+/**
+ * Retorna resumo de ferramentas detectadas (simples)
+ * @param {Object} tools - Objeto retornado por detectTools()
+ * @returns {Object} { total: number, installed: number, names: string[] }
+ */
+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 && tools.codex.installed) installed.push('codex');
+  if (tools.opencode && tools.opencode.installed) installed.push('opencode');
+  if (tools.gemini && tools.gemini.installed) installed.push('gemini');
+  
+  return {
+    total: 5,
+    installed: installed.length,
+    names: installed
+  };
+}
+
+module.exports = { displayToolsTable, getToolsSummary };

package/lib/version-checker.js

@@ -0,0 +1,130 @@
+const fs = require('fs-extra');
+const path = require('path');
+const os = require('os');
+const semver = require('semver');
+const yaml = require('js-yaml');
+
+/**
+ * Verifica se cli-ai-skills já está instalado em alguma plataforma
+ * @returns {Object} { installed: boolean, platforms: [], versions: {}, latestVersion: string }
+ */
+function checkInstalledVersion() {
+  const result = {
+    installed: false,
+    platforms: [],
+    versions: {},
+    latestVersion: require('../package.json').version
+  };
+  
+  const homeDir = os.homedir();
+  
+  const skillDirs = {
+    copilot: path.join(homeDir, '.copilot', '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')
+  };
+  
+  for (const [platform, skillDir] of Object.entries(skillDirs)) {
+    if (!fs.existsSync(skillDir)) continue;
+    
+    // Verificar se há skills instaladas (procurar por skill-creator ou prompt-engineer)
+    const testSkillPath = path.join(skillDir, 'skill-creator', 'SKILL.md');
+    
+    if (fs.existsSync(testSkillPath)) {
+      result.installed = true;
+      result.platforms.push(platform);
+      
+      // Extrair versão do YAML frontmatter
+      try {
+        const content = fs.readFileSync(testSkillPath, 'utf-8');
+        const yamlMatch = content.match(/^---\n([\s\S]*?)\n---/);
+        
+        if (yamlMatch) {
+          const metadata = yaml.load(yamlMatch[1]);
+          result.versions[platform] = metadata.version || 'unknown';
+        } else {
+          result.versions[platform] = 'unknown';
+        }
+      } catch (err) {
+        result.versions[platform] = 'unknown';
+      }
+    }
+  }
+  
+  return result;
+}
+
+/**
+ * Compara versões e retorna se atualização está disponível
+ * @param {Object} installInfo - Retorno de checkInstalledVersion()
+ * @returns {boolean} true se nova versão disponível
+ */
+function isUpdateAvailable(installInfo) {
+  if (!installInfo.installed) return false;
+  
+  const { versions, latestVersion } = installInfo;
+  
+  for (const installedVersion of Object.values(versions)) {
+    if (installedVersion === 'unknown') continue;
+    
+    try {
+      if (semver.lt(installedVersion, latestVersion)) {
+        return true;
+      }
+    } catch (err) {
+      // Versão inválida, assumir atualização disponível
+      return true;
+    }
+  }
+  
+  return false;
+}
+
+/**
+ * Verifica se uma plataforma específica tem cli-ai-skills instalado
+ * @param {string} platform - Nome da plataforma (copilot, claude, etc)
+ * @returns {Object} { installed: boolean, version: string }
+ */
+function checkPlatformInstallation(platform) {
+  const homeDir = os.homedir();
+  const platformMap = {
+    copilot: '.copilot',
+    claude: '.claude',
+    codex: '.codex',
+    opencode: '.opencode',
+    gemini: '.gemini'
+  };
+  
+  const dirName = platformMap[platform];
+  if (!dirName) {
+    return { installed: false, version: null };
+  }
+  
+  const skillPath = path.join(homeDir, dirName, 'skills', 'skill-creator', 'SKILL.md');
+  
+  if (!fs.existsSync(skillPath)) {
+    return { installed: false, version: null };
+  }
+  
+  try {
+    const content = fs.readFileSync(skillPath, 'utf-8');
+    const yamlMatch = content.match(/^---\n([\s\S]*?)\n---/);
+    
+    if (yamlMatch) {
+      const metadata = yaml.load(yamlMatch[1]);
+      return { installed: true, version: metadata.version || 'unknown' };
+    }
+  } catch (err) {
+    return { installed: true, version: 'unknown' };
+  }
+  
+  return { installed: true, version: 'unknown' };
+}
+
+module.exports = { 
+  checkInstalledVersion, 
+  isUpdateAvailable,
+  checkPlatformInstallation
+};

package/package.json

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