@cnrai/pave 0.3.34 → 0.3.50

package/lib/skill-manager.js

@@ -1,891 +0,0 @@
-#!/usr/bin/env node
-/**
- * PAVE Skill Manager
- * Install, list, and remove skills from the OpenPave Skill Marketplace
- *
- * Supports:
- * - Local paths: pave install /path/to/skill
- * - GitHub repos: pave install github:user/repo
- * - GitHub URLs: pave install https://github.com/user/repo
- * - Short form: pave install user/repo (assumes GitHub)
- *
- * Node 16 compatible - runs on iSH iOS
- */
-
-const fs = require('fs');
-const path = require('path');
-const { execSync } = require('child_process');
-const os = require('os');
-const yaml = require('js-yaml');
-
-// Default paths (can be overridden with custom config)
-const DEFAULT_HOME_DIR = process.env.HOME || '/root';
-const DEFAULT_PAVE_DIR = path.join(DEFAULT_HOME_DIR, '.pave');
-const TEMP_DIR = path.join(os.tmpdir(), 'pave-install');
-
-// Module-level config (can be set via setPaveHome)
-let PAVE_HOME = DEFAULT_PAVE_DIR;
-
-/**
- * Set the PAVE home directory
- * @param {string|null} configPath - Custom .pave directory path, or null for default
- * @throws {Error} If path is invalid (empty string after resolution)
- */
-function setPaveHome(configPath) {
-  if (configPath) {
-    const resolved = path.resolve(configPath);
-    // Validate that path.resolve() produced a valid path
-    if (!resolved || resolved === '' || resolved === '/') {
-      throw new Error(`Invalid config path: "${configPath}" resolves to "${resolved}"`);
-    }
-    PAVE_HOME = resolved;
-  } else {
-    PAVE_HOME = DEFAULT_PAVE_DIR;
-  }
-}
-
-/**
- * Get current PAVE home directory
- * @returns {string}
- */
-function getPaveHome() {
-  return PAVE_HOME;
-}
-
-/**
- * Get paths based on current PAVE_HOME
- */
-function getPaths() {
-  return {
-    skillsDir: path.join(PAVE_HOME, 'skills'),
-    lockFile: path.join(PAVE_HOME, 'skills.lock.json'),
-    permissionsFile: path.join(PAVE_HOME, 'permissions.yaml'),
-  };
-}
-
-const _HOME_DIR = DEFAULT_HOME_DIR;
-
-/**
- * Parse a source string to determine if it's a GitHub repo
- * Supports:
- * - github:user/repo
- * - https://github.com/user/repo
- * - https://github.com/user/repo.git
- * - user/repo (short form, assumes GitHub)
- *
- * @param {string} source - The source string
- * @returns {Object|null} - { type: 'github', owner, repo, url } or null if not GitHub
- */
-function parseGitHubSource(source) {
-  // github:user/repo
-  if (source.startsWith('github:')) {
-    const parts = source.slice(7).split('/');
-    if (parts.length === 2) {
-      return {
-        type: 'github',
-        owner: parts[0],
-        repo: parts[1].replace(/\.git$/, ''),
-        url: `https://github.com/${parts[0]}/${parts[1].replace(/\.git$/, '')}.git`,
-      };
-    }
-  }
-
-  // https://github.com/user/repo
-  const githubUrlMatch = source.match(/^https?:\/\/github\.com\/([^\/]+)\/([^\/]+?)(\.git)?$/);
-  if (githubUrlMatch) {
-    return {
-      type: 'github',
-      owner: githubUrlMatch[1],
-      repo: githubUrlMatch[2],
-      url: `https://github.com/${githubUrlMatch[1]}/${githubUrlMatch[2]}.git`,
-    };
-  }
-
-  // user/repo short form (must be exactly user/repo, no slashes in names)
-  if (/^[a-zA-Z0-9_-]+\/[a-zA-Z0-9_-]+$/.test(source)) {
-    const parts = source.split('/');
-    return {
-      type: 'github',
-      owner: parts[0],
-      repo: parts[1],
-      url: `https://github.com/${parts[0]}/${parts[1]}.git`,
-    };
-  }
-
-  return null;
-}
-
-/**
- * Clone a GitHub repository to a temp directory
- * @param {Object} githubInfo - { owner, repo, url }
- * @param {Object} options - { verbose, branch }
- * @returns {string} - Path to cloned directory
- */
-function cloneFromGitHub(githubInfo, options = {}) {
-  const { verbose = false, branch = null } = options;
-
-  // Create temp directory
-  ensureDir(TEMP_DIR);
-  const cloneDir = path.join(TEMP_DIR, `${githubInfo.owner}-${githubInfo.repo}-${Date.now()}`);
-
-  // Clean up if exists
-  if (fs.existsSync(cloneDir)) {
-    removeDir(cloneDir);
-  }
-
-  // Build git clone command
-  let gitCmd = `git clone --depth 1`;
-  if (branch) {
-    gitCmd += ` --branch ${branch}`;
-  }
-  gitCmd += ` ${githubInfo.url} "${cloneDir}"`;
-
-  if (verbose) {
-    console.log(`Cloning from ${githubInfo.url}...`);
-  }
-
-  try {
-    execSync(gitCmd, {
-      stdio: verbose ? 'inherit' : 'pipe',
-      timeout: 60000, // 60 second timeout
-    });
-  } catch (error) {
-    // Try to provide helpful error message
-    if (error.message.includes('not found') || error.status === 128) {
-      throw new Error(`Repository not found: ${githubInfo.url}`);
-    }
-    throw new Error(`Failed to clone: ${error.message}`);
-  }
-
-  // Verify clone succeeded
-  if (!fs.existsSync(cloneDir)) {
-    throw new Error(`Clone failed: directory not created`);
-  }
-
-  // Verify skill.yaml or skill.json exists
-  const hasYaml = fs.existsSync(path.join(cloneDir, 'skill.yaml'));
-  const hasJson = fs.existsSync(path.join(cloneDir, 'skill.json'));
-  if (!hasYaml && !hasJson) {
-    removeDir(cloneDir);
-    throw new Error(`Not a valid skill: no skill.yaml or skill.json found in ${githubInfo.owner}/${githubInfo.repo}`);
-  }
-
-  return cloneDir;
-}
-
-/**
- * Clean up temp directories
- */
-function cleanupTemp() {
-  try {
-    if (fs.existsSync(TEMP_DIR)) {
-      removeDir(TEMP_DIR);
-    }
-  } catch (e) {
-    // Ignore cleanup errors
-  }
-}
-
-/**
- * Ensure a directory exists
- */
-function ensureDir(dirPath) {
-  if (!fs.existsSync(dirPath)) {
-    fs.mkdirSync(dirPath, { recursive: true });
-  }
-}
-
-/**
- * Read the lock file
- */
-function readLockFile() {
-  const { lockFile } = getPaths();
-  try {
-    if (fs.existsSync(lockFile)) {
-      return JSON.parse(fs.readFileSync(lockFile, 'utf8'));
-    }
-  } catch (e) {
-    // Ignore errors, return empty
-  }
-  return { version: 1, skills: {} };
-}
-
-/**
- * Write the lock file
- */
-function writeLockFile(lockData) {
-  const { lockFile } = getPaths();
-  ensureDir(path.dirname(lockFile));
-  fs.writeFileSync(lockFile, JSON.stringify(lockData, null, 2));
-}
-
-/**
- * Read a skill.yaml or skill.json from a directory
- * Prefers skill.yaml, falls back to skill.json for backwards compatibility
- */
-function readSkillManifest(skillPath) {
-  const yamlPath = path.join(skillPath, 'skill.yaml');
-  const jsonPath = path.join(skillPath, 'skill.json');
-
-  // Prefer YAML
-  if (fs.existsSync(yamlPath)) {
-    try {
-      const content = fs.readFileSync(yamlPath, 'utf8');
-      return yaml.load(content);
-    } catch (e) {
-      throw new Error(`Invalid skill.yaml: ${e.message}`);
-    }
-  }
-
-  // Fall back to JSON for backwards compatibility
-  if (fs.existsSync(jsonPath)) {
-    try {
-      return JSON.parse(fs.readFileSync(jsonPath, 'utf8'));
-    } catch (e) {
-      throw new Error(`Invalid skill.json: ${e.message}`);
-    }
-  }
-
-  throw new Error(`No skill.yaml or skill.json found in ${skillPath}`);
-}
-
-/**
- * Validate a skill manifest
- */
-function validateManifest(manifest) {
-  const required = ['name', 'version', 'entrypoint'];
-  const missing = required.filter((f) => !manifest[f]);
-
-  if (missing.length > 0) {
-    throw new Error(`skill.json missing required fields: ${missing.join(', ')}`);
-  }
-
-  // Validate name (alphanumeric, hyphens only)
-  if (!/^[a-z0-9-]+$/.test(manifest.name)) {
-    throw new Error(`Invalid skill name "${manifest.name}": must be lowercase alphanumeric with hyphens`);
-  }
-
-  // Validate version (semver-ish)
-  if (!/^\d+\.\d+\.\d+/.test(manifest.version)) {
-    throw new Error(`Invalid version "${manifest.version}": must be semver format (e.g., 1.0.0)`);
-  }
-
-  return true;
-}
-
-/**
- * Copy a directory recursively
- * Falls back to `cp -a` on iSH/Alpine where copyFileSync may fail with EPERM
- */
-function copyDir(src, dest) {
-  ensureDir(dest);
-
-  // Try native copy first, fall back to cp -a if EPERM
-  try {
-    copyDirNative(src, dest);
-  } catch (error) {
-    if (error.code === 'EPERM') {
-      // iSH workaround: use cp -a command
-      copyDirWithCp(src, dest);
-    } else {
-      throw error;
-    }
-  }
-}
-
-/**
- * Native Node.js directory copy
- */
-function copyDirNative(src, dest) {
-  ensureDir(dest);
-  const entries = fs.readdirSync(src, { withFileTypes: true });
-
-  for (const entry of entries) {
-    const srcPath = path.join(src, entry.name);
-    const destPath = path.join(dest, entry.name);
-
-    // Skip node_modules, .git, etc.
-    if (['node_modules', '.git', '.DS_Store'].includes(entry.name)) {
-      continue;
-    }
-
-    if (entry.isDirectory()) {
-      copyDirNative(srcPath, destPath);
-    } else {
-      fs.copyFileSync(srcPath, destPath);
-    }
-  }
-}
-
-/**
- * Copy directory using cp -a command (iSH workaround)
- * Excludes node_modules and .git
- */
-function copyDirWithCp(src, dest) {
-  ensureDir(dest);
-
-  // Get list of items to copy (excluding node_modules, .git, .DS_Store)
-  const entries = fs.readdirSync(src);
-  const itemsToCopy = entries.filter((name) =>
-    !['node_modules', '.git', '.DS_Store'].includes(name),
-  );
-
-  if (itemsToCopy.length === 0) {
-    return;
-  }
-
-  // Copy each item using cp -a
-  for (const item of itemsToCopy) {
-    const srcPath = path.join(src, item);
-    const destPath = path.join(dest, item);
-
-    try {
-      // Use cp -a for full copy (preserves attributes, handles all file types)
-      execSync(`cp -a "${srcPath}" "${destPath}"`, { stdio: 'pipe' });
-    } catch (error) {
-      throw new Error(`Failed to copy ${item}: ${error.message}`);
-    }
-  }
-}
-
-/**
- * Remove a directory recursively
- */
-function removeDir(dirPath) {
-  if (!fs.existsSync(dirPath)) return;
-
-  const entries = fs.readdirSync(dirPath, { withFileTypes: true });
-  for (const entry of entries) {
-    const fullPath = path.join(dirPath, entry.name);
-    if (entry.isDirectory()) {
-      removeDir(fullPath);
-    } else {
-      fs.unlinkSync(fullPath);
-    }
-  }
-  fs.rmdirSync(dirPath);
-}
-
-/**
- * Install a skill from a local directory, GitHub, or marketplace
- * @param {string} source - Local path, GitHub URL/shorthand, or skill name from marketplace
- * @param {Object} options - { force, verbose, branch }
- */
-async function installSkill(source, options = {}) {
-  const { force = false, verbose = false, branch = null } = options;
-
-  let absPath;
-  let sourceType = 'local';
-  let githubInfo = null;
-
-  // Check if it's a GitHub source
-  githubInfo = parseGitHubSource(source);
-
-  if (githubInfo) {
-    sourceType = 'github';
-    if (verbose) {
-      console.log(`Detected GitHub source: ${githubInfo.owner}/${githubInfo.repo}`);
-    }
-
-    // Clone from GitHub
-    absPath = cloneFromGitHub(githubInfo, { verbose, branch });
-  } else if (fs.existsSync(path.resolve(source))) {
-    // Local path exists
-    absPath = path.resolve(source);
-
-    if (!fs.statSync(absPath).isDirectory()) {
-      throw new Error(`Not a directory: ${absPath}`);
-    }
-  } else if (/^[a-z0-9-]+$/.test(source)) {
-    // Looks like a skill name - try marketplace lookup
-    sourceType = 'marketplace';
-    if (verbose) {
-      console.log(`Looking up "${source}" in marketplace...`);
-    }
-
-    // Import marketplace module
-    const marketplace = require('./marketplace');
-
-    try {
-      const skillInfo = await marketplace.lookupSkill(source, { verbose });
-
-      if (!skillInfo) {
-        throw new Error(
-          `Skill "${source}" not found in marketplace.\n` +
-          `  Try: pave search ${source}\n` +
-          `  Or install from GitHub: pave install owner/repo`,
-        );
-      }
-
-      if (verbose) {
-        console.log(`Found in marketplace: ${skillInfo.repository}`);
-      }
-
-      // Parse the repository as GitHub source
-      githubInfo = parseGitHubSource(skillInfo.repository);
-
-      if (!githubInfo) {
-        throw new Error(`Invalid repository in marketplace: ${skillInfo.repository}`);
-      }
-
-      sourceType = 'github';
-
-      // Clone from GitHub
-      absPath = cloneFromGitHub(githubInfo, { verbose, branch });
-    } catch (e) {
-      if (e.message.includes('not found in marketplace')) {
-        throw e;
-      }
-      throw new Error(`Failed to lookup in marketplace: ${e.message}`);
-    }
-  } else {
-    // Not a valid path, GitHub source, or skill name
-    throw new Error(
-      `Invalid source: "${source}"\n` +
-      `  Use one of:\n` +
-      `    pave install <skill-name>     (from marketplace)\n` +
-      `    pave install <owner/repo>     (from GitHub)\n` +
-      `    pave install <local-path>     (from local directory)`,
-    );
-  }
-
-  // Read and validate manifest
-  const manifest = readSkillManifest(absPath);
-  validateManifest(manifest);
-
-  const skillName = manifest.name;
-  const skillVersion = manifest.version;
-  const { skillsDir } = getPaths();
-  const destPath = path.join(skillsDir, skillName);
-
-  if (verbose) {
-    console.log(`Installing ${skillName}@${skillVersion}${sourceType === 'github' ? ` from ${githubInfo.owner}/${githubInfo.repo}` : ''}`);
-  }
-
-  // Check if already installed
-  const lockData = readLockFile();
-  const existing = lockData.skills[skillName];
-
-  if (existing && !force) {
-    // Cleanup temp if from GitHub
-    if (sourceType === 'github') {
-      cleanupTemp();
-    }
-    throw new Error(
-      `Skill "${skillName}" already installed (v${existing.version}). ` +
-      `Use --force to overwrite.`,
-    );
-  }
-
-  // Remove existing if force
-  if (existing && force) {
-    if (verbose) {
-      console.log(`Removing existing ${skillName}@${existing.version}`);
-    }
-    removeDir(destPath);
-  }
-
-  // Copy skill files
-  if (verbose) {
-    console.log(`Copying files to ${destPath}`);
-  }
-  copyDir(absPath, destPath);
-
-  // Determine source string for lock file
-  const sourceString = sourceType === 'github'
-    ? `github:${githubInfo.owner}/${githubInfo.repo}`
-    : absPath;
-
-  // Update lock file
-  lockData.skills[skillName] = {
-    version: skillVersion,
-    source: sourceString,
-    sourceType,
-    installedAt: new Date().toISOString(),
-    manifest: {
-      name: manifest.name,
-      version: manifest.version,
-      description: manifest.description || '',
-      entrypoint: manifest.entrypoint,
-      commands: manifest.commands || [],
-      pattern: manifest.pattern || 'sandbox',
-    },
-  };
-
-  // Add GitHub info if applicable
-  if (sourceType === 'github') {
-    lockData.skills[skillName].github = {
-      owner: githubInfo.owner,
-      repo: githubInfo.repo,
-      url: githubInfo.url,
-    };
-  }
-
-  writeLockFile(lockData);
-
-  // Cleanup temp directory if from GitHub
-  if (sourceType === 'github') {
-    cleanupTemp();
-  }
-
-  // Return installation info
-  return {
-    name: skillName,
-    version: skillVersion,
-    path: destPath,
-    source: sourceString,
-    sourceType,
-    commands: manifest.commands || [],
-    tokens: manifest.tokens || {},
-  };
-}
-
-/**
- * List installed skills
- */
-function listSkills(options = {}) {
-  const { json = false } = options;
-  const lockData = readLockFile();
-  const { skillsDir } = getPaths();
-
-  const skills = Object.entries(lockData.skills).map(([name, info]) => {
-    // Handle commands as either array or object format
-    let commandNames = [];
-    const commands = info.manifest?.commands;
-    if (Array.isArray(commands)) {
-      commandNames = commands.map((c) => c.name);
-    } else if (commands && typeof commands === 'object') {
-      // Object format: { "post": {...}, "get": {...} } -> ["post", "get"]
-      commandNames = Object.keys(commands);
-    }
-
-    return {
-      name,
-      version: info.version,
-      description: info.manifest?.description || '',
-      commands: commandNames,
-      installedAt: info.installedAt,
-      path: path.join(skillsDir, name),
-    };
-  });
-
-  if (json) {
-    return skills;
-  }
-
-  return skills;
-}
-
-/**
- * Remove an installed skill
- */
-function removeSkill(skillName, options = {}) {
-  const { verbose = false } = options;
-
-  const lockData = readLockFile();
-  const existing = lockData.skills[skillName];
-
-  if (!existing) {
-    throw new Error(`Skill "${skillName}" is not installed`);
-  }
-
-  const { skillsDir } = getPaths();
-  const skillPath = path.join(skillsDir, skillName);
-
-  if (verbose) {
-    console.log(`Removing ${skillName}@${existing.version} from ${skillPath}`);
-  }
-
-  // Remove the skill directory
-  removeDir(skillPath);
-
-  // Update lock file
-  delete lockData.skills[skillName];
-  writeLockFile(lockData);
-
-  return {
-    name: skillName,
-    version: existing.version,
-    removed: true,
-  };
-}
-
-/**
- * Get info about a skill (installed or from path)
- */
-function getSkillInfo(nameOrPath, options = {}) {
-  // Check if it's an installed skill name
-  const lockData = readLockFile();
-  const { skillsDir } = getPaths();
-
-  if (lockData.skills[nameOrPath]) {
-    const info = lockData.skills[nameOrPath];
-    const skillPath = path.join(skillsDir, nameOrPath);
-
-    // Read full manifest from installed location
-    let fullManifest = info.manifest;
-    try {
-      fullManifest = readSkillManifest(skillPath);
-    } catch (e) {
-      // Use cached manifest from lock file
-    }
-
-    return {
-      installed: true,
-      name: nameOrPath,
-      version: info.version,
-      path: skillPath,
-      source: info.source,
-      installedAt: info.installedAt,
-      manifest: fullManifest,
-    };
-  }
-
-  // Check if it's a path
-  const absPath = path.resolve(nameOrPath);
-  if (fs.existsSync(absPath) && fs.statSync(absPath).isDirectory()) {
-    try {
-      const manifest = readSkillManifest(absPath);
-      return {
-        installed: false,
-        name: manifest.name,
-        version: manifest.version,
-        path: absPath,
-        manifest,
-      };
-    } catch (e) {
-      throw new Error(`Not a valid skill: ${e.message}`);
-    }
-  }
-
-  throw new Error(`Skill "${nameOrPath}" not found (not installed and not a valid path)`);
-}
-
-/**
- * Get the script path and command for running a skill
- * Returns { scriptPath, skillArgs } for use with pave-run or sandbox
- */
-function getSkillCommand(skillName, commandArgs = []) {
-  const lockData = readLockFile();
-
-  if (!lockData.skills[skillName]) {
-    throw new Error(`Skill "${skillName}" is not installed. Install with: pave install <path>`);
-  }
-
-  const info = lockData.skills[skillName];
-  const { skillsDir } = getPaths();
-  const skillPath = path.join(skillsDir, skillName);
-
-  // Get entrypoint from manifest
-  let entrypoint = 'index.js';
-  try {
-    const manifest = readSkillManifest(skillPath);
-    entrypoint = manifest.entrypoint || 'index.js';
-  } catch (e) {
-    // Use default
-  }
-
-  const scriptPath = path.join(skillPath, entrypoint);
-
-  if (!fs.existsSync(scriptPath)) {
-    throw new Error(`Skill entrypoint not found: ${scriptPath}`);
-  }
-
-  return {
-    skillName,
-    version: info.version,
-    scriptPath,
-    skillPath,
-    skillArgs: commandArgs,
-  };
-}
-
-/**
- * Update an installed skill to the latest version
- * @param {string} skillName - Name of installed skill
- * @param {Object} options - { force, verbose, checkOnly }
- * @returns {Object} - Update result
- */
-async function updateSkill(skillName, options = {}) {
-  const { verbose = false, checkOnly = false } = options;
-
-  const lockData = readLockFile();
-  const existing = lockData.skills[skillName];
-
-  if (!existing) {
-    throw new Error(`Skill "${skillName}" is not installed`);
-  }
-
-  // Need GitHub source to update
-  if (existing.sourceType !== 'github' && !existing.github) {
-    throw new Error(
-      `Cannot update "${skillName}": installed from local path.\n` +
-      `  Source: ${existing.source}\n` +
-      `  Reinstall from GitHub to enable updates.`,
-    );
-  }
-
-  const githubInfo = existing.github || parseGitHubSource(existing.source);
-
-  if (!githubInfo) {
-    throw new Error(`Cannot determine GitHub source for "${skillName}"`);
-  }
-
-  if (verbose) {
-    console.log(`Checking ${githubInfo.owner}/${githubInfo.repo} for updates...`);
-  }
-
-  // Clone to temp to check version
-  let tempPath;
-  try {
-    tempPath = cloneFromGitHub(githubInfo, { verbose: false });
-  } catch (e) {
-    throw new Error(`Failed to fetch latest version: ${e.message}`);
-  }
-
-  // Read new manifest
-  let newManifest;
-  try {
-    newManifest = readSkillManifest(tempPath);
-  } catch (e) {
-    cleanupTemp();
-    throw new Error(`Failed to read updated manifest: ${e.message}`);
-  }
-
-  const currentVersion = existing.version;
-  const latestVersion = newManifest.version;
-
-  // Compare versions
-  const hasUpdate = latestVersion !== currentVersion;
-
-  if (checkOnly) {
-    cleanupTemp();
-    return {
-      name: skillName,
-      currentVersion,
-      latestVersion,
-      hasUpdate,
-      repository: `${githubInfo.owner}/${githubInfo.repo}`,
-    };
-  }
-
-  if (!hasUpdate) {
-    cleanupTemp();
-    if (verbose) {
-      console.log(`${skillName} is already at latest version (${currentVersion})`);
-    }
-    return {
-      name: skillName,
-      currentVersion,
-      latestVersion,
-      hasUpdate: false,
-      updated: false,
-    };
-  }
-
-  if (verbose) {
-    console.log(`Updating ${skillName}: ${currentVersion} � ${latestVersion}`);
-  }
-
-  // Remove old version
-  const { skillsDir } = getPaths();
-  const destPath = path.join(skillsDir, skillName);
-  removeDir(destPath);
-
-  // Copy new version
-  copyDir(tempPath, destPath);
-
-  // Update lock file
-  lockData.skills[skillName] = {
-    version: latestVersion,
-    source: `github:${githubInfo.owner}/${githubInfo.repo}`,
-    sourceType: 'github',
-    installedAt: new Date().toISOString(),
-    updatedAt: new Date().toISOString(),
-    previousVersion: currentVersion,
-    manifest: {
-      name: newManifest.name,
-      version: newManifest.version,
-      description: newManifest.description || '',
-      entrypoint: newManifest.entrypoint,
-      commands: newManifest.commands || [],
-      pattern: newManifest.pattern || 'sandbox',
-    },
-    github: {
-      owner: githubInfo.owner,
-      repo: githubInfo.repo,
-      url: githubInfo.url,
-    },
-  };
-
-  writeLockFile(lockData);
-  cleanupTemp();
-
-  return {
-    name: skillName,
-    currentVersion,
-    latestVersion,
-    hasUpdate: true,
-    updated: true,
-    path: destPath,
-  };
-}
-
-/**
- * Check for updates on all installed skills
- * @param {Object} options - { verbose }
- * @returns {Array} - Skills with updates available
- */
-async function checkAllUpdates(options = {}) {
-  const { verbose = false } = options;
-
-  const lockData = readLockFile();
-  const results = [];
-
-  for (const [name, info] of Object.entries(lockData.skills)) {
-    // Skip local installs
-    if (info.sourceType !== 'github' && !info.github) {
-      if (verbose) {
-        console.log(`Skipping ${name}: installed from local path`);
-      }
-      continue;
-    }
-
-    try {
-      const result = await updateSkill(name, { ...options, checkOnly: true });
-      results.push(result);
-    } catch (e) {
-      if (verbose) {
-        console.log(`Error checking ${name}: ${e.message}`);
-      }
-      results.push({
-        name,
-        error: e.message,
-      });
-    }
-  }
-
-  return results;
-}
-
-// Export functions
-module.exports = {
-  installSkill,
-  listSkills,
-  removeSkill,
-  getSkillInfo,
-  getSkillCommand,
-  updateSkill,
-  checkAllUpdates,
-  readSkillManifest,
-  validateManifest,
-  parseGitHubSource,
-  cleanupTemp,
-  // Config path management
-  setPaveHome,
-  getPaveHome,
-  getPaths,
-  // Deprecated: use getPaths() instead. Kept for backward compatibility.
-  get SKILLS_DIR() { return getPaths().skillsDir; },
-  get LOCK_FILE() { return getPaths().lockFile; },
-};