@cnrai/pave 0.3.35 → 0.3.51

package/lib/marketplace.js

@@ -1,866 +0,0 @@
-#!/usr/bin/env node
-/**
- * OpenPave Skill Marketplace
- * Fetch, search, and publish skills to the marketplace registry
- *
- * Node 16 compatible - runs on iSH iOS
- */
-
-const https = require('https');
-const http = require('http');
-const fs = require('fs');
-const path = require('path');
-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');
-
-// 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 cache paths based on current PAVE_HOME
- */
-function getCachePaths() {
-  const cacheDir = path.join(PAVE_HOME, 'cache');
-  return {
-    cacheDir,
-    cacheFile: path.join(cacheDir, 'registry.yaml'),
-    cacheMetaFile: path.join(cacheDir, 'registry.meta.json'),
-  };
-}
-
-const _HOME_DIR = DEFAULT_HOME_DIR;
-
-// Default registry URL
-const DEFAULT_REGISTRY_URL = 'https://raw.githubusercontent.com/cnrai/openpave-marketplace/main/registry.yaml';
-
-// Cache TTL in milliseconds (1 hour default)
-const _DEFAULT_CACHE_TTL = parseInt(process.env.PAVE_CACHE_TTL || '3600', 10) * 1000;
-
-/**
- * Ensure a directory exists
- */
-function ensureDir(dirPath) {
-  if (!fs.existsSync(dirPath)) {
-    fs.mkdirSync(dirPath, { recursive: true });
-  }
-}
-
-/**
- * Get the registry URL from environment or default
- */
-function getRegistryUrl() {
-  return process.env.PAVE_REGISTRY_URL || DEFAULT_REGISTRY_URL;
-}
-
-/**
- * Check if we should use a local registry file
- */
-function getLocalRegistryFile() {
-  return process.env.PAVE_REGISTRY_FILE || null;
-}
-
-/**
- * Read cache metadata
- */
-function readCacheMeta() {
-  const { cacheMetaFile } = getCachePaths();
-  try {
-    if (fs.existsSync(cacheMetaFile)) {
-      return JSON.parse(fs.readFileSync(cacheMetaFile, 'utf8'));
-    }
-  } catch (e) {
-    // Ignore errors
-  }
-  return null;
-}
-
-/**
- * Write cache metadata
- */
-function writeCacheMeta(meta) {
-  const { cacheDir, cacheMetaFile } = getCachePaths();
-  ensureDir(cacheDir);
-  fs.writeFileSync(cacheMetaFile, JSON.stringify(meta, null, 2));
-}
-
-/**
- * Check if cache is still valid
- */
-function isCacheValid() {
-  const meta = readCacheMeta();
-  if (!meta || !meta.timestamp) return false;
-
-  const age = Date.now() - meta.timestamp;
-  const ttl = parseInt(process.env.PAVE_CACHE_TTL || '3600', 10) * 1000;
-  const { cacheFile } = getCachePaths();
-
-  return age < ttl && fs.existsSync(cacheFile);
-}
-
-/**
- * Read cached registry
- */
-function readCachedRegistry() {
-  const { cacheFile } = getCachePaths();
-  try {
-    if (fs.existsSync(cacheFile)) {
-      const content = fs.readFileSync(cacheFile, 'utf8');
-      return yaml.load(content);
-    }
-  } catch (e) {
-    // Ignore errors
-  }
-  return null;
-}
-
-/**
- * Write registry to cache
- */
-function writeRegistryCache(content) {
-  const { cacheDir, cacheFile } = getCachePaths();
-  ensureDir(cacheDir);
-  fs.writeFileSync(cacheFile, content);
-  writeCacheMeta({
-    timestamp: Date.now(),
-    url: getRegistryUrl(),
-  });
-}
-
-/**
- * Fetch URL content (Node 16 compatible, no fetch API)
- * @param {string} url - URL to fetch
- * @returns {Promise<string>} - Response body
- */
-function fetchUrl(url) {
-  return new Promise((resolve, reject) => {
-    const client = url.startsWith('https') ? https : http;
-
-    const request = client.get(url, {
-      headers: {
-        'User-Agent': 'pave-cli/1.0',
-      },
-      timeout: 30000,
-    }, (response) => {
-      // Handle redirects
-      if (response.statusCode >= 300 && response.statusCode < 400 && response.headers.location) {
-        fetchUrl(response.headers.location).then(resolve).catch(reject);
-        return;
-      }
-
-      if (response.statusCode !== 200) {
-        reject(new Error(`HTTP ${response.statusCode}: ${response.statusMessage}`));
-        return;
-      }
-
-      let data = '';
-      response.on('data', (chunk) => { data += chunk; });
-      response.on('end', () => resolve(data));
-      response.on('error', reject);
-    });
-
-    request.on('error', reject);
-    request.on('timeout', () => {
-      request.destroy();
-      reject(new Error('Request timeout'));
-    });
-  });
-}
-
-/**
- * Fetch the marketplace registry
- * Uses cache if available and not expired
- *
- * @param {Object} options - { force: boolean, verbose: boolean }
- * @returns {Promise<Object>} - Registry object
- */
-async function fetchRegistry(options = {}) {
-  const { force = false, verbose = false } = options;
-
-  // Check for local file override
-  const localFile = getLocalRegistryFile();
-  if (localFile) {
-    if (verbose) {
-      console.log(`Using local registry file: ${localFile}`);
-    }
-    try {
-      const content = fs.readFileSync(localFile, 'utf8');
-      return yaml.load(content);
-    } catch (e) {
-      throw new Error(`Failed to read local registry: ${e.message}`);
-    }
-  }
-
-  // Check cache unless force refresh
-  if (!force && isCacheValid()) {
-    if (verbose) {
-      console.log('Using cached registry');
-    }
-    const cached = readCachedRegistry();
-    if (cached) {
-      return cached;
-    }
-  }
-
-  // Fetch from remote
-  const url = getRegistryUrl();
-  if (verbose) {
-    console.log(`Fetching registry from ${url}`);
-  }
-
-  try {
-    const content = await fetchUrl(url);
-
-    // Parse and validate
-    const registry = yaml.load(content);
-    if (!registry || !registry.skills) {
-      throw new Error('Invalid registry format: missing skills');
-    }
-
-    // Cache the result
-    writeRegistryCache(content);
-
-    if (verbose) {
-      const skillCount = Object.keys(registry.skills).length;
-      console.log(`Registry loaded: ${skillCount} skills available`);
-    }
-
-    return registry;
-  } catch (e) {
-    // Try to use cache as fallback
-    const cached = readCachedRegistry();
-    if (cached) {
-      if (verbose) {
-        console.log(`Network error, using cached registry: ${e.message}`);
-      }
-      return cached;
-    }
-    throw new Error(`Failed to fetch registry: ${e.message}`);
-  }
-}
-
-/**
- * Search skills in the registry
- *
- * @param {string} query - Search query (name, description, keywords)
- * @param {Object} options - { all: boolean, category: string, verbose: boolean }
- * @returns {Promise<Array>} - Matching skills
- */
-async function searchSkills(query, options = {}) {
-  const { all = false, category = null, verbose = false } = options;
-
-  const registry = await fetchRegistry({ verbose });
-  const skills = Object.values(registry.skills || {});
-
-  // Return all skills if --all flag
-  if (all || !query) {
-    let results = skills;
-
-    // Filter by category if specified
-    if (category) {
-      results = results.filter((s) => s.category === category);
-    }
-
-    return results.sort((a, b) => a.name.localeCompare(b.name));
-  }
-
-  // Search by query
-  const queryLower = query.toLowerCase();
-
-  const results = skills.filter((skill) => {
-    // Match name
-    if (skill.name.toLowerCase().includes(queryLower)) {
-      return true;
-    }
-
-    // Match description
-    if (skill.description && skill.description.toLowerCase().includes(queryLower)) {
-      return true;
-    }
-
-    // Match keywords
-    if (skill.keywords && Array.isArray(skill.keywords)) {
-      for (const keyword of skill.keywords) {
-        if (keyword.toLowerCase().includes(queryLower)) {
-          return true;
-        }
-      }
-    }
-
-    // Match category
-    if (skill.category && skill.category.toLowerCase().includes(queryLower)) {
-      return true;
-    }
-
-    // Match author
-    if (skill.author && skill.author.toLowerCase().includes(queryLower)) {
-      return true;
-    }
-
-    return false;
-  });
-
-  // Filter by category if specified
-  if (category) {
-    return results.filter((s) => s.category === category);
-  }
-
-  // Sort by relevance (exact name match first, then alphabetical)
-  return results.sort((a, b) => {
-    const aExact = a.name.toLowerCase() === queryLower;
-    const bExact = b.name.toLowerCase() === queryLower;
-    if (aExact && !bExact) return -1;
-    if (!aExact && bExact) return 1;
-    return a.name.localeCompare(b.name);
-  });
-}
-
-/**
- * Lookup a specific skill in the registry
- *
- * @param {string} name - Skill name
- * @param {Object} options - { verbose: boolean }
- * @returns {Promise<Object|null>} - Skill metadata or null
- */
-async function lookupSkill(name, options = {}) {
-  const { verbose = false } = options;
-
-  const registry = await fetchRegistry({ verbose });
-
-  if (registry.skills && registry.skills[name]) {
-    return registry.skills[name];
-  }
-
-  return null;
-}
-
-/**
- * Validate a skill directory for publishing
- *
- * @param {string} skillPath - Path to skill directory
- * @returns {Object} - { valid: boolean, errors: string[], manifest: Object }
- */
-function validateSkillForPublish(skillPath) {
-  const errors = [];
-  let manifest = null;
-
-  // Check path exists
-  if (!fs.existsSync(skillPath)) {
-    errors.push(`Path not found: ${skillPath}`);
-    return { valid: false, errors, manifest: null };
-  }
-
-  // Check skill.yaml exists
-  const yamlPath = path.join(skillPath, 'skill.yaml');
-  const jsonPath = path.join(skillPath, 'skill.json');
-
-  if (fs.existsSync(yamlPath)) {
-    try {
-      manifest = yaml.load(fs.readFileSync(yamlPath, 'utf8'));
-    } catch (e) {
-      errors.push(`Invalid skill.yaml: ${e.message}`);
-    }
-  } else if (fs.existsSync(jsonPath)) {
-    try {
-      manifest = JSON.parse(fs.readFileSync(jsonPath, 'utf8'));
-    } catch (e) {
-      errors.push(`Invalid skill.json: ${e.message}`);
-    }
-  } else {
-    errors.push('Missing skill.yaml or skill.json');
-  }
-
-  if (!manifest) {
-    return { valid: false, errors, manifest: null };
-  }
-
-  // Validate required fields
-  const required = ['name', 'version', 'description', 'entrypoint'];
-  for (const field of required) {
-    if (!manifest[field]) {
-      errors.push(`Missing required field: ${field}`);
-    }
-  }
-
-  // Validate name format
-  if (manifest.name && !/^[a-z0-9-]+$/.test(manifest.name)) {
-    errors.push(`Invalid skill name "${manifest.name}": must be lowercase alphanumeric with hyphens`);
-  }
-
-  // Validate version format
-  if (manifest.version && !/^\d+\.\d+\.\d+/.test(manifest.version)) {
-    errors.push(`Invalid version "${manifest.version}": must be semver format`);
-  }
-
-  // Check entrypoint exists
-  if (manifest.entrypoint) {
-    const entrypointPath = path.join(skillPath, manifest.entrypoint);
-    if (!fs.existsSync(entrypointPath)) {
-      errors.push(`Entrypoint not found: ${manifest.entrypoint}`);
-    }
-  }
-
-  // Check for README
-  const readmePath = path.join(skillPath, 'README.md');
-  if (!fs.existsSync(readmePath)) {
-    errors.push('Missing README.md (recommended for publishing)');
-  }
-
-  // Check for LICENSE
-  const licensePath = path.join(skillPath, 'LICENSE');
-  if (!fs.existsSync(licensePath)) {
-    errors.push('Missing LICENSE file (recommended for publishing)');
-  }
-
-  // Validate repository field
-  if (!manifest.repository) {
-    errors.push('Missing repository field (required for publishing)');
-  } else if (!/^[a-zA-Z0-9_-]+\/[a-zA-Z0-9_-]+$/.test(manifest.repository)) {
-    errors.push(`Invalid repository format "${manifest.repository}": should be owner/repo`);
-  }
-
-  // Check for category
-  const validCategories = ['communication', 'storage', 'search', 'productivity', 'development', 'other'];
-  if (!manifest.category) {
-    errors.push('Missing category field');
-  } else if (!validCategories.includes(manifest.category)) {
-    errors.push(`Invalid category "${manifest.category}": must be one of ${validCategories.join(', ')}`);
-  }
-
-  return {
-    valid: errors.length === 0,
-    errors,
-    manifest,
-  };
-}
-
-/**
- * Generate registry entry from skill manifest
- *
- * @param {Object} manifest - Skill manifest
- * @returns {Object} - Registry entry
- */
-function generateRegistryEntry(manifest) {
-  return {
-    name: manifest.name,
-    version: manifest.version,
-    description: manifest.description,
-    author: manifest.author?.name || manifest.repository?.split('/')[0] || 'unknown',
-    repository: manifest.repository,
-    category: manifest.category || 'other',
-    icon: manifest.icon || null,
-    keywords: manifest.keywords || [],
-    published: new Date(), // Use Date object directly for unquoted YAML output
-  };
-}
-
-/**
- * Prepare a skill for publishing
- * Returns the registry entry YAML that would be added
- *
- * @param {string} skillPath - Path to skill directory
- * @param {Object} options - { verbose: boolean }
- * @returns {Object} - { valid: boolean, errors: string[], entry: Object, yaml: string }
- */
-function prepareForPublish(skillPath, options = {}) {
-  const { _verbose = false } = options;
-
-  const absPath = path.resolve(skillPath);
-  const validation = validateSkillForPublish(absPath);
-
-  if (!validation.valid) {
-    return {
-      valid: false,
-      errors: validation.errors,
-      entry: null,
-      yaml: null,
-    };
-  }
-
-  const entry = generateRegistryEntry(validation.manifest);
-
-  // Generate YAML snippet for the registry
-  // Note: Don't use quotingType to avoid quoting timestamps
-  const yamlEntry = yaml.dump({ [entry.name]: entry }, {
-    indent: 2,
-    lineWidth: 120,
-    forceQuotes: false,
-  });
-
-  return {
-    valid: true,
-    errors: [],
-    entry,
-    yaml: yamlEntry,
-    manifest: validation.manifest,
-  };
-}
-
-/**
- * Get instructions for manual publishing
- *
- * @param {Object} publishInfo - Result from prepareForPublish
- * @returns {string} - Instructions text
- */
-function getPublishInstructions(publishInfo) {
-  if (!publishInfo.valid) {
-    return `Cannot publish: fix the following errors first:\n${publishInfo.errors.map((e) => `  - ${e}`).join('\n')}`;
-  }
-
-  const entry = publishInfo.entry;
-
-  return `
-To publish "${entry.name}" to the OpenPave Marketplace:
-
-1. Ensure your repository is public: https://github.com/${entry.repository}
-
-2. Fork the marketplace repo:
-   https://github.com/cnrai/openpave-marketplace
-
-3. Add your skill to registry.yaml under the "skills:" section:
-
-${publishInfo.yaml}
-
-4. Create a pull request with title:
-   "Add skill: ${entry.name}"
-
-5. Wait for review and approval from maintainers.
-
-Alternatively, run "pave publish --create-pr" to automatically create the PR (requires gh CLI).
-`.trim();
-}
-
-/**
- * Clear the registry cache
- */
-function clearCache() {
-  const { cacheFile, cacheMetaFile } = getCachePaths();
-  try {
-    if (fs.existsSync(cacheFile)) {
-      fs.unlinkSync(cacheFile);
-    }
-    if (fs.existsSync(cacheMetaFile)) {
-      fs.unlinkSync(cacheMetaFile);
-    }
-    return true;
-  } catch (e) {
-    return false;
-  }
-}
-
-/**
- * Get cache info
- */
-function getCacheInfo() {
-  const meta = readCacheMeta();
-  if (!meta) {
-    return { cached: false };
-  }
-
-  const { cacheFile } = getCachePaths();
-  return {
-    cached: true,
-    timestamp: meta.timestamp,
-    age: Date.now() - meta.timestamp,
-    url: meta.url,
-    valid: isCacheValid(),
-    file: cacheFile,
-  };
-}
-
-/**
- * Create a PR to add or upgrade a skill in the marketplace registry
- * Uses gh CLI to fork, create branch, commit, and open PR
- *
- * @param {Object} publishInfo - Result from prepareForPublish
- * @param {Object} options - { verbose: boolean, upgrade: boolean }
- * @returns {Promise<Object>} - { success: boolean, prUrl: string, error: string }
- */
-async function createPublishPR(publishInfo, options = {}) {
-  const { verbose = false, upgrade = false } = options;
-  const { execSync } = require('child_process');
-
-  if (!publishInfo.valid) {
-    return {
-      success: false,
-      error: `Cannot publish: ${publishInfo.errors.join(', ')}`,
-    };
-  }
-
-  const entry = publishInfo.entry;
-  const skillName = entry.name;
-  const branchName = upgrade ? `upgrade-skill-${skillName}` : `add-skill-${skillName}`;
-
-  // Check if gh CLI is available
-  try {
-    execSync('gh --version', { stdio: 'pipe' });
-  } catch (e) {
-    return {
-      success: false,
-      error: 'GitHub CLI (gh) is not installed. Install from https://cli.github.com/',
-    };
-  }
-
-  // Check if gh is authenticated
-  try {
-    execSync('gh auth status', { stdio: 'pipe' });
-  } catch (e) {
-    return {
-      success: false,
-      error: 'GitHub CLI is not authenticated. Run: gh auth login',
-    };
-  }
-
-  // Check if skill repo exists and is accessible
-  try {
-    if (verbose) console.log(`Checking repository: ${entry.repository}`);
-    execSync(`gh repo view ${entry.repository}`, { stdio: 'pipe' });
-  } catch (e) {
-    return {
-      success: false,
-      error: `Repository not found or not accessible: ${entry.repository}\nMake sure the repo exists and is public.`,
-    };
-  }
-
-  const tempDir = path.join(require('os').tmpdir(), `pave-publish-${Date.now()}`);
-
-  try {
-    // Clone the marketplace repo
-    if (verbose) console.log('Cloning marketplace repository...');
-    execSync(`git clone --depth 1 https://github.com/cnrai/openpave-marketplace.git "${tempDir}"`, {
-      stdio: verbose ? 'inherit' : 'pipe',
-    });
-
-    // Read current registry
-    const registryPath = path.join(tempDir, 'registry.yaml');
-    const registryContent = fs.readFileSync(registryPath, 'utf8');
-    const registry = yaml.load(registryContent);
-
-    // Check if skill already exists
-    const skillExists = registry.skills && registry.skills[skillName];
-
-    if (skillExists && !upgrade) {
-      // Clean up
-      fs.rmSync(tempDir, { recursive: true, force: true });
-      return {
-        success: false,
-        error: `Skill "${skillName}" already exists in the marketplace registry. Use --upgrade to update it.`,
-      };
-    }
-
-    if (!skillExists && upgrade) {
-      // Clean up
-      fs.rmSync(tempDir, { recursive: true, force: true });
-      return {
-        success: false,
-        error: `Skill "${skillName}" does not exist in the marketplace registry. Remove --upgrade to add it as new.`,
-      };
-    }
-
-    // Store old version for PR description (if upgrading)
-    const oldVersion = skillExists ? registry.skills[skillName].version : null;
-
-    // Add or update the skill entry
-    if (!registry.skills) {
-      registry.skills = {};
-    }
-    registry.skills[skillName] = entry;
-    registry.updated = new Date(); // Use Date object directly for unquoted YAML output
-
-    // Write updated registry
-    // Note: Don't use quotingType to avoid quoting timestamps
-    const updatedYaml = yaml.dump(registry, {
-      indent: 2,
-      lineWidth: 120,
-      sortKeys: false,
-      forceQuotes: false,
-    });
-    fs.writeFileSync(registryPath, updatedYaml);
-
-    // Create branch and commit
-    if (verbose) console.log(`Creating branch: ${branchName}`);
-    execSync(`git checkout -b ${branchName}`, {
-      cwd: tempDir,
-      stdio: verbose ? 'inherit' : 'pipe',
-    });
-
-    execSync(`git add registry.yaml`, {
-      cwd: tempDir,
-      stdio: verbose ? 'inherit' : 'pipe',
-    });
-
-    const commitMsg = upgrade
-      ? `Upgrade skill: ${skillName} (${oldVersion} � ${entry.version})`
-      : `Add skill: ${skillName}`;
-    execSync(`git commit -m "${commitMsg}"`, {
-      cwd: tempDir,
-      stdio: verbose ? 'inherit' : 'pipe',
-    });
-
-    // Fork the repo (if not already forked) and push
-    if (verbose) console.log('Forking marketplace repo (if needed)...');
-    try {
-      execSync('gh repo fork cnrai/openpave-marketplace --clone=false', {
-        cwd: tempDir,
-        stdio: verbose ? 'inherit' : 'pipe',
-      });
-    } catch (e) {
-      // Fork might already exist, continue
-      if (verbose) console.log('Fork may already exist, continuing...');
-    }
-
-    // Get current user
-    const ghUser = execSync('gh api user -q .login', { encoding: 'utf8' }).trim();
-    if (verbose) console.log(`GitHub user: ${ghUser}`);
-
-    // Add fork as remote and push
-    try {
-      execSync(`git remote add fork https://github.com/${ghUser}/openpave-marketplace.git`, {
-        cwd: tempDir,
-        stdio: 'pipe',
-      });
-    } catch (e) {
-      // Remote might already exist
-      execSync(`git remote set-url fork https://github.com/${ghUser}/openpave-marketplace.git`, {
-        cwd: tempDir,
-        stdio: 'pipe',
-      });
-    }
-
-    if (verbose) console.log('Pushing to fork...');
-    execSync(`git push -u fork ${branchName} --force`, {
-      cwd: tempDir,
-      stdio: verbose ? 'inherit' : 'pipe',
-    });
-
-    // Create PR
-    if (verbose) console.log('Creating pull request...');
-
-    const prTitle = upgrade
-      ? `Upgrade skill: ${skillName} (${oldVersion} � ${entry.version})`
-      : `Add skill: ${skillName}`;
-
-    const prBody = upgrade ? `## Upgrade Skill: ${skillName}
-
-**Version Update:** ${oldVersion} � ${entry.version}
-
-**Skill Details:**
-- **Name:** ${entry.name}
-- **Version:** ${entry.version}
-- **Description:** ${entry.description}
-- **Category:** ${entry.category}
-- **Repository:** [${entry.repository}](https://github.com/${entry.repository})
-
-**Update command:**
-\`\`\`bash
-pave update ${skillName}
-\`\`\`
-
----
-*This PR was automatically generated by \`pave publish --create-pr --upgrade\`*
-` : `## Add Skill: ${skillName}
-
-**Skill Details:**
-- **Name:** ${entry.name}
-- **Version:** ${entry.version}
-- **Description:** ${entry.description}
-- **Category:** ${entry.category}
-- **Repository:** [${entry.repository}](https://github.com/${entry.repository})
-
-**Install command:**
-\`\`\`bash
-pave install ${skillName}
-\`\`\`
-
----
-*This PR was automatically generated by \`pave publish --create-pr\`*
-`;
-
-    // Write PR body to temp file to handle special characters
-    const prBodyFile = path.join(tempDir, 'pr-body.md');
-    fs.writeFileSync(prBodyFile, prBody);
-
-    const prResult = execSync(
-      `gh pr create --repo cnrai/openpave-marketplace --title "${prTitle}" --body-file "${prBodyFile}" --head ${ghUser}:${branchName}`,
-      {
-        cwd: tempDir,
-        encoding: 'utf8',
-        stdio: ['pipe', 'pipe', 'pipe'],
-      },
-    ).trim();
-
-    // Clean up temp directory
-    fs.rmSync(tempDir, { recursive: true, force: true });
-
-    return {
-      success: true,
-      prUrl: prResult,
-      skillName,
-      repository: entry.repository,
-    };
-  } catch (e) {
-    // Clean up on error
-    try {
-      fs.rmSync(tempDir, { recursive: true, force: true });
-    } catch (cleanupErr) {
-      // Ignore cleanup errors
-    }
-
-    return {
-      success: false,
-      error: e.message || String(e),
-    };
-  }
-}
-
-// Export functions
-module.exports = {
-  fetchRegistry,
-  searchSkills,
-  lookupSkill,
-  validateSkillForPublish,
-  prepareForPublish,
-  getPublishInstructions,
-  generateRegistryEntry,
-  createPublishPR,
-  clearCache,
-  getCacheInfo,
-  getRegistryUrl,
-  // Config path management
-  setPaveHome,
-  getPaveHome,
-  getCachePaths,
-  // Constants
-  DEFAULT_REGISTRY_URL,
-  // Deprecated: use getCachePaths() instead. Kept for backward compatibility.
-  get CACHE_DIR() { return getCachePaths().cacheDir; },
-  get CACHE_FILE() { return getCachePaths().cacheFile; },
-};