cli-ai-skills 1.0.0 → 1.3.1

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/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/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/package.json

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