@supercorks/skills-installer 1.0.0

package/README.md

@@ -0,0 +1,82 @@
+# @supercorks/skills-installer
+
+Interactive CLI installer for AI agent skills. Selectively install skills for GitHub Copilot, Claude, and other AI assistants using Git sparse-checkout.
+
+## Usage
+
+```bash
+npx @supercorks/skills-installer install
+```
+
+Or with the longer form:
+
+```bash
+npx --package=@supercorks/skills-installer skills-installer install
+```
+
+## What it does
+
+1. **Choose installation path** - Select where skills should be installed:
+   - `.github/skills/` (GitHub Copilot default)
+   - `.claude/skills/` (Claude)
+   - Custom path of your choice
+
+2. **Gitignore option** - Optionally add the installation path to `.gitignore`
+
+3. **Select skills** - Interactive checkbox to pick which skills to install:
+   - Use `↑`/`↓` to navigate
+   - Use `SPACE` to toggle selection
+   - Use `A` to toggle all
+   - Press `ENTER` to confirm
+
+4. **Sparse clone** - Only downloads the selected skills using Git sparse-checkout, keeping the download minimal while preserving full git functionality.
+
+## Features
+
+- **Minimal download** - Uses `git clone --filter=blob:none` for efficient cloning
+- **Push capable** - The sparse clone preserves the full git history, allowing you to commit and push changes
+- **Auto-discovery** - Fetches the latest skill list from the repository
+- **Recursive directory creation** - Custom paths are created automatically
+
+## Requirements
+
+- Node.js 18+
+- Git
+
+## Updating skills
+
+Since the installation uses a sparse git checkout, you can pull updates:
+
+```bash
+cd .github/skills  # or wherever you installed
+git pull
+```
+
+## Adding more skills later
+
+You can add more skills to an existing installation:
+
+```bash
+cd .github/skills
+git sparse-checkout add new-skill-name
+```
+
+## Development
+
+```bash
+# Clone the repo
+git clone https://github.com/supercorks/agent-skills-installer.git
+cd agent-skills-installer
+
+# Install dependencies
+npm install
+
+# Run locally
+npm start
+# or
+node bin/install.js install
+```
+
+## License
+
+MIT

package/bin/install.js

@@ -0,0 +1,175 @@
+#!/usr/bin/env node
+
+/**
+ * @supercorks/skills-installer
+ * Interactive CLI installer for AI agent skills
+ * 
+ * Usage: npx @supercorks/skills-installer install
+ */
+
+import { existsSync, appendFileSync, readFileSync, writeFileSync } from 'fs';
+import { resolve, join } from 'path';
+import { 
+  promptInstallPath, 
+  promptGitignore, 
+  promptSkillSelection,
+  showSpinner,
+  showSuccess,
+  showError
+} from '../lib/prompts.js';
+import { fetchAvailableSkills } from '../lib/skills.js';
+import { sparseCloneSkills, isGitAvailable } from '../lib/git.js';
+
+const VERSION = '1.0.0';
+
+/**
+ * Print usage information
+ */
+function printUsage() {
+  console.log(`
+@supercorks/skills-installer v${VERSION}
+
+Usage:
+  npx @supercorks/skills-installer            Install skills interactively (default)
+  npx @supercorks/skills-installer --help     Show this help message
+  npx @supercorks/skills-installer --version  Show version
+
+Examples:
+  npx @supercorks/skills-installer
+  npx @supercorks/skills-installer install
+`);
+}
+
+/**
+ * Add a path to .gitignore if not already present
+ * @param {string} gitignorePath - Path to .gitignore file
+ * @param {string} pathToIgnore - Path to add to .gitignore
+ */
+function addToGitignore(gitignorePath, pathToIgnore) {
+  // Normalize the path for gitignore (remove trailing slash for consistency)
+  const normalizedPath = pathToIgnore.replace(/\/$/, '');
+  const gitignoreEntry = `\n# AI Agent Skills\n${normalizedPath}/\n`;
+
+  if (existsSync(gitignorePath)) {
+    const content = readFileSync(gitignorePath, 'utf-8');
+    if (content.includes(normalizedPath)) {
+      console.log(`ℹ️  "${normalizedPath}" is already in .gitignore`);
+      return;
+    }
+    appendFileSync(gitignorePath, gitignoreEntry);
+  } else {
+    writeFileSync(gitignorePath, gitignoreEntry.trim() + '\n');
+  }
+  console.log(`✅ Added "${normalizedPath}/" to .gitignore`);
+}
+
+/**
+ * Main installation flow
+ */
+async function runInstall() {
+  console.log('\n🔧 AI Agent Skills Installer\n');
+
+  // Check git availability
+  if (!isGitAvailable()) {
+    showError('Git is not installed or not available in PATH. Please install git first.');
+    process.exit(1);
+  }
+
+  // Step 1: Fetch available skills
+  let skills;
+  const fetchSpinner = showSpinner('Fetching available skills from repository...');
+  try {
+    skills = await fetchAvailableSkills();
+    fetchSpinner.stop(`✅ Found ${skills.length} available skills`);
+  } catch (error) {
+    fetchSpinner.stop('❌ Failed to fetch skills');
+    showError(`Could not fetch skills list: ${error.message}`);
+    process.exit(1);
+  }
+
+  if (skills.length === 0) {
+    showError('No skills found in the repository');
+    process.exit(1);
+  }
+
+  // Step 2: Ask where to install
+  const installPath = await promptInstallPath();
+  const absoluteInstallPath = resolve(process.cwd(), installPath);
+
+  // Check if path already exists with a git repo
+  if (existsSync(join(absoluteInstallPath, '.git'))) {
+    showError(`"${installPath}" already contains a git repository. Please remove it first or choose a different path.`);
+    process.exit(1);
+  }
+
+  // Step 3: Ask about .gitignore
+  const shouldGitignore = await promptGitignore(installPath);
+
+  // Step 4: Select skills
+  const selectedSkills = await promptSkillSelection(skills);
+
+  // Step 5: Perform installation
+  console.log('');
+  const installSpinner = showSpinner('Installing selected skills...');
+  
+  try {
+    await sparseCloneSkills(installPath, selectedSkills, (message) => {
+      installSpinner.stop(`   ${message}`);
+    });
+  } catch (error) {
+    installSpinner.stop('❌ Installation failed');
+    showError(error.message);
+    process.exit(1);
+  }
+
+  // Step 6: Update .gitignore if requested
+  if (shouldGitignore) {
+    const gitignorePath = resolve(process.cwd(), '.gitignore');
+    addToGitignore(gitignorePath, installPath);
+  }
+
+  // Step 7: Show success
+  const installedSkillNames = skills
+    .filter(s => selectedSkills.includes(s.folder))
+    .map(s => s.name);
+  
+  showSuccess(installPath, installedSkillNames);
+}
+
+/**
+ * Parse command line arguments and run
+ */
+async function main() {
+  const args = process.argv.slice(2);
+  const command = args[0];
+
+  if (command === '--help' || command === '-h') {
+    printUsage();
+    process.exit(0);
+  }
+
+  if (command === '--version' || command === '-v') {
+    console.log(VERSION);
+    process.exit(0);
+  }
+
+  // Default to install if no command or explicit 'install' command
+  if (!command || command === 'install') {
+    try {
+      await runInstall();
+    } catch (error) {
+      if (error.message.includes('User force closed')) {
+        console.log('\n\n👋 Installation cancelled.\n');
+        process.exit(0);
+      }
+      showError(error.message);
+      process.exit(1);
+    }
+  } else {
+    console.error(`Unknown command: ${command}`);
+    printUsage();
+    process.exit(1);
+  }
+}
+
+main();

package/lib/git.js

@@ -0,0 +1,178 @@
+/**
+ * Git sparse-checkout utilities for cloning selected skills
+ */
+
+import { execSync, spawn } from 'child_process';
+import { existsSync, mkdirSync, rmSync, writeFileSync, readFileSync, appendFileSync } from 'fs';
+import { join, resolve } from 'path';
+import { getRepoUrl } from './skills.js';
+
+/**
+ * Check if git is available
+ * @returns {boolean}
+ */
+export function isGitAvailable() {
+  try {
+    execSync('git --version', { stdio: 'ignore' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Execute a git command and return the result
+ * @param {string[]} args - Git command arguments
+ * @param {string} cwd - Working directory
+ * @returns {Promise<string>}
+ */
+function runGitCommand(args, cwd) {
+  return new Promise((resolve, reject) => {
+    const proc = spawn('git', args, { 
+      cwd, 
+      stdio: ['ignore', 'pipe', 'pipe'] 
+    });
+    
+    let stdout = '';
+    let stderr = '';
+    
+    proc.stdout.on('data', (data) => { stdout += data.toString(); });
+    proc.stderr.on('data', (data) => { stderr += data.toString(); });
+    
+    proc.on('close', (code) => {
+      if (code === 0) {
+        resolve(stdout.trim());
+      } else {
+        reject(new Error(stderr || `Git command failed with code ${code}`));
+      }
+    });
+    
+    proc.on('error', reject);
+  });
+}
+
+/**
+ * Perform a sparse clone of the repository with only selected skills
+ * This method preserves full git history and allows push capability
+ * 
+ * @param {string} targetPath - Where to clone the repository
+ * @param {string[]} skillFolders - Array of skill folder names to include
+ * @param {(message: string) => void} onProgress - Progress callback
+ * @returns {Promise<void>}
+ */
+export async function sparseCloneSkills(targetPath, skillFolders, onProgress = () => {}) {
+  const repoUrl = getRepoUrl();
+  const absolutePath = resolve(targetPath);
+  
+  // Check if target already exists and has content
+  if (existsSync(absolutePath)) {
+    const gitDir = join(absolutePath, '.git');
+    if (existsSync(gitDir)) {
+      throw new Error(`Directory "${targetPath}" already contains a git repository. Please remove it first or choose a different path.`);
+    }
+  }
+
+  // Create target directory
+  mkdirSync(absolutePath, { recursive: true });
+
+  try {
+    // Clone with blob filter for minimal download, no checkout yet
+    onProgress('Initializing sparse clone...');
+    await runGitCommand([
+      'clone',
+      '--filter=blob:none',
+      '--no-checkout',
+      '--sparse',
+      repoUrl,
+      '.'
+    ], absolutePath);
+
+    // Use non-cone mode for precise control over what's checked out
+    // This prevents root-level files (README.md, etc.) from being included
+    onProgress('Configuring sparse-checkout...');
+    await runGitCommand([
+      'sparse-checkout',
+      'init',
+      '--no-cone'
+    ], absolutePath);
+
+    // Write explicit patterns - only skill folders, no root files
+    // Format: /folder/* includes everything in that folder recursively
+    const sparseCheckoutPath = join(absolutePath, '.git', 'info', 'sparse-checkout');
+    const patterns = skillFolders.map(folder => `/${folder}/`).join('\n');
+    writeFileSync(sparseCheckoutPath, patterns + '\n');
+
+    // Checkout the files
+    onProgress('Checking out files...');
+    await runGitCommand(['checkout'], absolutePath);
+
+    onProgress('Done!');
+  } catch (error) {
+    // Clean up on failure
+    try {
+      rmSync(absolutePath, { recursive: true, force: true });
+    } catch {
+      // Ignore cleanup errors
+    }
+    throw error;
+  }
+}
+
+/**
+ * Add more skills to an existing sparse-checkout
+ * @param {string} repoPath - Path to the existing sparse-checkout repo
+ * @param {string[]} skillFolders - Additional skill folders to add
+ * @returns {Promise<void>}
+ */
+export async function addSkillsToSparseCheckout(repoPath, skillFolders) {
+  const absolutePath = resolve(repoPath);
+  
+  if (!existsSync(join(absolutePath, '.git'))) {
+    throw new Error(`"${repoPath}" is not a git repository`);
+  }
+
+  // Append new patterns to sparse-checkout file (non-cone mode format)
+  const sparseCheckoutPath = join(absolutePath, '.git', 'info', 'sparse-checkout');
+  const newPatterns = skillFolders.map(folder => `/${folder}/`).join('\n');
+  appendFileSync(sparseCheckoutPath, newPatterns + '\n');
+  
+  // Re-apply sparse-checkout
+  await runGitCommand(['read-tree', '-mu', 'HEAD'], absolutePath);
+}
+
+/**
+ * List currently checked out skills in a sparse-checkout repo
+ * @param {string} repoPath - Path to the sparse-checkout repo
+ * @returns {Promise<string[]>} List of skill folder names
+ */
+export async function listCheckedOutSkills(repoPath) {
+  const absolutePath = resolve(repoPath);
+  
+  if (!existsSync(join(absolutePath, '.git'))) {
+    throw new Error(`"${repoPath}" is not a git repository`);
+  }
+
+  // Read patterns from sparse-checkout file (non-cone mode format: /folder/)
+  const sparseCheckoutPath = join(absolutePath, '.git', 'info', 'sparse-checkout');
+  if (!existsSync(sparseCheckoutPath)) {
+    return [];
+  }
+  
+  const content = readFileSync(sparseCheckoutPath, 'utf-8');
+  const patterns = content.split('\n').filter(Boolean);
+  
+  // Extract folder names from patterns like /folder/
+  return patterns
+    .map(p => p.replace(/^\/|\/$/g, ''))  // Remove leading/trailing slashes
+    .filter(p => p && !p.startsWith('.'));
+}
+
+/**
+ * Pull latest changes in a sparse-checkout repo
+ * @param {string} repoPath - Path to the sparse-checkout repo  
+ * @returns {Promise<string>}
+ */
+export async function pullUpdates(repoPath) {
+  const absolutePath = resolve(repoPath);
+  return runGitCommand(['pull'], absolutePath);
+}

package/lib/prompts.js

@@ -0,0 +1,276 @@
+/**
+ * Interactive CLI prompts using inquirer
+ */
+
+import inquirer from 'inquirer';
+import * as readline from 'readline';
+
+const PATH_CHOICES = {
+  GITHUB: '.github/skills/',
+  CLAUDE: '.claude/skills/',
+  CUSTOM: '__custom__'
+};
+
+/**
+ * Extract the first sentence from a description
+ * @param {string} text - Full description text
+ * @param {number} maxLength - Maximum length before truncating
+ * @returns {string}
+ */
+function getFirstSentence(text, maxLength = 60) {
+  if (!text) return '';
+  // Match first sentence (ends with . ! or ?)
+  const match = text.match(/^[^.!?]+[.!?]/);
+  const sentence = match ? match[0].trim() : text;
+  if (sentence.length <= maxLength) return sentence;
+  return sentence.slice(0, maxLength - 3) + '...';
+}
+
+/**
+ * Prompt user to select installation path
+ * @returns {Promise<string>} The selected or custom path
+ */
+export async function promptInstallPath() {
+  const { pathChoice } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'pathChoice',
+      message: 'Where would you like to install the skills?',
+      choices: [
+        { name: '.github/skills/', value: PATH_CHOICES.GITHUB },
+        { name: '.claude/skills/', value: PATH_CHOICES.CLAUDE },
+        { name: 'Custom path...', value: PATH_CHOICES.CUSTOM }
+      ],
+      default: PATH_CHOICES.GITHUB
+    }
+  ]);
+
+  if (pathChoice === PATH_CHOICES.CUSTOM) {
+    const { customPath } = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'customPath',
+        message: 'Enter custom installation path:',
+        validate: (input) => {
+          if (!input.trim()) {
+            return 'Please enter a valid path';
+          }
+          return true;
+        }
+      }
+    ]);
+    return customPath.trim();
+  }
+
+  return pathChoice;
+}
+
+/**
+ * Prompt user whether to add path to .gitignore
+ * @param {string} installPath - The installation path to potentially ignore
+ * @returns {Promise<boolean>}
+ */
+export async function promptGitignore(installPath) {
+  const { shouldIgnore } = await inquirer.prompt([
+    {
+      type: 'confirm',
+      name: 'shouldIgnore',
+      message: `Add "${installPath}" to .gitignore?`,
+      default: true
+    }
+  ]);
+
+  return shouldIgnore;
+}
+
+/**
+ * Prompt user to select skills to install with expand/collapse support
+ * @param {Array<{name: string, description: string, folder: string}>} skills - Available skills
+ * @returns {Promise<string[]>} Selected skill folder names
+ */
+export async function promptSkillSelection(skills) {
+  return new Promise((resolve, reject) => {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+
+    // Enable raw mode for keypress detection
+    if (process.stdin.isTTY) {
+      process.stdin.setRawMode(true);
+    }
+    readline.emitKeypressEvents(process.stdin, rl);
+
+    let cursor = 0;
+    const selected = new Set();
+    const expanded = new Set();
+
+    const render = () => {
+      // Clear screen and move to top
+      process.stdout.write('\x1B[2J\x1B[H');
+      
+      console.log('\n📦 Available Skills');
+      console.log('─'.repeat(60));
+      console.log('↑↓ navigate  SPACE toggle  → expand  ← collapse  A all  ENTER confirm\n');
+      console.log('Select skills to install:\n');
+
+      skills.forEach((skill, i) => {
+        const isSelected = selected.has(skill.folder);
+        const isCursor = i === cursor;
+        const isExpanded = expanded.has(skill.folder);
+        
+        const checkbox = isSelected ? '◉' : '○';
+        const pointer = isCursor ? '❯' : ' ';
+        const expandIcon = isExpanded ? '▼' : '▶';
+        
+        // Highlight current line
+        const highlight = isCursor ? '\x1B[36m' : '';  // Cyan for selected
+        const reset = '\x1B[0m';
+        
+        const shortDesc = getFirstSentence(skill.description);
+        
+        if (isExpanded) {
+          console.log(`${highlight}${pointer} ${checkbox} ${skill.name}${reset}`);
+          // Show full description indented
+          const fullDesc = skill.description || 'No description available';
+          const lines = fullDesc.match(/.{1,55}/g) || [fullDesc];
+          lines.forEach(line => {
+            console.log(`     ${highlight}${line}${reset}`);
+          });
+        } else {
+          console.log(`${highlight}${pointer} ${checkbox} ${skill.name} ${expandIcon} ${shortDesc}${reset}`);
+        }
+      });
+
+      const selectedCount = selected.size;
+      console.log(`\n${selectedCount} skill${selectedCount !== 1 ? 's' : ''} selected`);
+    };
+
+    const cleanup = () => {
+      process.stdin.removeListener('keypress', handleKeypress);
+      if (process.stdin.isTTY) {
+        process.stdin.setRawMode(false);
+      }
+      rl.close();
+    };
+
+    const handleKeypress = (str, key) => {
+      if (!key) return;
+
+      if (key.ctrl && key.name === 'c') {
+        cleanup();
+        reject(new Error('User force closed the prompt'));
+        return;
+      }
+
+      switch (key.name) {
+        case 'up':
+          cursor = cursor > 0 ? cursor - 1 : skills.length - 1;
+          render();
+          break;
+        case 'down':
+          cursor = cursor < skills.length - 1 ? cursor + 1 : 0;
+          render();
+          break;
+        case 'right':
+          expanded.add(skills[cursor].folder);
+          render();
+          break;
+        case 'left':
+          expanded.delete(skills[cursor].folder);
+          render();
+          break;
+        case 'space':
+          const folder = skills[cursor].folder;
+          if (selected.has(folder)) {
+            selected.delete(folder);
+          } else {
+            selected.add(folder);
+          }
+          render();
+          break;
+        case 'a':
+          // Toggle all
+          if (selected.size === skills.length) {
+            selected.clear();
+          } else {
+            skills.forEach(s => selected.add(s.folder));
+          }
+          render();
+          break;
+        case 'return':
+          if (selected.size === 0) {
+            // Show error inline
+            process.stdout.write('\x1B[31mPlease select at least one skill\x1B[0m');
+            setTimeout(render, 1000);
+          } else {
+            cleanup();
+            // Clear and show final selection
+            process.stdout.write('\x1B[2J\x1B[H');
+            console.log('\n📦 Selected skills:');
+            skills.filter(s => selected.has(s.folder)).forEach(s => {
+              console.log(`   ✓ ${s.name}`);
+            });
+            console.log('');
+            resolve(Array.from(selected));
+          }
+          break;
+      }
+    };
+
+    process.stdin.on('keypress', handleKeypress);
+    render();
+  });
+}
+
+/**
+ * Display a spinner/loading message
+ * @param {string} message - Message to display
+ * @returns {{stop: (finalMessage: string) => void}}
+ */
+export function showSpinner(message) {
+  const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+  let i = 0;
+  
+  process.stdout.write(`${frames[0]} ${message}`);
+  
+  const interval = setInterval(() => {
+    i = (i + 1) % frames.length;
+    process.stdout.clearLine(0);
+    process.stdout.cursorTo(0);
+    process.stdout.write(`${frames[i]} ${message}`);
+  }, 80);
+
+  return {
+    stop: (finalMessage) => {
+      clearInterval(interval);
+      process.stdout.clearLine(0);
+      process.stdout.cursorTo(0);
+      console.log(finalMessage);
+    }
+  };
+}
+
+/**
+ * Display success message with next steps
+ * @param {string} installPath - Where skills were installed
+ * @param {string[]} installedSkills - List of installed skill names
+ */
+export function showSuccess(installPath, installedSkills) {
+  console.log('\n' + '═'.repeat(50));
+  console.log('✅ Skills installed successfully!');
+  console.log('═'.repeat(50));
+  console.log(`\n📁 Location: ${installPath}`);
+  console.log(`\n📦 Installed skills (${installedSkills.length}):`);
+  installedSkills.forEach(skill => console.log(`   • ${skill}`));
+  console.log('\n🚀 Your AI agent will automatically discover these skills.');
+  console.log('═'.repeat(50) + '\n');
+}
+
+/**
+ * Display error message
+ * @param {string} message - Error message
+ */
+export function showError(message) {
+  console.error(`\n❌ Error: ${message}\n`);
+}

package/lib/skills.js

@@ -0,0 +1,122 @@
+/**
+ * Fetch and parse available skills from the GitHub repository
+ */
+
+const REPO_OWNER = 'supercorks';
+const REPO_NAME = 'agent-skills';
+const GITHUB_API = 'https://api.github.com';
+
+// Folders to exclude from skill detection (not actual skills)
+const EXCLUDED_FOLDERS = ['.github', '.claude', 'node_modules'];
+
+/**
+ * Fetch the list of skill directories from the repository
+ * Skills are at the repo root level, each folder with a SKILL.md is a skill
+ * @returns {Promise<Array<{name: string, description: string, folder: string}>>}
+ */
+export async function fetchAvailableSkills() {
+  const repoUrl = `${GITHUB_API}/repos/${REPO_OWNER}/${REPO_NAME}/contents`;
+  
+  const response = await fetch(repoUrl, {
+    headers: {
+      'Accept': 'application/vnd.github.v3+json',
+      'User-Agent': '@supercorks/skills-installer'
+    }
+  });
+
+  if (!response.ok) {
+    throw new Error(`Failed to fetch skills list: ${response.status} ${response.statusText}`);
+  }
+
+  const contents = await response.json();
+  
+  // Filter to directories that aren't excluded
+  const potentialSkillDirs = contents.filter(
+    item => item.type === 'dir' && !EXCLUDED_FOLDERS.includes(item.name) && !item.name.startsWith('.')
+  );
+
+  // Check each directory for SKILL.md to confirm it's a skill
+  const skillChecks = await Promise.all(
+    potentialSkillDirs.map(async (dir) => {
+      const metadata = await fetchSkillMetadata(dir.name);
+      // Only include if we found valid metadata (has a SKILL.md)
+      if (metadata.name || metadata.description) {
+        return {
+          folder: dir.name,
+          name: metadata.name || dir.name,
+          description: metadata.description || 'No description available'
+        };
+      }
+      return null;
+    })
+  );
+
+  return skillChecks.filter(Boolean);
+}
+
+/**
+ * Fetch and parse SKILL.md frontmatter for a specific skill
+ * @param {string} skillFolder - The skill folder name
+ * @returns {Promise<{name: string, description: string}>}
+ */
+async function fetchSkillMetadata(skillFolder) {
+  const skillMdUrl = `${GITHUB_API}/repos/${REPO_OWNER}/${REPO_NAME}/contents/${skillFolder}/SKILL.md`;
+  
+  try {
+    const response = await fetch(skillMdUrl, {
+      headers: {
+        'Accept': 'application/vnd.github.v3+json',
+        'User-Agent': '@supercorks/skills-installer'
+      }
+    });
+
+    if (!response.ok) {
+      return { name: '', description: '' };
+    }
+
+    const data = await response.json();
+    const content = Buffer.from(data.content, 'base64').toString('utf-8');
+    
+    return parseSkillFrontmatter(content);
+  } catch (error) {
+    return { name: '', description: '' };
+  }
+}
+
+/**
+ * Parse the SKILL.md frontmatter to extract name and description
+ * Supports both ```skill code fence and standard --- frontmatter
+ * @param {string} content - The SKILL.md file content
+ * @returns {{name: string, description: string}}
+ */
+function parseSkillFrontmatter(content) {
+  // Try to match ```skill fenced frontmatter first
+  const skillFenceMatch = content.match(/```skill\s*\n---\s*\n([\s\S]*?)\n---\s*\n/);
+  
+  // Fall back to standard --- frontmatter
+  const standardMatch = content.match(/^---\s*\n([\s\S]*?)\n---/);
+  
+  const frontmatterContent = skillFenceMatch?.[1] || standardMatch?.[1];
+  
+  if (!frontmatterContent) {
+    return { name: '', description: '' };
+  }
+
+  const nameMatch = frontmatterContent.match(/name:\s*['"]?([^'"\n]+)['"]?/);
+  const descMatch = frontmatterContent.match(/description:\s*['"]?([^'"\n]+)['"]?/);
+
+  return {
+    name: nameMatch?.[1]?.trim() || '',
+    description: descMatch?.[1]?.trim() || ''
+  };
+}
+
+/**
+ * Get the repository clone URL
+ * @returns {string}
+ */
+export function getRepoUrl() {
+  return `https://github.com/${REPO_OWNER}/${REPO_NAME}.git`;
+}
+
+export { REPO_OWNER, REPO_NAME };

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@supercorks/skills-installer",
+  "version": "1.0.0",
+  "description": "Interactive CLI installer for AI agent skills",
+  "type": "module",
+  "bin": {
+    "skills-installer": "./bin/install.js"
+  },
+  "files": [
+    "bin/",
+    "lib/"
+  ],
+  "scripts": {
+    "start": "node bin/install.js install"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/supercorks/agent-skills-installer.git"
+  },
+  "bugs": {
+    "url": "https://github.com/supercorks/agent-skills-installer/issues"
+  },
+  "homepage": "https://github.com/supercorks/agent-skills-installer#readme",
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "ai",
+    "agent",
+    "skills",
+    "copilot",
+    "claude",
+    "installer",
+    "cli"
+  ],
+  "author": "supercorks",
+  "license": "MIT",
+  "dependencies": {
+    "inquirer": "^9.2.12"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}