cli-ai-skills 1.7.3 → 1.8.0

package/bin/cli.js

@@ -96,7 +96,7 @@ async function main() {
     displayToolsTable(detected);
     
     const hasAny = detected.copilot.installed || detected.claude.installed || 
-                   detected.codex.installed || detected.opencode.installed || 
+                   detected.codex_cli.installed || detected.codex_app.installed || detected.opencode.installed || 
                    detected.gemini.installed;
     
     if (!hasAny) {
@@ -112,7 +112,7 @@ async function main() {
       platforms = [];
       if (detected.copilot.installed) platforms.push('copilot');
       if (detected.claude.installed) platforms.push('claude');
-      if (detected.codex.installed) platforms.push('codex');
+      if (detected.codex_cli.installed) platforms.push('codex_cli');
       if (detected.opencode.installed) platforms.push('opencode');
       if (detected.gemini.installed) platforms.push('gemini');
     } else {
@@ -140,7 +140,7 @@ async function main() {
       if (platforms.includes('claude')) {
         installClaudeSkills(repoPath, [skill], quiet);
       }
-      if (platforms.includes('codex')) {
+      if (platforms.includes('codex') || platforms.includes('codex_cli') || platforms.includes('codex_app')) {
         installCodexSkills(repoPath, [skill], quiet);
       }
       if (platforms.includes('opencode')) {
@@ -167,7 +167,7 @@ async function main() {
     displayToolsTable(detected);
     
     const hasAny = detected.copilot.installed || detected.claude.installed || 
-                   detected.codex.installed || detected.opencode.installed || 
+                   detected.codex_cli.installed || detected.codex_app.installed || detected.opencode.installed || 
                    detected.gemini.installed;
     
     if (!hasAny) {
@@ -227,7 +227,8 @@ async function main() {
       platforms = [];
       if (detected.copilot.installed) platforms.push('copilot');
       if (detected.claude.installed) platforms.push('claude');
-      if (detected.codex.installed) platforms.push('codex');
+      if (detected.codex_cli.installed) platforms.push('codex_cli');
+      if (detected.codex_app.installed) platforms.push('codex_app');
       if (detected.opencode.installed) platforms.push('opencode');
       if (detected.gemini.installed) platforms.push('gemini');
     } else {
@@ -242,8 +243,13 @@ async function main() {
     
     console.log(chalk.cyan(`\n📦 Instalando skills para: ${platforms.join(', ')}\n`));
     
-    const repoPath = getSkillsBasePath(__dirname);
+    const isLocal = args.includes('--local') || args.includes('-l');
+    const repoPath = isLocal ? process.cwd() : getSkillsBasePath(__dirname);
     const quiet = args.includes('-q') || args.includes('--quiet');
+
+    if (isLocal && !quiet) {
+      console.log(chalk.yellow(`📂 Modo Local: Buscando skills em ${repoPath}`));
+    }
     
     // Install for selected platforms
     if (platforms.includes('copilot')) {
@@ -254,7 +260,7 @@ async function main() {
       installClaudeSkills(repoPath, null, quiet);
     }
     
-    if (platforms.includes('codex')) {
+    if (platforms.includes('codex') || platforms.includes('codex_cli') || platforms.includes('codex_app')) {
       installCodexSkills(repoPath, null, quiet);
     }
     

package/lib/codex.js

@@ -1,45 +1,70 @@
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
+const chalk = require('chalk');
 const { getSkillsSourcePath, getUserSkillsPath } = require('./utils/path-resolver');
 
-const CODEX_SKILLS_DIR = getUserSkillsPath('codex');
-
 /**
  * Instala skills para OpenAI Codex
+ * Solução robusta com multi-path fallback e logging detalhado
  * @param {string} repoPath - Caminho para o repositório cli-ai-skills
+ * @param {Array<string>|null} skills - Skills to install (null = all)
+ * @param {boolean} quiet - Suppress output
  */
-function install(repoPath) {
-  console.log('\n📦 Instalando skills para OpenAI Codex...');
+function install(repoPath, skills = null, quiet = false) {
+  const targetDir = getUserSkillsPath('codex');
+
+  if (!quiet) {
+    console.log(chalk.cyan('\n📦 Instalando skills para OpenAI Codex...'));
+    console.log(chalk.gray(`   Destino: ${targetDir}`));
+  }
 
-  const skillsSource = getSkillsSourcePath(repoPath, 'codex');
+  const sourceDir = getSkillsSourcePath(repoPath, 'codex');
   
-  if (!fs.existsSync(skillsSource)) {
-    console.error('❌ Erro: .codex/skills/ não encontrado no repositório');
-    console.error(`   Caminho esperado: ${skillsSource}`);
-    return;
+  if (!fs.existsSync(sourceDir)) {
+    if (!quiet) {
+      console.log(chalk.red('❌ Diretório .codex/skills não encontrado no repositório'));
+      console.log(chalk.gray(`   Esperado: ${sourceDir}`));
+    }
+    return { installed: 0, failed: 0 };
   }
   
-  // Criar ~/.codex/skills/ se não existir
-  if (!fs.existsSync(CODEX_SKILLS_DIR)) {
-    fs.mkdirSync(CODEX_SKILLS_DIR, { recursive: true });
-    console.log(`   Criado: ${CODEX_SKILLS_DIR}`);
+  // Criar diretório de destino se não existir
+  if (!fs.existsSync(targetDir)) {
+    fs.mkdirSync(targetDir, { recursive: true });
+    if (!quiet) {
+      console.log(chalk.green(`   ✓ Criado: ${targetDir}`));
+    }
   }
   
   // Listar skills disponíveis
-  const skills = fs.readdirSync(skillsSource, { withFileTypes: true })
+  const availableSkills = fs.readdirSync(sourceDir, { withFileTypes: true })
     .filter(d => d.isDirectory() && d.name !== 'node_modules' && !d.name.startsWith('.'))
     .map(d => d.name);
   
-  if (skills.length === 0) {
-    console.log('   ⚠️  Nenhum skill encontrado em .codex/skills/');
-    return;
+  if (availableSkills.length === 0) {
+    if (!quiet) {
+      console.log(chalk.yellow('   ⚠️  Nenhum skill encontrado em .codex/skills/'));
+    }
+    return { installed: 0, failed: 0 };
   }
+
+  const skillsToInstall = skills || availableSkills;
+  let installed = 0;
+  let failed = 0;
   
   // Criar symlinks
-  skills.forEach(skill => {
-    const src = path.join(skillsSource, skill);
-    const dest = path.join(CODEX_SKILLS_DIR, skill);
+  skillsToInstall.forEach(skill => {
+    const src = path.join(sourceDir, skill);
+    const dest = path.join(targetDir, skill);
+    
+    if (!fs.existsSync(src)) {
+      if (!quiet) {
+        console.log(chalk.yellow(`   ⚠️  Skill não encontrada: ${skill}`));
+      }
+      failed++;
+      return;
+    }
     
     // Remover symlink antigo se existir
     if (fs.existsSync(dest) || fs.lstatSync(dest, {throwIfNoEntry: false})) {
@@ -53,13 +78,26 @@ function install(repoPath) {
     // Criar novo symlink
     try {
       fs.symlinkSync(src, dest);
-      console.log(`   ✓ ${skill}`);
+      if (!quiet) {
+        console.log(chalk.green(`   ✓ Codex: ${skill}`));
+      }
+      installed++;
     } catch (error) {
-      console.error(`   ✗ ${skill} (erro: ${error.message})`);
+      if (!quiet) {
+        console.log(chalk.red(`   ✗ Erro ao instalar ${skill}: ${error.message}`));
+      }
+      failed++;
     }
   });
   
-  console.log(`\n✅ ${skills.length} Codex skills instalados em ${CODEX_SKILLS_DIR}`);
+  if (!quiet) {
+    console.log(chalk.green(`\n✅ ${installed} Codex skill(s) instalado(s)`));
+    if (failed > 0) {
+      console.log(chalk.yellow(`⚠️  ${failed} skill(s) falharam`));
+    }
+  }
+
+  return { installed, failed };
 }
 
 module.exports = { install };

package/lib/detector.js

@@ -1,14 +1,18 @@
 const { execSync } = require('child_process');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
 
 /**
  * Detecta ferramentas AI CLI instaladas no sistema
- * @returns {Object} { copilot: {installed, version, path}, claude: {...}, ... }
+ * @returns {Object} { copilot: {installed, version, path}, claude: {...}, codex_cli: {...}, codex_app: {...}, ... }
  */
 function detectTools() {
   const tools = {
     copilot: detectCopilot(),
     claude: detectClaude(),
-    codex: detectCodex(),
+    codex_cli: detectCodexCli(),
+    codex_app: detectCodexApp(),
     opencode: detectOpenCode(),
     gemini: detectGemini()
   };
@@ -43,9 +47,9 @@ function detectClaude() {
 }
 
 /**
- * Detecta OpenAI Codex
+ * Detecta OpenAI Codex CLI
  */
-function detectCodex() {
+function detectCodexCli() {
   try {
     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();
@@ -55,6 +59,62 @@ function detectCodex() {
   }
 }
 
+/**
+ * Detecta OpenAI Codex App (Desktop)
+ */
+function detectCodexApp() {
+  // Check macOS
+  if (os.platform() === 'darwin') {
+    const appPath = '/Applications/Codex.app';
+    if (fs.existsSync(appPath)) {
+      try {
+        // Try to get version from Info.plist
+        const plistPath = path.join(appPath, 'Contents', 'Info.plist');
+        const version = 'Codex Desktop'; // Could parse plist for exact version
+        return { installed: true, version, path: appPath };
+      } catch (e) {
+        return { installed: true, version: 'unknown', path: appPath };
+      }
+    }
+  }
+  
+  // Check Linux (if applicable)
+  if (os.platform() === 'linux') {
+    // Could check for ~/.local/share/applications or similar
+    const homeDir = os.homedir();
+    const possiblePaths = [
+      path.join(homeDir, '.local', 'share', 'codex'),
+      '/opt/Codex',
+      '/usr/local/bin/Codex'
+    ];
+    
+    for (const appPath of possiblePaths) {
+      if (fs.existsSync(appPath)) {
+        return { installed: true, version: 'Codex Desktop', path: appPath };
+      }
+    }
+  }
+  
+  // Check Windows
+  if (os.platform() === 'win32') {
+    const programFiles = process.env['ProgramFiles'] || 'C:\\Program Files';
+    const appPath = path.join(programFiles, 'Codex', 'Codex.exe');
+    if (fs.existsSync(appPath)) {
+      return { installed: true, version: 'Codex Desktop', path: appPath };
+    }
+  }
+  
+  return { installed: false, version: null, path: null };
+}
+
+/**
+ * @deprecated Use detectCodexCli() and detectCodexApp() instead
+ * Detecta OpenAI Codex (mantido para backward compatibility)
+ */
+function detectCodex() {
+  return detectCodexCli();
+}
+
 /**
  * Detecta OpenCode
  */
@@ -123,5 +183,5 @@ Após instalar, execute novamente: npx cli-ai-skills
   `;
 }
 
-module.exports = { detectTools, getInstallInstructions };
+module.exports = { detectTools, getInstallInstructions, detectCodex, detectCodexCli, detectCodexApp };
 

package/lib/interactive.js

@@ -50,47 +50,58 @@ async function confirmCancel() {
 
 /**
  * Pergunta ao usuário para quais plataformas instalar
- * @param {Object} detected - Ferramentas detectadas { copilot, claude, codex, opencode, gemini }
+ * Codex CLI e Codex App são mostrados SEMPRE separadamente
+ * @param {Object} detected - Ferramentas detectadas { copilot, claude, codex_cli, codex_app, opencode, gemini }
  * @returns {Promise<Array>} Plataformas escolhidas
  */
 async function promptPlatforms(detected) {
   const choices = [];
   
-  if (detected.copilot) {
+  if (detected.copilot && detected.copilot.installed) {
     choices.push({
-      name: '✅ GitHub Copilot CLI (.github/skills/)',
+      name: '✅ GitHub Copilot CLI (~/.github/skills/)',
       value: 'copilot',
       checked: true
     });
   }
   
-  if (detected.claude) {
+  if (detected.claude && detected.claude.installed) {
     choices.push({
-      name: '✅ Claude Code (.claude/skills/)',
+      name: '✅ Claude Code (~/.claude/skills/)',
       value: 'claude',
       checked: true
     });
   }
   
-  if (detected.codex) {
+  // Codex CLI - sempre separado
+  if (detected.codex_cli && detected.codex_cli.installed) {
     choices.push({
-      name: '✅ OpenAI Codex (.codex/skills/)',
-      value: 'codex',
+      name: '✅ OpenAI Codex CLI (~/.codex/vendor_imports/skills/skills/.curated/)',
+      value: 'codex_cli',
       checked: true
     });
   }
   
-  if (detected.opencode) {
+  // Codex App - sempre separado
+  if (detected.codex_app && detected.codex_app.installed) {
     choices.push({
-      name: '✅ OpenCode (.opencode/skills/)',
+      name: '✅ OpenAI Codex App (~/.codex/vendor_imports/skills/skills/.curated/)',
+      value: 'codex_app',
+      checked: true
+    });
+  }
+  
+  if (detected.opencode && detected.opencode.installed) {
+    choices.push({
+      name: '✅ OpenCode (~/.opencode/skills/)',
       value: 'opencode',
       checked: true
     });
   }
   
-  if (detected.gemini) {
+  if (detected.gemini && detected.gemini.installed) {
     choices.push({
-      name: '✅ Gemini CLI (.gemini/skills/)',
+      name: '✅ Gemini CLI (~/.gemini/skills/)',
       value: 'gemini',
       checked: true
     });

package/lib/ui/table.js

@@ -2,36 +2,40 @@ const chalk = require('chalk');
 
 /**
  * Exibe tabela formatada de ferramentas detectadas
+ * Agora com Codex CLI e Codex App separados
  * @param {Object} tools - Objeto retornado por detectTools()
  */
 function displayToolsTable(tools) {
-  console.log('\n┌─────────────────────────────────────────────────────────────┐');
-  console.log('│ Ferramenta            │ Status   │ Versão              │');
-  console.log('├─────────────────────────────────────────────────────────────┤');
+  console.log('\n┌──────────────────────────────────────────────────────────────────┐');
+  console.log('│ Ferramenta            │ Status   │ Versão                    │');
+  console.log('├──────────────────────────────────────────────────────────────────┤');
   
   const toolNames = {
     copilot: 'GitHub Copilot CLI',
     claude: 'Claude Code',
-    codex: 'OpenAI Codex',
+    codex_cli: 'OpenAI Codex CLI',
+    codex_app: 'OpenAI Codex App',
     opencode: 'OpenCode',
     gemini: 'Gemini CLI'
   };
   
   for (const [key, name] of Object.entries(toolNames)) {
     const tool = tools[key];
+    if (!tool) continue; // Skip if tool not in detected object
+    
     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);
+    const versionStr = String(version).substring(0, 26);
+    const versionPadded = versionStr.padEnd(26);
     
     console.log(`│ ${namePadded} │${statusPadded}│ ${versionPadded}│`);
   }
   
-  console.log('└─────────────────────────────────────────────────────────────┘\n');
+  console.log('└──────────────────────────────────────────────────────────────────┘\n');
 }
 
 /**
@@ -44,12 +48,13 @@ function getToolsSummary(tools) {
   
   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.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');
   
   return {
-    total: 5,
+    total: 6,
     installed: installed.length,
     names: installed
   };

package/lib/utils/path-resolver.js

@@ -63,16 +63,35 @@ function getSkillsSourcePath(basePath, platform) {
 
 /**
  * Get user home directory skills path for a platform
+ * Includes multi-path fallback for Codex (robust solution)
  * @param {string} platform - Platform name
  * @returns {string} Path to user's skills directory
  */
 function getUserSkillsPath(platform) {
   const home = process.env.HOME || process.env.USERPROFILE;
 
+  // Special handling for Codex with multi-path fallback
+  if (platform === 'codex') {
+    const codexPaths = [
+      path.join(home, '.codex', 'vendor_imports', 'skills', 'skills', '.curated'), // Real path (primary)
+      path.join(home, '.codex', 'vendor_imports', 'skills', 'skills', '.custom'),  // Alternative
+      path.join(home, '.codex', 'skills')                                           // Documented path (fallback)
+    ];
+
+    // Return first existing path, or primary path if none exist (will be created)
+    for (const codexPath of codexPaths) {
+      if (fs.existsSync(codexPath)) {
+        return codexPath;
+      }
+    }
+    
+    // Return primary path (will be created during install)
+    return codexPaths[0];
+  }
+
   const platformDirs = {
     'copilot': path.join(home, '.github', 'skills'),
     'claude': path.join(home, '.claude', 'skills'),
-    'codex': path.join(home, '.codex', 'skills'),
     'opencode': path.join(home, '.opencode', 'skills'),
     'gemini': path.join(home, '.gemini', 'skills')
   };

package/package.json

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