cli-ai-skills 1.0.0

package/lib/core/detector.js

@@ -0,0 +1,136 @@
+const fs = require('fs-extra');
+const path = require('path');
+const os = require('os');
+const { execSync} = require('child_process');
+
+class PlatformDetector {
+  constructor() {
+    this.homeDir = os.homedir();
+  }
+
+  /**
+   * Detect all available platforms
+   * @returns {Object} Platform detection results
+   */
+  async detectAll() {
+    return {
+      copilot: await this.detectCopilot(),
+      claude: await this.detectClaude()
+    };
+  }
+
+  /**
+   * Detect GitHub Copilot CLI
+   * @returns {Object} Detection result with installation status and paths
+   */
+  async detectCopilot() {
+    const result = {
+      installed: false,
+      cliInstalled: false,
+      version: null,
+      globalPath: path.join(this.homeDir, '.copilot', 'skills'),
+      localPath: path.join(process.cwd(), '.github', 'skills')
+    };
+
+    // Check if gh copilot is installed
+    try {
+      const version = execSync('gh copilot --version 2>&1', { encoding: 'utf8' });
+      result.cliInstalled = true;
+      result.version = version.trim();
+    } catch (error) {
+      result.cliInstalled = false;
+    }
+
+    // Check if global skills directory exists
+    result.installed = await fs.pathExists(path.join(this.homeDir, '.copilot'));
+
+    return result;
+  }
+
+  /**
+   * Detect Claude Code
+   * @returns {Object} Detection result with installation status and paths
+   */
+  async detectClaude() {
+    const result = {
+      installed: false,
+      version: null,
+      globalPath: path.join(this.homeDir, '.claude', 'skills'),
+      localPath: path.join(process.cwd(), '.claude', 'skills')
+    };
+
+    // Check if .claude directory exists
+    const claudeDir = path.join(this.homeDir, '.claude');
+    result.installed = await fs.pathExists(claudeDir);
+
+    // Try to get version from config
+    if (result.installed) {
+      const configPath = path.join(claudeDir, 'settings.local.json');
+      if (await fs.pathExists(configPath)) {
+        try {
+          const config = await fs.readJson(configPath);
+          result.version = config.version || 'unknown';
+        } catch (error) {
+          // Ignore JSON parse errors
+        }
+      }
+    }
+
+    return result;
+  }
+
+  /**
+   * Get installation paths based on scope
+   * @param {string} scope - 'global' or 'local'
+   * @param {Object} platforms - Platform detection results
+   * @returns {Object} Installation paths
+   */
+  getInstallPaths(scope, platforms) {
+    const paths = {};
+
+    if (scope === 'global') {
+      if (platforms.copilot) {
+        paths.copilot = platforms.copilot.globalPath;
+      }
+      if (platforms.claude) {
+        paths.claude = platforms.claude.globalPath;
+      }
+    } else {
+      // local
+      if (platforms.copilot) {
+        paths.copilot = platforms.copilot.localPath;
+      }
+      if (platforms.claude) {
+        paths.claude = platforms.claude.localPath;
+      }
+    }
+
+    return paths;
+  }
+
+  /**
+   * Ensure installation directories exist
+   * @param {Object} paths - Installation paths
+   */
+  async ensureDirectories(paths) {
+    for (const [platform, dirPath] of Object.entries(paths)) {
+      await fs.ensureDir(dirPath);
+    }
+  }
+
+  /**
+   * Check if directory is writable
+   * @param {string} dirPath - Directory path to check
+   * @returns {boolean} True if writable
+   */
+  async isWritable(dirPath) {
+    try {
+      await fs.access(dirPath, fs.constants.W_OK);
+      return true;
+    } catch (error) {
+      return false;
+    }
+  }
+}
+
+module.exports = PlatformDetector;

package/lib/core/downloader.js

@@ -0,0 +1,161 @@
+const axios = require('axios');
+const fs = require('fs-extra');
+const path = require('path');
+const os = require('os');
+const ora = require('ora');
+const yaml = require('js-yaml');
+
+class SkillDownloader {
+  constructor() {
+    this.repoOwner = 'ericgandrade';
+    this.repoName = 'cli-ai-skills';
+    this.branch = 'main';
+    this.cacheDir = path.join(os.homedir(), '.cli-ai-skills', 'cache');
+  }
+
+  /**
+   * List available skills from GitHub
+   * @returns {Array} List of skill objects
+   */
+  async listAvailableSkills() {
+    const spinner = ora('Fetching available skills...').start();
+    
+    try {
+      const url = `https://api.github.com/repos/${this.repoOwner}/${this.repoName}/contents/.github/skills`;
+      const response = await axios.get(url, {
+        headers: {
+          'Accept': 'application/vnd.github.v3+json',
+          'User-Agent': 'cli-ai-skills-installer'
+        }
+      });
+
+      const skills = [];
+      
+      for (const item of response.data) {
+        if (item.type === 'dir') {
+          // Get SKILL.md to extract metadata
+          const skillMeta = await this.getSkillMetadata(item.name, '.github');
+          skills.push({
+            name: item.name,
+            version: skillMeta.version,
+            description: skillMeta.description
+          });
+        }
+      }
+
+      spinner.succeed(`Found ${skills.length} skills`);
+      return skills;
+    } catch (error) {
+      spinner.fail('Failed to fetch skills');
+      throw new Error(`GitHub API error: ${error.message}`);
+    }
+  }
+
+  /**
+   * Get skill metadata from SKILL.md
+   * @param {string} skillName - Name of the skill
+   * @param {string} basePath - '.github' or '.claude'
+   * @returns {Object} Skill metadata
+   */
+  async getSkillMetadata(skillName, basePath = '.github') {
+    try {
+      const url = `https://raw.githubusercontent.com/${this.repoOwner}/${this.repoName}/${this.branch}/${basePath}/skills/${skillName}/SKILL.md`;
+      const response = await axios.get(url);
+      
+      // Extract YAML frontmatter
+      const frontmatterMatch = response.data.match(/^---\n([\s\S]*?)\n---/);
+      if (frontmatterMatch) {
+        return yaml.load(frontmatterMatch[1]);
+      }
+      
+      return { version: 'unknown', description: 'No description' };
+    } catch (error) {
+      return { version: 'unknown', description: 'No description' };
+    }
+  }
+
+  /**
+   * Download a skill directory from GitHub
+   * @param {string} skillName - Name of the skill
+   * @param {string} platform - 'copilot' or 'claude'
+   * @returns {string} Path to downloaded skill
+   */
+  async downloadSkill(skillName, platform = 'copilot') {
+    const spinner = ora(`Downloading ${skillName}...`).start();
+    
+    const basePath = platform === 'copilot' ? '.github/skills' : '.claude/skills';
+    const skillPath = path.join(this.cacheDir, platform, skillName);
+    
+    try {
+      // Ensure cache directory exists
+      await fs.ensureDir(skillPath);
+
+      // Get directory contents from GitHub API
+      const url = `https://api.github.com/repos/${this.repoOwner}/${this.repoName}/contents/${basePath}/${skillName}`;
+      const response = await axios.get(url, {
+        headers: {
+          'Accept': 'application/vnd.github.v3+json',
+          'User-Agent': 'cli-ai-skills-installer'
+        }
+      });
+
+      // Download each file
+      await this.downloadDirectory(response.data, skillPath);
+      
+      spinner.succeed(`Downloaded ${skillName}`);
+      return skillPath;
+    } catch (error) {
+      spinner.fail(`Failed to download ${skillName}`);
+      throw new Error(`Download error: ${error.message}`);
+    }
+  }
+
+  /**
+   * Recursively download directory contents
+   * @param {Array} contents - GitHub API contents response
+   * @param {string} targetPath - Target directory path
+   */
+  async downloadDirectory(contents, targetPath) {
+    for (const item of contents) {
+      const itemPath = path.join(targetPath, item.name);
+
+      if (item.type === 'file') {
+        // Download file
+        const response = await axios.get(item.download_url, {
+          responseType: 'arraybuffer',
+          headers: {
+            'User-Agent': 'cli-ai-skills-installer'
+          }
+        });
+        await fs.writeFile(itemPath, response.data);
+      } else if (item.type === 'dir') {
+        // Recursively download subdirectory
+        await fs.ensureDir(itemPath);
+        const subDirResponse = await axios.get(item.url, {
+          headers: {
+            'Accept': 'application/vnd.github.v3+json',
+            'User-Agent': 'cli-ai-skills-installer'
+          }
+        });
+        await this.downloadDirectory(subDirResponse.data, itemPath);
+      }
+    }
+  }
+
+  /**
+   * Clear download cache
+   */
+  async clearCache() {
+    await fs.remove(this.cacheDir);
+  }
+
+  /**
+   * Get cache directory path
+   * @returns {string} Cache directory path
+   */
+  getCacheDir() {
+    return this.cacheDir;
+  }
+}
+
+module.exports = SkillDownloader;

package/lib/core/installer.js

@@ -0,0 +1,150 @@
+const fs = require('fs-extra');
+const path = require('path');
+const chalk = require('chalk');
+const ora = require('ora');
+
+class SkillInstaller {
+  constructor(detector, downloader, versionChecker) {
+    this.detector = detector;
+    this.downloader = downloader;
+    this.versionChecker = versionChecker;
+  }
+
+  /**
+   * Install a skill
+   * @param {string} skillName - Name of the skill
+   * @param {Object} options - Installation options
+   * @returns {Object} Installation result
+   */
+  async install(skillName, options = {}) {
+    const {
+      platforms = ['copilot', 'claude'],
+      scope = 'global',
+      method = 'symlink',
+      force = false
+    } = options;
+
+    const results = {
+      skillName,
+      success: false,
+      platforms: {},
+      errors: []
+    };
+
+    try {
+      // Get platform paths
+      const platformInfo = await this.detector.detectAll();
+      const installPaths = this.detector.getInstallPaths(scope, platformInfo);
+
+      // Ensure directories exist
+      await this.detector.ensureDirectories(installPaths);
+
+      // Install for each selected platform
+      for (const platform of platforms) {
+        if (!installPaths[platform]) {
+          results.errors.push(`${platform} not available`);
+          continue;
+        }
+
+        try {
+          // Download skill for this platform
+          const sourcePath = await this.downloader.downloadSkill(skillName, platform);
+          const targetPath = path.join(installPaths[platform], skillName);
+
+          // Check if already exists
+          const exists = await fs.pathExists(targetPath);
+          if (exists && !force) {
+            // Get version info
+            const sourceVersion = await this.versionChecker.extractVersionFromSkill(sourcePath);
+            const targetVersion = await this.versionChecker.extractVersionFromSkill(targetPath);
+
+            results.platforms[platform] = {
+              status: 'exists',
+              currentVersion: targetVersion,
+              availableVersion: sourceVersion,
+              skipped: true
+            };
+            continue;
+          }
+
+          // Remove existing if force
+          if (exists) {
+            await fs.remove(targetPath);
+          }
+
+          // Install based on method
+          if (method === 'symlink' && scope === 'global') {
+            // Create symlink (only for global installations)
+            await fs.symlink(sourcePath, targetPath, 'dir');
+            results.platforms[platform] = {
+              status: 'installed',
+              method: 'symlink',
+              path: targetPath
+            };
+          } else {
+            // Copy files (for local or when symlink not desired)
+            await fs.copy(sourcePath, targetPath);
+            results.platforms[platform] = {
+              status: 'installed',
+              method: 'copy',
+              path: targetPath
+            };
+          }
+
+        } catch (error) {
+          results.errors.push(`${platform}: ${error.message}`);
+          results.platforms[platform] = {
+            status: 'failed',
+            error: error.message
+          };
+        }
+      }
+
+      results.success = Object.values(results.platforms).some(p => p.status === 'installed');
+    } catch (error) {
+      results.errors.push(error.message);
+    }
+
+    return results;
+  }
+
+  /**
+   * Uninstall a skill
+   * @param {string} skillName - Name of the skill
+   * @param {Object} options - Uninstall options
+   */
+  async uninstall(skillName, options = {}) {
+    const { platforms = ['copilot', 'claude'], scope = 'global' } = options;
+    
+    const platformInfo = await this.detector.detectAll();
+    const installPaths = this.detector.getInstallPaths(scope, platformInfo);
+
+    const results = { removed: [], failed: [] };
+
+    for (const platform of platforms) {
+      if (!installPaths[platform]) continue;
+
+      const skillPath = path.join(installPaths[platform], skillName);
+      
+      if (await fs.pathExists(skillPath)) {
+        try {
+          await fs.remove(skillPath);
+          results.removed.push(platform);
+        } catch (error) {
+          results.failed.push({ platform, error: error.message });
+        }
+      }
+    }
+
+    return results;
+  }
+
+  /**
+   * Get version from downloaded skill
+   */
+  async getDownloadedVersion(skillPath) {
+    return await this.versionChecker.extractVersionFromSkill(skillPath);
+  }
+}
+
+module.exports = SkillInstaller;

package/lib/core/version-checker.js

@@ -0,0 +1,129 @@
+const semver = require('semver');
+const fs = require('fs-extra');
+const path = require('path');
+const yaml = require('js-yaml');
+
+class VersionChecker {
+  /**
+   * Extract version from SKILL.md frontmatter
+   * @param {string} skillPath - Path to skill directory (containing SKILL.md)
+   * @returns {string|null} Version string or null
+   */
+  async extractVersionFromSkill(skillPath) {
+    const skillFile = path.join(skillPath, 'SKILL.md');
+    
+    if (!await fs.pathExists(skillFile)) {
+      return null;
+    }
+
+    try {
+      const content = await fs.readFile(skillFile, 'utf8');
+      
+      // Extract YAML frontmatter
+      const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
+      if (!frontmatterMatch) {
+        return null;
+      }
+
+      const frontmatter = yaml.load(frontmatterMatch[1]);
+      return frontmatter.version || null;
+    } catch (error) {
+      return null;
+    }
+  }
+
+  /**
+   * Compare two versions
+   * @param {string} current - Current version
+   * @param {string} latest - Latest version
+   * @returns {string} 'outdated', 'latest', 'newer', or 'unknown'
+   */
+  compareVersions(current, latest) {
+    if (!semver.valid(current) || !semver.valid(latest)) {
+      return 'unknown';
+    }
+
+    if (semver.gt(latest, current)) {
+      return 'outdated'; // Update available
+    } else if (semver.eq(current, latest)) {
+      return 'latest';
+    } else {
+      return 'newer'; // Installed version is newer (beta/dev)
+    }
+  }
+
+  /**
+   * Check if skill needs update
+   * @param {string} installedPath - Path to installed skill
+   * @param {string} latestVersion - Latest available version
+   * @returns {Object} Update status
+   */
+  async checkUpdate(installedPath, latestVersion) {
+    const currentVersion = await this.extractVersionFromSkill(installedPath);
+    
+    if (!currentVersion) {
+      return {
+        installed: false,
+        needsUpdate: false,
+        currentVersion: null,
+        latestVersion
+      };
+    }
+
+    const status = this.compareVersions(currentVersion, latestVersion);
+
+    return {
+      installed: true,
+      needsUpdate: status === 'outdated',
+      currentVersion,
+      latestVersion,
+      status
+    };
+  }
+
+  /**
+   * Get installed version for a skill
+   * @param {string} skillName - Name of the skill
+   * @param {string} platform - Platform (copilot or claude)
+   * @returns {string|null} Version string or null
+   */
+  async getInstalledVersion(skillName, platform) {
+    const os = require('os');
+    const homeDir = os.homedir();
+    
+    let skillPath;
+    if (platform === 'copilot') {
+      skillPath = path.join(homeDir, '.copilot', 'skills', skillName);
+    } else if (platform === 'claude') {
+      skillPath = path.join(homeDir, '.claude', 'skills', skillName);
+    } else {
+      return null;
+    }
+
+    return await this.extractVersionFromSkill(skillPath);
+  }
+
+  /**
+   * Check version status for a skill
+   * @param {string} skillName - Name of the skill
+   * @param {string} platform - Platform (copilot or claude)
+   * @param {string} latestVersion - Latest version (optional, will fetch if not provided)
+   * @returns {string} Status: 'outdated', 'latest', 'newer', 'not_installed', 'unknown'
+   */
+  async checkVersion(skillName, platform, latestVersion = null) {
+    const installedVersion = await this.getInstalledVersion(skillName, platform);
+    
+    if (!installedVersion) {
+      return 'not_installed';
+    }
+
+    if (!latestVersion) {
+      // If latest version not provided, we can't compare
+      return 'unknown';
+    }
+
+    return this.compareVersions(installedVersion, latestVersion);
+  }
+}
+
+module.exports = VersionChecker;

package/lib/ui/progress-gauge.js

@@ -0,0 +1,132 @@
+const chalk = require('chalk');
+
+/**
+ * Visual progress gauge for multi-step operations
+ * Creates a progress bar like: [████████████░░░░░░] 60% - Step 3/5: Installing skills
+ */
+class ProgressGauge {
+  constructor(totalSteps) {
+    this.totalSteps = totalSteps;
+    this.currentStep = 0;
+    this.barLength = 20; // Total characters in the progress bar
+  }
+
+  /**
+   * Update progress to next step
+   * @param {string} stepName - Description of current step
+   */
+  next(stepName) {
+    this.currentStep++;
+    this.render(stepName);
+  }
+
+  /**
+   * Set progress to specific step
+   * @param {number} step - Step number (1-indexed)
+   * @param {string} stepName - Description of current step
+   */
+  setStep(step, stepName) {
+    this.currentStep = step;
+    this.render(stepName);
+  }
+
+  /**
+   * Render the progress gauge
+   * @param {string} stepName - Description of current step
+   */
+  render(stepName = '') {
+    const percentage = Math.round((this.currentStep / this.totalSteps) * 100);
+    const filledLength = Math.round((this.currentStep / this.totalSteps) * this.barLength);
+    const emptyLength = this.barLength - filledLength;
+
+    // Create the visual bar
+    const filledBar = '█'.repeat(filledLength);
+    const emptyBar = '░'.repeat(emptyLength);
+    const bar = chalk.cyan(filledBar) + chalk.dim(emptyBar);
+
+    // Format the output
+    const percentageStr = chalk.bold(`${percentage}%`);
+    const stepStr = chalk.dim(`Step ${this.currentStep}/${this.totalSteps}`);
+    const nameStr = stepName ? chalk.white(`: ${stepName}`) : '';
+
+    console.log(`[${bar}] ${percentageStr} - ${stepStr}${nameStr}`);
+  }
+
+  /**
+   * Mark as complete
+   */
+  complete(message = 'Complete!') {
+    this.currentStep = this.totalSteps;
+    const bar = chalk.green('█'.repeat(this.barLength));
+    console.log(`[${bar}] ${chalk.green.bold('100%')} - ${chalk.green(message)}`);
+  }
+
+  /**
+   * Create a simple inline gauge (single line, no steps)
+   * @param {number} current - Current value
+   * @param {number} total - Total value
+   * @param {string} label - Label to display
+   * @returns {string} Formatted gauge string
+   */
+  static inline(current, total, label = '') {
+    const percentage = Math.round((current / total) * 100);
+    const barLength = 15;
+    const filledLength = Math.round((current / total) * barLength);
+    const emptyLength = barLength - filledLength;
+
+    const filledBar = chalk.cyan('█'.repeat(filledLength));
+    const emptyBar = chalk.dim('░'.repeat(emptyLength));
+    
+    const labelStr = label ? `${label} ` : '';
+    return `${labelStr}[${filledBar}${emptyBar}] ${chalk.bold(percentage + '%')}`;
+  }
+
+  /**
+   * Create a compact gauge for lists
+   * @param {number} current - Current value
+   * @param {number} total - Total value
+   * @returns {string} Compact gauge (just the bar)
+   */
+  static compact(current, total) {
+    const percentage = Math.round((current / total) * 100);
+    const barLength = 10;
+    const filledLength = Math.round((current / total) * barLength);
+    const emptyLength = barLength - filledLength;
+
+    const filledBar = '█'.repeat(filledLength);
+    const emptyBar = '░'.repeat(emptyLength);
+    
+    return `[${chalk.cyan(filledBar)}${chalk.dim(emptyBar)}]`;
+  }
+
+  /**
+   * Render a multi-operation progress summary
+   * @param {Object} stats - Statistics object { completed, failed, total }
+   */
+  static summary(stats) {
+    const { completed = 0, failed = 0, total = 0 } = stats;
+    const skipped = total - completed - failed;
+
+    console.log(chalk.cyan('\n📊 Progress Summary:\n'));
+    
+    if (completed > 0) {
+      const gauge = ProgressGauge.compact(completed, total);
+      console.log(`  ${gauge} ${chalk.green(`✅ Completed: ${completed}`)}`);
+    }
+    
+    if (failed > 0) {
+      const gauge = ProgressGauge.compact(failed, total);
+      console.log(`  ${gauge} ${chalk.red(`❌ Failed: ${failed}`)}`);
+    }
+    
+    if (skipped > 0) {
+      const gauge = ProgressGauge.compact(skipped, total);
+      console.log(`  ${gauge} ${chalk.yellow(`⏭️  Skipped: ${skipped}`)}`);
+    }
+
+    const overallGauge = ProgressGauge.compact(completed, total);
+    console.log(`\n  ${overallGauge} ${chalk.bold(`Overall: ${completed}/${total} successful`)}`);
+  }
+}
+
+module.exports = ProgressGauge;