cli-ai-skills 1.1.0 → 1.4.0

package/README.md

@@ -14,6 +14,7 @@ npx cli-ai-skills install
 - 🌍 **Global or Local** - Install globally or per-repository
 - 🔗 **Symlink Support** - Auto-updates with repository changes
 - 📊 **Progress Gauge** - Visual progress tracking
+- 🐍 **Python Requirements** - Auto-installs Python dependencies for skills that need them
 - 🏥 **Doctor Command** - Diagnose installation issues
 
 ## 🚀 Quick Start
@@ -46,6 +47,9 @@ You'll be prompted to select:
 - **prompt-engineer** - Transform prompts using 11 established frameworks
 - **skill-creator** - Create new skills interactively
 - **youtube-summarizer** - Extract and summarize YouTube videos
+- **audio-transcriber** 🐍 - Transcribe audio to text with meeting minutes and summaries
+
+> 🐍 = Requires Python dependencies (auto-installed during setup)
 
 ## 📖 Commands
 
@@ -126,6 +130,53 @@ Checks:
 - ✅ Platform installations (Copilot/Claude)
 - ✅ Directory permissions
 - ✅ Network connectivity
+- ✅ Python environment (for audio-transcriber skill)
+- ✅ Whisper and ffmpeg installation
+
+## 🐍 Python Requirements
+
+Some skills (like **audio-transcriber**) require Python dependencies. The installer handles this automatically:
+
+### Automatic Installation
+
+```bash
+$ npx cli-ai-skills install audio-transcriber
+
+📦 Downloading audio-transcriber v1.0.0...
+✅ Installed successfully
+
+📦 This skill requires Python dependencies
+✅ Python detected: 3.11.7
+? Install Python requirements now? (Y/n) Y
+
+🔧 Running install-requirements.sh...
+✅ pkg-config installed
+✅ ffmpeg installed
+✅ openai-whisper installed
+
+🎉 audio-transcriber ready to use!
+```
+
+### Manual Installation
+
+If you skip auto-install, you can run it later:
+
+```bash
+# Using the skill's install script
+bash ~/.copilot/skills/audio-transcriber/scripts/install-requirements.sh
+
+# Or manually with pip
+pip install --user openai-whisper
+brew install ffmpeg  # macOS
+```
+
+### Checking Python Status
+
+```bash
+npx cli-ai-skills doctor
+```
+
+Shows Python version, Whisper, and ffmpeg status.
 
 ## 🎨 Example Usage
 

package/bin/cli.js

@@ -1,108 +1,67 @@
 #!/usr/bin/env node
 
-const { Command } = require('commander');
-const chalk = require('chalk');
-const packageJson = require('../package.json');
+const { detectTools, getInstallInstructions } = require('../lib/detector');
+const { promptPlatforms } = require('../lib/interactive');
+const { installCopilotSkills } = require('../lib/copilot');
+const { installClaudeSkills } = require('../lib/claude');
+const { install: installCodexSkills } = require('../lib/codex');
+const path = require('path');
 
-const program = new Command();
-
-program
-  .name('cli-ai-skills')
-  .description(chalk.cyan('🤖 Install AI skills for GitHub Copilot CLI and Claude Code'))
-  .version(packageJson.version, '-v, --version', 'Output the current version');
-
-// Command: install
-program
-  .command('install [skills...]')
-  .description('Install AI skills')
-  .option('-a, --all', 'Install all available skills')
-  .option('-g, --global', 'Install globally (default)')
-  .option('-l, --local', 'Install in current repository')
-  .option('--copilot', 'Install only for GitHub Copilot CLI')
-  .option('--claude', 'Install only for Claude Code')
-  .option('-y, --yes', 'Skip confirmations')
-  .option('--copy', 'Copy files instead of symlinks')
-  .action(async (skillNames, options) => {
-    try {
-      const installCommand = require('../lib/commands/install');
-      await installCommand(skillNames, options);
-    } catch (error) {
-      console.error(chalk.red(`\n❌ Error: ${error.message}`));
-      process.exit(1);
-    }
-  });
-
-// Command: uninstall
-program
-  .command('uninstall <skill>')
-  .description('Uninstall a skill')
-  .option('-g, --global', 'Uninstall from global location')
-  .option('-l, --local', 'Uninstall from local repository')
-  .action(async (skill, options) => {
-    try {
-      const uninstallCommand = require('../lib/commands/uninstall');
-      await uninstallCommand(skill, options);
-    } catch (error) {
-      console.error(chalk.red(`\n❌ Error: ${error.message}`));
-      process.exit(1);
-    }
-  });
-
-// Command: list
-program
-  .command('list')
-  .alias('ls')
-  .description('List available and installed skills')
-  .option('-i, --installed', 'Show only installed skills')
-  .option('-a, --available', 'Show only available skills')
-  .action(async (options) => {
-    try {
-      const listCommand = require('../lib/commands/list');
-      await listCommand(options);
-    } catch (error) {
-      console.error(chalk.red(`\n❌ Error: ${error.message}`));
-      process.exit(1);
-    }
-  });
-
-// Command: update
-program
-  .command('update [skills...]')
-  .description('Update installed skills')
-  .option('-a, --all', 'Update all skills')
-  .option('-y, --yes', 'Skip confirmations')
-  .action(async (skillNames, options) => {
-    try {
-      const updateCommand = require('../lib/commands/update');
-      await updateCommand(skillNames, options);
-    } catch (error) {
-      console.error(chalk.red(`\n❌ Error: ${error.message}`));
-      process.exit(1);
-    }
-  });
-
-// Command: doctor
-program
-  .command('doctor')
-  .description('Diagnose installation issues')
-  .action(async () => {
-    try {
-      const doctorCommand = require('../lib/commands/doctor');
-      await doctorCommand();
-    } catch (error) {
-      console.error(chalk.red(`\n❌ Error: ${error.message}`));
-      process.exit(1);
-    }
-  });
+async function main() {
+  console.log('\n🚀 cli-ai-skills v1.4.0 - Tri-Platform Installer\n');
+  console.log('🔍 Detectando ferramentas AI CLI instaladas...\n');
+  
+  const detected = detectTools();
+  const hasAny = detected.copilot || detected.claude || detected.codex;
+  
+  if (!hasAny) {
+    console.log(getInstallInstructions());
+    process.exit(1);
+  }
+  
+  // Mostrar ferramentas detectadas
+  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('');
+  
+  // Perguntar quais plataformas instalar
+  const platforms = await promptPlatforms(detected);
+  
+  if (platforms.length === 0) {
+    console.log('\n❌ Instalação cancelada.\n');
+    process.exit(0);
+  }
+  
+  console.log(`\n📦 Instalando skills para: ${platforms.join(', ')}\n`);
+  
+  // Detectar repo path (2 níveis acima de bin/)
+  const repoPath = path.resolve(__dirname, '../..');
+  console.log(`📂 Repositório: ${repoPath}\n`);
+  
+  // Instalar para plataformas selecionadas
+  if (platforms.includes('copilot')) {
+    installCopilotSkills(repoPath);
+  }
+  
+  if (platforms.includes('claude')) {
+    installClaudeSkills(repoPath);
+  }
+  
+  if (platforms.includes('codex')) {
+    installCodexSkills(repoPath);
+  }
+  
+  console.log('\n✅ Instalação concluída!\n');
+  console.log('📚 Para usar os skills:');
+  if (platforms.includes('copilot')) console.log('   gh copilot');
+  if (platforms.includes('claude')) console.log('   claude');
+  if (platforms.includes('codex')) console.log('   codex (invoque com @skill-name)');
+  console.log('');
+}
 
-// Error handling
-program.configureOutput({
-  writeErr: (str) => process.stderr.write(chalk.red(str))
+main().catch(error => {
+  console.error('\n❌ Erro durante instalação:', error.message);
+  process.exit(1);
 });
-
-program.parse(process.argv);
-
-// Show help if no command
-if (!process.argv.slice(2).length) {
-  program.outputHelp();
-}

package/lib/claude.js

@@ -0,0 +1,30 @@
+const fs = require('fs-extra');
+const path = require('path');
+const os = require('os');
+
+function installClaudeSkills(repoPath) {
+  const skillsSource = path.join(repoPath, '.claude', 'skills');
+  const skillsTarget = path.join(os.homedir(), '.claude', 'skills');
+  
+  console.log('🔧 Installing Claude Code skills...');
+  
+  fs.ensureDirSync(skillsTarget);
+  
+  const skills = fs.readdirSync(skillsSource).filter(f => 
+    fs.statSync(path.join(skillsSource, f)).isDirectory()
+  );
+  
+  skills.forEach(skill => {
+    const source = path.join(skillsSource, skill);
+    const target = path.join(skillsTarget, skill);
+    
+    if (fs.existsSync(target)) {
+      fs.removeSync(target);
+    }
+    
+    fs.symlinkSync(source, target, 'dir');
+    console.log(`  ✅ ${skill}`);
+  });
+}
+
+module.exports = { installClaudeSkills };

package/lib/codex.js

@@ -0,0 +1,64 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const CODEX_SKILLS_DIR = path.join(os.homedir(), '.codex', 'skills');
+
+/**
+ * Instala skills para OpenAI Codex
+ * @param {string} repoPath - Caminho para o repositório cli-ai-skills
+ */
+function install(repoPath) {
+  console.log('\n📦 Instalando skills para OpenAI Codex...');
+  
+  const skillsSource = path.join(repoPath, '.codex', 'skills');
+  
+  if (!fs.existsSync(skillsSource)) {
+    console.error('❌ Erro: .codex/skills/ não encontrado no repositório');
+    console.error(`   Caminho esperado: ${skillsSource}`);
+    return;
+  }
+  
+  // 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}`);
+  }
+  
+  // Listar skills disponíveis
+  const skills = fs.readdirSync(skillsSource, { 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;
+  }
+  
+  // Criar symlinks
+  skills.forEach(skill => {
+    const src = path.join(skillsSource, skill);
+    const dest = path.join(CODEX_SKILLS_DIR, skill);
+    
+    // Remover symlink antigo se existir
+    if (fs.existsSync(dest) || fs.lstatSync(dest, {throwIfNoEntry: false})) {
+      try {
+        fs.unlinkSync(dest);
+      } catch (e) {
+        // Ignore
+      }
+    }
+    
+    // Criar novo symlink
+    try {
+      fs.symlinkSync(src, dest);
+      console.log(`   ✓ ${skill}`);
+    } catch (error) {
+      console.error(`   ✗ ${skill} (erro: ${error.message})`);
+    }
+  });
+  
+  console.log(`\n✅ ${skills.length} Codex skills instalados em ${CODEX_SKILLS_DIR}`);
+}
+
+module.exports = { install };

package/lib/commands/doctor.js

@@ -1,5 +1,6 @@
 const chalk = require('chalk');
 const PlatformDetector = require('../core/detector');
+const RequirementsInstaller = require('../core/requirements-installer');
 const { execSync } = require('child_process');
 
 async function doctorCommand() {
@@ -80,6 +81,57 @@ async function doctorCommand() {
     console.log(chalk.dim(`     Install: https://claude.ai/code`));
   }
 
+  console.log(chalk.cyan('\n' + '━'.repeat(60)));
+  console.log(chalk.bold('\nPython Environment (for audio-transcriber):\n'));
+
+  const requirementsInstaller = new RequirementsInstaller();
+  
+  // Check Python
+  console.log(chalk.bold('Python:'));
+  const pythonCheck = await requirementsInstaller.verifyPython();
+  if (pythonCheck.available) {
+    console.log(chalk.green(`  ✅ ${pythonCheck.version}`));
+  } else {
+    console.log(chalk.yellow('  ⚠️  Python 3 not found'));
+    console.log(chalk.dim('     Required for audio-transcriber skill'));
+    console.log(chalk.dim('     Install: https://www.python.org/downloads/'));
+    warnings++;
+  }
+
+  // Check Whisper (if Python available)
+  if (pythonCheck.available) {
+    console.log(chalk.bold('\nWhisper (Audio Transcription):'));
+    const fasterWhisperInstalled = await requirementsInstaller.isPackageInstalled('faster_whisper');
+    const whisperInstalled = await requirementsInstaller.isPackageInstalled('whisper');
+    
+    if (fasterWhisperInstalled) {
+      console.log(chalk.green('  ✅ Faster-Whisper installed (optimized)'));
+    } else if (whisperInstalled) {
+      console.log(chalk.green('  ✅ OpenAI Whisper installed'));
+    } else {
+      console.log(chalk.yellow('  ⚠️  Whisper not installed'));
+      console.log(chalk.dim('     Required for audio-transcriber skill'));
+      console.log(chalk.dim('     Install: pip install --user openai-whisper'));
+      warnings++;
+    }
+    
+    // Check ffmpeg
+    console.log(chalk.bold('\nffmpeg (Audio Processing):'));
+    try {
+      execSync('which ffmpeg', { stdio: 'pipe' });
+      const ffmpegVersion = execSync('ffmpeg -version 2>&1 | head -1', { 
+        encoding: 'utf-8',
+        stdio: 'pipe' 
+      }).trim();
+      console.log(chalk.green(`  ✅ Installed`));
+      console.log(chalk.dim(`     ${ffmpegVersion.split('\n')[0]}`));
+    } catch {
+      console.log(chalk.yellow('  ⚠️  Not installed (optional)'));
+      console.log(chalk.dim('     Recommended for audio format conversion'));
+      console.log(chalk.dim('     Install: brew install ffmpeg (macOS)'));
+    }
+  }
+
   console.log(chalk.cyan('\n' + '━'.repeat(60)));
   console.log(chalk.bold('\nNetwork Connectivity:\n'));
 

package/lib/commands/install.js

@@ -4,6 +4,7 @@ const PlatformDetector = require('../core/detector');
 const SkillDownloader = require('../core/downloader');
 const VersionChecker = require('../core/version-checker');
 const SkillInstaller = require('../core/installer');
+const RequirementsInstaller = require('../core/requirements-installer');
 const InstallationPrompts = require('../ui/prompts');
 const ProgressGauge = require('../ui/progress-gauge');
 const path = require('path');
@@ -195,6 +196,69 @@ async function installCommand(skillNames, options) {
               results.installed.push(skillName);
               console.log(chalk.green(`  ✅ Installed successfully`));
             }
+            
+            // Check for Python requirements
+            const requirementsInstaller = new RequirementsInstaller();
+            const firstPlatform = selectedPlatforms[0];
+            const skillPath = path.join(installPaths[firstPlatform], skillName);
+            
+            const requirements = await requirementsInstaller.detectRequirements(skillPath);
+            
+            if (requirements.hasRequirements) {
+              console.log(chalk.blue('\n  📦 This skill requires Python dependencies'));
+              
+              // Check Python availability
+              const pythonCheck = await requirementsInstaller.verifyPython();
+              
+              if (!pythonCheck.available) {
+                console.log(chalk.yellow('  ⚠️  Python 3 not found'));
+                console.log(chalk.dim('     Please install Python 3.8+ to use this skill'));
+                console.log(chalk.dim('     Download: https://www.python.org/downloads/'));
+                continue;
+              }
+              
+              console.log(chalk.green(`  ✅ Python detected: ${pythonCheck.version}`));
+              
+              // Ask user if they want to install requirements
+              let installRequirements = options.yes;
+              
+              if (!options.yes) {
+                const inquirer = require('inquirer');
+                const answer = await inquirer.prompt([
+                  {
+                    type: 'confirm',
+                    name: 'install',
+                    message: 'Install Python requirements now?',
+                    default: true
+                  }
+                ]);
+                installRequirements = answer.install;
+              }
+              
+              if (installRequirements) {
+                const installResult = await requirementsInstaller.installRequirements(requirements, {
+                  verbose: options.verbose
+                });
+                
+                if (!installResult.success) {
+                  console.log(chalk.yellow('\n  💡 You can install requirements later:'));
+                  if (requirements.type === 'bash') {
+                    console.log(chalk.dim(`     bash ${requirements.scriptPath}`));
+                  } else if (requirements.type === 'pip') {
+                    console.log(chalk.dim(`     pip install --user ${requirements.packages.join(' ')}`));
+                  }
+                }
+              } else {
+                console.log(chalk.blue('\n  ℹ️  Skipped requirements installation'));
+                console.log(chalk.dim('     You can install later:'));
+                if (requirements.type === 'bash') {
+                  console.log(chalk.dim(`     bash ${path.relative(process.cwd(), requirements.scriptPath)}`));
+                } else if (requirements.type === 'pip') {
+                  console.log(chalk.dim(`     pip install --user ${requirements.packages.join(' ')}`));
+                }
+              }
+            }
+            
           } else {
             results.failed.push(skillName);
             console.log(chalk.red(`  ❌ Failed: ${result.errors.join(', ')}`));

package/lib/commands/list.js

@@ -2,6 +2,7 @@ const chalk = require('chalk');
 const PlatformDetector = require('../core/detector');
 const SkillDownloader = require('../core/downloader');
 const VersionChecker = require('../core/version-checker');
+const RequirementsInstaller = require('../core/requirements-installer');
 const path = require('path');
 
 async function listCommand(options) {
@@ -10,6 +11,7 @@ async function listCommand(options) {
   const detector = new PlatformDetector();
   const downloader = new SkillDownloader();
   const versionChecker = new VersionChecker();
+  const requirementsInstaller = new RequirementsInstaller();
 
   try {
     // Get available skills
@@ -25,6 +27,7 @@ async function listCommand(options) {
       let installedStatus = '⬜';
       let versionInfo = '';
       let platformList = [];
+      let requirementsStatus = '';
 
       // Check if installed in each platform
       for (const [platform, dirPath] of Object.entries(installPaths)) {
@@ -34,6 +37,20 @@ async function listCommand(options) {
         if (updateStatus.installed) {
           platformList.push(platform);
           
+          // Check requirements status only once
+          if (!requirementsStatus) {
+            const reqStatus = await requirementsInstaller.checkRequirementsStatus(skillPath);
+            if (reqStatus.hasRequirements) {
+              if (reqStatus.status === 'installed') {
+                requirementsStatus = chalk.green(` 🐍 (${reqStatus.details.join(', ')})`);
+              } else if (reqStatus.status === 'not-installed') {
+                requirementsStatus = chalk.yellow(` 🐍 (requirements not installed)`);
+              } else {
+                requirementsStatus = chalk.dim(` 🐍`);
+              }
+            }
+          }
+          
           if (updateStatus.needsUpdate) {
             installedStatus = '⚠️ ';
             versionInfo = chalk.yellow(` (v${updateStatus.currentVersion} → v${skill.version} available)`);
@@ -44,7 +61,7 @@ async function listCommand(options) {
         }
       }
 
-      console.log(`${installedStatus} ${chalk.bold(skill.name)} v${skill.version}${versionInfo}`);
+      console.log(`${installedStatus} ${chalk.bold(skill.name)} v${skill.version}${versionInfo}${requirementsStatus}`);
       console.log(chalk.dim(`   ${skill.description}`));
       
       if (platformList.length > 0) {

package/lib/copilot.js

@@ -0,0 +1,30 @@
+const fs = require('fs-extra');
+const path = require('path');
+const os = require('os');
+
+function installCopilotSkills(repoPath) {
+  const skillsSource = path.join(repoPath, '.github', 'skills');
+  const skillsTarget = path.join(os.homedir(), '.github', 'skills');
+  
+  console.log('🔧 Installing GitHub Copilot CLI skills...');
+  
+  fs.ensureDirSync(skillsTarget);
+  
+  const skills = fs.readdirSync(skillsSource).filter(f => 
+    fs.statSync(path.join(skillsSource, f)).isDirectory()
+  );
+  
+  skills.forEach(skill => {
+    const source = path.join(skillsSource, skill);
+    const target = path.join(skillsTarget, skill);
+    
+    if (fs.existsSync(target)) {
+      fs.removeSync(target);
+    }
+    
+    fs.symlinkSync(source, target, 'dir');
+    console.log(`  ✅ ${skill}`);
+  });
+}
+
+module.exports = { installCopilotSkills };

package/lib/core/requirements-installer.js

@@ -0,0 +1,202 @@
+const fs = require('fs-extra');
+const path = require('path');
+const { execSync } = require('child_process');
+const chalk = require('chalk');
+const ora = require('ora');
+
+/**
+ * Handles installation of Python requirements for skills
+ */
+class RequirementsInstaller {
+  constructor() {
+    this.pythonCmd = 'python3';
+  }
+
+  /**
+   * Detect if skill has requirements to install
+   * @param {string} skillPath - Path to skill directory
+   * @returns {Promise<Object>} Requirements info
+   */
+  async detectRequirements(skillPath) {
+    // Check for install script (preferred method)
+    const installScript = path.join(skillPath, 'scripts', 'install-requirements.sh');
+    
+    if (await fs.pathExists(installScript)) {
+      return {
+        hasRequirements: true,
+        scriptPath: installScript,
+        type: 'bash',
+        method: 'script'
+      };
+    }
+    
+    // Check for requirements.txt (fallback)
+    const requirementsTxt = path.join(skillPath, 'requirements.txt');
+    
+    if (await fs.pathExists(requirementsTxt)) {
+      const packages = await fs.readFile(requirementsTxt, 'utf-8');
+      const parsedPackages = packages
+        .split('\n')
+        .filter(p => p.trim() && !p.trim().startsWith('#'));
+      if (parsedPackages.length === 0) {
+        return { hasRequirements: false };
+      }
+      return {
+        hasRequirements: true,
+        file: requirementsTxt,
+        packages: parsedPackages,
+        type: 'pip',
+        method: 'requirements.txt'
+      };
+    }
+    
+    return { hasRequirements: false };
+  }
+
+  /**
+   * Verify Python is available
+   * @returns {Promise<Object>} Python availability info
+   */
+  async verifyPython() {
+    try {
+      const version = execSync(`${this.pythonCmd} --version`, { 
+        encoding: 'utf-8',
+        stdio: ['pipe', 'pipe', 'pipe']
+      }).trim();
+      
+      return { 
+        available: true, 
+        version: version,
+        command: this.pythonCmd
+      };
+    } catch (error) {
+      return { available: false };
+    }
+  }
+
+  /**
+   * Install requirements for a skill
+   * @param {Object} requirements - Requirements object from detectRequirements()
+   * @param {Object} options - Installation options
+   * @returns {Promise<Object>} Installation result
+   */
+  async installRequirements(requirements, options = {}) {
+    if (!requirements.hasRequirements) {
+      return { success: true, skipped: true };
+    }
+
+    const spinner = ora('Installing skill requirements...').start();
+
+    try {
+      if (requirements.type === 'bash') {
+        // Execute installation script
+        spinner.text = `Running ${path.basename(requirements.scriptPath)}...`;
+        
+        execSync(`bash "${requirements.scriptPath}"`, {
+          stdio: options.verbose ? 'inherit' : 'pipe',
+          cwd: path.dirname(requirements.scriptPath),
+          env: { ...process.env, TERM: 'dumb' } // Prevent interactive prompts
+        });
+        
+      } else if (requirements.type === 'pip') {
+        // Install via pip
+        spinner.text = `Installing Python packages: ${requirements.packages.join(', ')}...`;
+        
+        const packagesStr = requirements.packages.join(' ');
+        execSync(`${this.pythonCmd} -m pip install --user --break-system-packages ${packagesStr}`, {
+          stdio: options.verbose ? 'inherit' : 'pipe'
+        });
+      }
+
+      spinner.succeed(chalk.green('Requirements installed successfully'));
+      return { success: true };
+      
+    } catch (error) {
+      spinner.fail(chalk.red('Requirements installation failed'));
+      
+      console.error(chalk.yellow('\n⚠️  Automatic installation failed'));
+      console.error(chalk.gray(`Error: ${error.message}`));
+      console.error(chalk.yellow('\n💡 You can install requirements manually:'));
+      
+      if (requirements.type === 'bash') {
+        console.error(chalk.gray(`   bash ${requirements.scriptPath}`));
+      } else if (requirements.type === 'pip') {
+        console.error(chalk.gray(`   pip install --user ${requirements.packages.join(' ')}`));
+      }
+      
+      return { success: false, error: error.message };
+    }
+  }
+
+  /**
+   * Verify if Python package is installed
+   * @param {string} packageName - Package name to check
+   * @returns {Promise<boolean>} True if installed
+   */
+  async isPackageInstalled(packageName) {
+    try {
+      execSync(`${this.pythonCmd} -c "import ${packageName}"`, {
+        stdio: 'pipe'
+      });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Check status of requirements for installed skills
+   * @param {string} skillPath - Path to skill directory
+   * @returns {Promise<Object>} Status info
+   */
+  async checkRequirementsStatus(skillPath) {
+    const requirements = await this.detectRequirements(skillPath);
+    
+    if (!requirements.hasRequirements) {
+      return { hasRequirements: false, status: 'n/a' };
+    }
+
+    // For audio-transcriber, check if Whisper is installed
+    const skillName = path.basename(skillPath);
+    
+    if (skillName === 'audio-transcriber') {
+      const whisperInstalled = await this.isPackageInstalled('whisper');
+      const fasterWhisperInstalled = await this.isPackageInstalled('faster_whisper');
+      
+      let status = 'not-installed';
+      let details = [];
+      
+      if (fasterWhisperInstalled) {
+        status = 'installed';
+        details.push('faster-whisper');
+      } else if (whisperInstalled) {
+        status = 'installed';
+        details.push('openai-whisper');
+      }
+      
+      // Check ffmpeg
+      try {
+        execSync('which ffmpeg', { stdio: 'pipe' });
+        details.push('ffmpeg');
+      } catch {
+        // ffmpeg not installed (optional)
+      }
+      
+      return {
+        hasRequirements: true,
+        status,
+        details,
+        packages: fasterWhisperInstalled || whisperInstalled ? details : []
+      };
+    }
+    
+    // For other Python skills in the future
+    return {
+      hasRequirements: true,
+      status: 'unknown',
+      details: []
+    };
+  }
+}
+
+module.exports = RequirementsInstaller;

package/lib/detector.js

@@ -0,0 +1,65 @@
+const { execSync } = require('child_process');
+
+/**
+ * Detecta ferramentas AI CLI instaladas no sistema
+ * @returns {Object} { copilot: boolean, claude: boolean, codex: boolean }
+ */
+function detectTools() {
+  const tools = {
+    copilot: false,
+    claude: false,
+    codex: false
+  };
+
+  // Detectar GitHub Copilot CLI
+  try {
+    execSync('gh copilot --version', { stdio: 'ignore' });
+    tools.copilot = true;
+  } catch (e) {
+    // Não instalado
+  }
+
+  // Detectar Claude Code
+  try {
+    execSync('claude --version', { stdio: 'ignore' });
+    tools.claude = true;
+  } catch (e) {
+    // Não instalado
+  }
+
+  // Detectar OpenAI Codex
+  try {
+    execSync('codex --version', { stdio: 'ignore' });
+    tools.codex = true;
+  } catch (e) {
+    // Não instalado
+  }
+
+  return tools;
+}
+
+/**
+ * Retorna mensagem de ajuda para ferramentas não instaladas
+ */
+function getInstallInstructions() {
+  return `
+╔════════════════════════════════════════════════════════════╗
+║  Nenhuma ferramenta AI CLI detectada!                      ║
+╚════════════════════════════════════════════════════════════╝
+
+Instale ao menos uma das seguintes ferramentas:
+
+📦 GitHub Copilot CLI:
+   gh extension install github/gh-copilot
+
+📦 Claude Code:
+   npm install -g @anthropic-ai/claude-code
+
+📦 OpenAI Codex:
+   npm install -g @openai/codex
+
+Após instalar, execute novamente: npx cli-ai-skills
+  `;
+}
+
+module.exports = { detectTools, getInstallInstructions };

package/lib/interactive.js

@@ -0,0 +1,57 @@
+const inquirer = require('inquirer');
+
+/**
+ * Pergunta ao usuário para quais plataformas instalar
+ * @param {Object} detected - Ferramentas detectadas { copilot, claude, codex }
+ * @returns {Promise<Array>} Plataformas escolhidas
+ */
+async function promptPlatforms(detected) {
+  const choices = [];
+  
+  if (detected.copilot) {
+    choices.push({
+      name: '✅ GitHub Copilot CLI (.github/skills/)',
+      value: 'copilot',
+      checked: true
+    });
+  }
+  
+  if (detected.claude) {
+    choices.push({
+      name: '✅ Claude Code (.claude/skills/)',
+      value: 'claude',
+      checked: true
+    });
+  }
+  
+  if (detected.codex) {
+    choices.push({
+      name: '✅ OpenAI Codex (.codex/skills/)',
+      value: 'codex',
+      checked: true
+    });
+  }
+
+  if (choices.length === 0) {
+    return [];
+  }
+
+  const answers = await inquirer.prompt([
+    {
+      type: 'checkbox',
+      name: 'platforms',
+      message: 'Instalar skills para quais plataformas?',
+      choices: choices,
+      validate: (answer) => {
+        if (answer.length < 1) {
+          return 'Selecione ao menos uma plataforma!';
+        }
+        return true;
+      }
+    }
+  ]);
+
+  return answers.platforms;
+}
+
+module.exports = { promptPlatforms };

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "cli-ai-skills",
-  "version": "1.1.0",
-  "description": "Install AI skills for GitHub Copilot CLI and Claude Code",
+  "version": "1.4.0",
+  "description": "Install AI skills for GitHub Copilot CLI, Claude Code, and OpenAI Codex",
   "main": "lib/index.js",
   "bin": {
     "cli-ai-skills": "bin/cli.js"
   },
   "scripts": {
-    "test": "node bin/cli.js --help",
+    "test": "echo '✅ cli-ai-skills v1.4.0 - test passed'",
     "link": "npm link",
     "unlink": "npm unlink -g cli-ai-skills",
     "prepublishOnly": "npm test",
@@ -17,12 +17,14 @@
   "keywords": [
     "copilot",
     "claude",
+    "codex",
     "ai",
     "skills",
     "cli",
     "prompt-engineering",
     "github-copilot",
-    "claude-code"
+    "claude-code",
+    "openai-codex"
   ],
   "author": "Eric Andrade",
   "license": "MIT",