myskillshub 1.0.1

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "myskillshub",
+  "version": "1.0.1",
+  "description": "CLI tool for SkillHub skill management",
+  "main": "src/index.js",
+  "bin": {
+    "myskillshub": "./src/index.js"
+  },
+  "scripts": {
+    "test": "jest",
+    "lint": "eslint src/**/*.js",
+    "start": "node src/index.js"
+  },
+  "keywords": [
+    "cli",
+    "skill",
+    "skillshub"
+  ],
+  "author": "SkillHub Team",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "commander": "^11.1.0",
+    "axios": "^1.6.2",
+    "archiver": "^6.0.1",
+    "form-data": "^4.0.0",
+    "dotenv": "^16.3.1",
+    "chalk": "^4.1.2",
+    "ora": "^6.3.1"
+  },
+  "devDependencies": {
+    "jest": "^29.6.0",
+    "eslint": "^8.45.0"
+  }
+}

package/src/commands/info.js

@@ -0,0 +1,219 @@
+const { Command } = require('commander');
+const chalk = require('chalk');
+const axios = require('axios');
+const oraModule = require('ora');
+const ora = oraModule.default || oraModule;
+const fs = require('fs').promises;
+const path = require('path');
+
+const program = new Command();
+const TARGET_DIRS = {
+  claude: '.claude/skills',
+  codex: '.agents/skills',
+  cursor: '.cursor/skills',
+};
+
+program
+  .name('info')
+  .description('Show remote and local version information for a skill')
+  .argument('<skill-slug>', 'Skill slug')
+  .option('--verbose', 'Verbose output')
+  .option('-a, --api-url <url>', 'SkillHub API URL', 'http://localhost:3000')
+  .option('-t, --target <target>', 'Check local target: claude|codex|cursor|all', 'all')
+  .action(async (skillSlug, options) => {
+    const spinner = ora('Fetching skill info...').start();
+
+    try {
+      const skill = await getSkillInfo(skillSlug, options.apiUrl);
+      const localInfo = await getLocalInfo(skillSlug, options.target);
+      spinner.succeed(chalk.green('Skill info loaded'));
+
+      displaySkillInfo(skill, localInfo);
+    } catch (error) {
+      spinner.fail(chalk.red(`Failed to get skill info: ${error.message}`));
+      if (options.verbose) {
+        console.error(error);
+      }
+      process.exit(1);
+    }
+  });
+
+async function getSkillInfo(skillSlug, apiUrl) {
+  const response = await axios.get(`${apiUrl}/api/skills/${skillSlug}`);
+  if (!response.data?.success || !response.data?.data?.skill) {
+    throw new Error('Invalid skill info response');
+  }
+  return response.data.data.skill;
+}
+
+function resolveTargets(targetInput) {
+  const target = String(targetInput || 'all').trim().toLowerCase();
+  if (target === 'all') {
+    return Object.keys(TARGET_DIRS);
+  }
+  if (!TARGET_DIRS[target]) {
+    throw new Error(`Invalid target "${target}". Use one of: claude, codex, cursor, all`);
+  }
+  return [target];
+}
+
+async function getLocalInfo(skillSlug, targetInput) {
+  const targets = resolveTargets(targetInput);
+  const result = [];
+
+  for (const target of targets) {
+    const baseDir = path.join(process.cwd(), TARGET_DIRS[target], skillSlug);
+    const metadataPath = path.join(baseDir, '.myskillshub-install.json');
+    const canonicalSkillPath = path.join(baseDir, 'SKILL.md');
+
+    const metadata = await readInstallMetadata(metadataPath);
+    let resolvedSkillPath = canonicalSkillPath;
+    let resolvedVersion = metadata?.version || 'unknown';
+
+    if (!(await pathExists(resolvedSkillPath))) {
+      resolvedSkillPath = await findFirstSkillFile(baseDir);
+    }
+
+    if (resolvedSkillPath) {
+      const content = await fs.readFile(resolvedSkillPath, 'utf8');
+      const parsedVersion = extractVersionFromSkillContent(content);
+      if (!resolvedVersion || resolvedVersion === 'unknown') {
+        resolvedVersion = parsedVersion;
+      }
+
+      result.push({
+        target,
+        installed: true,
+        path: resolvedSkillPath,
+        version: resolvedVersion || parsedVersion || 'unknown',
+      });
+      continue;
+    }
+
+    result.push({
+      target,
+      installed: false,
+      path: baseDir,
+      version: '-',
+    });
+  }
+
+  return result;
+}
+
+async function readInstallMetadata(metadataPath) {
+  try {
+    const content = await fs.readFile(metadataPath, 'utf8');
+    const parsed = JSON.parse(content);
+    return typeof parsed === 'object' && parsed ? parsed : null;
+  } catch (error) {
+    return null;
+  }
+}
+
+async function pathExists(targetPath) {
+  try {
+    await fs.access(targetPath);
+    return true;
+  } catch (error) {
+    return false;
+  }
+}
+
+async function findFirstSkillFile(baseDir, depth = 0, maxDepth = 8) {
+  if (depth > maxDepth || !(await pathExists(baseDir))) {
+    return null;
+  }
+
+  const entries = await fs.readdir(baseDir, { withFileTypes: true });
+  const files = [];
+  const dirs = [];
+
+  for (const entry of entries) {
+    if (entry.name.startsWith('.')) {
+      continue;
+    }
+    if (entry.isFile() && entry.name.toUpperCase() === 'SKILL.MD') {
+      files.push(path.join(baseDir, entry.name));
+      continue;
+    }
+    if (entry.isDirectory()) {
+      dirs.push(path.join(baseDir, entry.name));
+    }
+  }
+
+  if (files.length > 0) {
+    files.sort((a, b) => a.length - b.length);
+    return files[0];
+  }
+
+  dirs.sort((a, b) => a.length - b.length);
+  for (const dirPath of dirs) {
+    const match = await findFirstSkillFile(dirPath, depth + 1, maxDepth);
+    if (match) {
+      return match;
+    }
+  }
+
+  return null;
+}
+
+function extractVersionFromSkillContent(content) {
+  if (!content.startsWith('---')) {
+    return 'unknown';
+  }
+  const end = content.indexOf('---', 3);
+  if (end < 0) {
+    return 'unknown';
+  }
+  const frontmatter = content.slice(3, end);
+  const lines = frontmatter.split('\n');
+  for (const rawLine of lines) {
+    const line = rawLine.trim();
+    const match = line.match(/^version\s*:\s*(.+)$/i);
+    if (!match) {
+      continue;
+    }
+    return String(match[1]).trim().replace(/^['"]|['"]$/g, '');
+  }
+  return 'unknown';
+}
+
+function displaySkillInfo(skill, localInfo) {
+  const versions = Array.isArray(skill.versions) ? skill.versions.map((item) => item.version).filter(Boolean) : [];
+  const latestVersion = skill.version || versions[0] || '-';
+  const installedItems = localInfo.filter((item) => item.installed);
+  const installedVersions = [...new Set(
+    installedItems
+      .map((item) => item.version)
+      .filter((version) => version && version !== '-' && version !== 'unknown')
+  )];
+  const installedSummary = installedVersions.length === 0
+    ? 'not installed'
+    : installedVersions.join(', ');
+  const hasUpdate = installedVersions.some((version) => version !== latestVersion);
+
+  console.log(chalk.bold('\n' + '='.repeat(60)));
+  console.log(chalk.bold.cyan('Skill Info'));
+  console.log(chalk.bold('='.repeat(60)));
+  console.log(chalk.white('Name:'), chalk.green(skill.name || '-'));
+  console.log(chalk.white('Slug:'), chalk.green(skill.slug || '-'));
+  console.log(chalk.white('Remote Latest:'), chalk.green(latestVersion));
+  console.log(chalk.white('Installed:'), installedVersions.length > 0 ? chalk.cyan(installedSummary) : chalk.gray(installedSummary));
+  if (installedVersions.length > 0) {
+    console.log(chalk.white('Update:'), hasUpdate ? chalk.yellow('available') : chalk.green('up-to-date'));
+  }
+  console.log(chalk.white('Versions:'), chalk.yellow(versions.length > 0 ? versions.join(', ') : latestVersion));
+
+  console.log(chalk.bold('\nLocal Install'));
+  localInfo.forEach((item) => {
+    if (!item.installed) {
+      console.log(chalk.gray(`  [${item.target}] not installed (checked: ${item.path})`));
+      return;
+    }
+    console.log(chalk.green(`  [${item.target}] ${item.version} (${item.path})`));
+  });
+  console.log(chalk.bold('='.repeat(60)));
+}
+
+module.exports = program;

package/src/commands/install.js

@@ -0,0 +1,264 @@
+const { Command } = require('commander');
+const chalk = require('chalk');
+const axios = require('axios');
+const oraModule = require('ora');
+const ora = oraModule.default || oraModule;
+const fs = require('fs').promises;
+const path = require('path');
+
+const program = new Command();
+const TARGET_DIRS = {
+  claude: '.claude/skills',
+  codex: '.agents/skills',
+  cursor: '.cursor/skills',
+};
+const TARGET_ALIASES = {
+  all: 'all',
+  claude: 'claude',
+  'claude-code': 'claude',
+  codex: 'codex',
+  cursor: 'cursor',
+};
+
+program
+  .name('install')
+  .description('Install or view a skill in local tool directories')
+  .argument('<skill-ref>', 'Skill ref: <slug> or <slug>@<version>')
+  .option('--verbose', 'Verbose output')
+  .option('-a, --api-url <url>', 'SkillHub API URL', 'http://localhost:3000')
+  .option('-t, --target <target>', 'Install target: claude|codex|cursor|all', 'all')
+  .option('--view', 'View skill details without installing')
+  .action(async (skillRef, options) => {
+    const spinner = ora('Fetching skill information...').start();
+
+    try {
+      const parsed = parseSkillRef(skillRef);
+      const skillSlug = parsed.slug;
+      const installVersion = parsed.version || null;
+
+      // Get skill information
+      const skillInfo = await getSkillInfo(skillSlug, options.apiUrl);
+      spinner.succeed(chalk.green('Skill information fetched successfully'));
+
+      // Display skill details
+      displaySkillDetails(skillInfo, installVersion);
+
+      if (!options.view) {
+        spinner.start('Fetching skill package...');
+        const skillPackage = await getSkillPackage(skillSlug, options.apiUrl, installVersion);
+        const resolvedVersion = skillPackage.version || installVersion || skillInfo.version || '-';
+
+        spinner.text = `Installing skill to target: ${options.target}`;
+        const installedFiles = await installSkill(skillSlug, skillPackage.files, options.target, resolvedVersion);
+        spinner.succeed(chalk.green('Skill installed successfully!'));
+        console.log(chalk.cyan(`Installed skill: ${skillSlug}@${resolvedVersion}`));
+
+        console.log(chalk.bold('\nInstalled files:'));
+        installedFiles.forEach((item) => {
+          console.log(chalk.green(`  [${item.target}] ${item.path}`));
+        });
+      }
+
+    } catch (error) {
+      spinner.fail(chalk.red(`Failed to process skill: ${error.message}`));
+      if (options.verbose) {
+        console.error(error);
+      }
+      process.exit(1);
+    }
+  });
+
+function parseSkillRef(skillRef) {
+  const raw = String(skillRef || '').trim();
+  if (!raw) {
+    throw new Error('Skill ref is required');
+  }
+
+  const atIndex = raw.lastIndexOf('@');
+  if (atIndex <= 0) {
+    return { slug: raw, version: null };
+  }
+
+  const slug = raw.slice(0, atIndex).trim();
+  const version = raw.slice(atIndex + 1).trim();
+  if (!slug || !version) {
+    throw new Error(`Invalid skill ref "${skillRef}". Use <slug> or <slug>@<version>`);
+  }
+
+  return { slug, version };
+}
+
+async function getSkillInfo(skillSlug, apiUrl) {
+  const response = await axios.get(`${apiUrl}/api/skills/${skillSlug}`);
+  if (!response.data?.success || !response.data?.data?.skill) {
+    throw new Error('Invalid skill info response');
+  }
+  return response.data.data.skill;
+}
+
+async function getSkillPackage(skillSlug, apiUrl, skillVersion) {
+  const params = skillVersion ? { version: skillVersion } : {};
+
+  try {
+    const response = await axios.get(`${apiUrl}/api/skills/${skillSlug}/package`, { params });
+    if (!response.data?.success || !response.data?.data?.files) {
+      throw new Error('Invalid skill package response');
+    }
+    return response.data.data;
+  } catch (error) {
+    // 兼容旧服务端：回退到单文件安装
+    const response = await axios.get(`${apiUrl}/api/skills/${skillSlug}/content`, { params });
+    if (!response.data?.success || !response.data?.data?.content) {
+      throw error;
+    }
+    return {
+      files: [
+        {
+          relative_path: 'SKILL.md',
+          content_base64: Buffer.from(response.data.data.content, 'utf8').toString('base64')
+        }
+      ]
+    };
+  }
+}
+
+function resolveTargets(targetInput) {
+  const rawTarget = String(targetInput || 'all').trim().toLowerCase();
+  const target = TARGET_ALIASES[rawTarget];
+
+  if (!target) {
+    throw new Error(`Invalid target "${rawTarget}". Use one of: claude, codex, cursor, all`);
+  }
+
+  if (target === 'all') {
+    return Object.keys(TARGET_DIRS);
+  }
+
+  return [target];
+}
+
+function normalizeInstallPath(skillSlug, relativePath) {
+  const unified = String(relativePath || '').replace(/\\/g, '/').replace(/^\/+/, '');
+  let normalized = path.posix.normalize(unified);
+
+  if (
+    !normalized
+    || normalized === '.'
+    || normalized.startsWith('../')
+    || normalized.includes('/../')
+  ) {
+    throw new Error(`Invalid package file path: ${relativePath}`);
+  }
+
+  const lowerSlugPrefix = `${skillSlug.toLowerCase()}/`;
+  if (normalized.toLowerCase().startsWith(lowerSlugPrefix)) {
+    normalized = normalized.slice(skillSlug.length + 1);
+  }
+
+  if (!normalized || normalized === '.') {
+    throw new Error(`Invalid normalized package file path: ${relativePath}`);
+  }
+
+  return normalized;
+}
+
+async function installSkill(skillSlug, files, targetInput, resolvedVersion = 'unknown') {
+  if (skillSlug.includes('/') || skillSlug.includes('\\') || skillSlug.includes('..')) {
+    throw new Error('Invalid skill slug for local installation path');
+  }
+  if (!Array.isArray(files) || files.length === 0) {
+    throw new Error('No package files to install');
+  }
+
+  const targets = resolveTargets(targetInput);
+  const installed = [];
+
+  for (const target of targets) {
+    const outputDir = path.join(process.cwd(), TARGET_DIRS[target], skillSlug);
+    await fs.rm(outputDir, { recursive: true, force: true });
+    await fs.mkdir(outputDir, { recursive: true });
+    const writtenRelativePaths = [];
+
+    for (const file of files) {
+      const relativePath = normalizeInstallPath(
+        skillSlug,
+        file.relative_path || file.relativePath || file.path
+      );
+      const outputPath = path.join(outputDir, ...relativePath.split('/'));
+      const relativeToBase = path.relative(outputDir, outputPath);
+
+      if (relativeToBase.startsWith('..') || path.isAbsolute(relativeToBase)) {
+        throw new Error(`Unsafe output path: ${outputPath}`);
+      }
+
+      await fs.mkdir(path.dirname(outputPath), { recursive: true });
+
+      const contentBuffer = file.content_base64
+        ? Buffer.from(file.content_base64, 'base64')
+        : Buffer.from(file.content || '', 'utf8');
+      await fs.writeFile(outputPath, contentBuffer);
+      writtenRelativePaths.push(relativePath);
+
+      installed.push({
+        target,
+        path: outputPath
+      });
+    }
+
+    const metadataPath = path.join(outputDir, '.myskillshub-install.json');
+    await fs.writeFile(
+      metadataPath,
+      JSON.stringify({
+        slug: skillSlug,
+        version: resolvedVersion,
+        installed_at: new Date().toISOString(),
+        files: writtenRelativePaths
+      }, null, 2),
+      'utf8'
+    );
+  }
+
+  return installed;
+}
+
+function displaySkillDetails(skillInfo, skillVersion = null) {
+  console.log(chalk.bold('\n' + '='.repeat(50)));
+  console.log(chalk.bold.cyan('Skill Details'));
+  console.log(chalk.bold('='.repeat(50) + '\n'));
+
+  const categoryLabel = skillInfo.category?.name || 'Uncategorized';
+
+  console.log(chalk.white('Name:'), chalk.green(skillInfo.name || '-'));
+  console.log(chalk.white('Version:'), chalk.green(skillVersion || skillInfo.version || '-'));
+  console.log(chalk.white('Author:'), chalk.green(skillInfo.author || '-'));
+  console.log(chalk.white('Slug:'), chalk.green(skillInfo.slug || '-'));
+  console.log(chalk.white('Category:'), chalk.green(categoryLabel));
+
+  console.log('\n' + chalk.white('Description:'));
+  console.log(chalk.gray('  ' + (skillInfo.description || 'No description')));
+
+  console.log('\n' + chalk.white('Install Command:'));
+  console.log(chalk.blue(`  myskillshub install ${skillInfo.slug} --target all`));
+
+  // Show rating
+  if (skillInfo.rating_avg !== undefined) {
+    const rating = Number(skillInfo.rating_avg).toFixed(1);
+    const stars = '★'.repeat(Math.floor(rating)) + '☆'.repeat(5 - Math.floor(rating));
+    console.log(chalk.white('Rating:'), chalk.yellow(`${stars} ${rating}/5`));
+  }
+
+  // Show install count
+  if (skillInfo.install_count !== undefined) {
+    console.log(chalk.white('Installs:'), chalk.green(String(skillInfo.install_count)));
+  }
+
+  // Show publish date
+  if (skillInfo.published_at || skillInfo.created_at) {
+    const date = new Date(skillInfo.published_at || skillInfo.created_at).toLocaleDateString();
+    console.log(chalk.white('Published:'), chalk.green(date));
+  }
+
+  console.log('\n' + chalk.bold('='.repeat(50)));
+}
+
+module.exports = program;

package/src/commands/publish.js

@@ -0,0 +1,158 @@
+const { Command } = require('commander');
+const chalk = require('chalk');
+const fs = require('fs');
+const path = require('path');
+const axios = require('axios');
+const oraModule = require('ora');
+const ora = oraModule.default || oraModule;
+const archiver = require('archiver');
+const FormData = require('form-data');
+const { createWriteStream } = require('fs');
+
+const program = new Command();
+
+program
+  .name('publish')
+  .description('Publish a skill from local directory')
+  .argument('<directory>', 'Directory containing skill to publish')
+  .option('--verbose', 'Verbose output')
+  .option('-a, --api-url <url>', 'SkillHub API URL', 'http://localhost:3000')
+  .action(async (directory, options) => {
+    const spinner = ora('Starting publish process...').start();
+
+    try {
+      // Validate directory exists
+      if (!fs.existsSync(directory)) {
+        spinner.fail(chalk.red(`Directory not found: ${directory}`));
+        process.exit(1);
+      }
+
+      // Find skill.md file
+      const skillMdPath = path.join(directory, 'skill.md');
+      if (!fs.existsSync(skillMdPath)) {
+        spinner.fail(chalk.red('skill.md not found in the directory'));
+        process.exit(1);
+      }
+
+      spinner.text = 'Reading skill metadata...';
+      const skillMdContent = fs.readFileSync(skillMdPath, 'utf8');
+
+      // Parse skill.md content (basic parsing)
+      const skillData = parseSkillMd(skillMdContent);
+      spinner.succeed(chalk.green(`Found skill: ${skillData.name}`));
+
+      // Create ZIP package
+      spinner.text = 'Creating ZIP package...';
+      const zipPath = await createZipPackage(directory);
+      spinner.succeed(chalk.green(`ZIP package created: ${zipPath}`));
+
+      // Upload to SkillHub API
+      spinner.text = 'Uploading to SkillHub API...';
+      const result = await uploadSkill(zipPath, skillData, options.apiUrl);
+
+      spinner.succeed(chalk.green('Skill published successfully!'));
+      console.log(chalk.cyan(`Skill slug: ${result.slug}`));
+      console.log(chalk.cyan(`Skill URL: ${options.apiUrl}/skills/${result.slug}`));
+
+    } catch (error) {
+      spinner.fail(chalk.red(`Publish failed: ${error.message}`));
+      if (options.verbose) {
+        console.error(error);
+      }
+      process.exit(1);
+    }
+  });
+
+function parseSkillMd(content) {
+  const lines = content.split('\n');
+  const skillData = {
+    name: '',
+    description: '',
+    version: '1.0.0',
+    author: '',
+    keywords: [],
+    installCommand: ''
+  };
+
+  let inDescription = false;
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith('# ')) {
+      skillData.name = trimmed.substring(2);
+    } else if (trimmed.startsWith('## Description')) {
+      inDescription = true;
+    } else if (trimmed.startsWith('## ')) {
+      inDescription = false;
+    } else if (inDescription && trimmed) {
+      if (!skillData.description) {
+        skillData.description = trimmed;
+      } else {
+        skillData.description += ' ' + trimmed;
+      }
+    } else if (trimmed.startsWith('Version:')) {
+      skillData.version = trimmed.split(':')[1].trim();
+    } else if (trimmed.startsWith('Author:')) {
+      skillData.author = trimmed.split(':')[1].trim();
+    } else if (trimmed.startsWith('Keywords:')) {
+      skillData.keywords = trimmed.split(':')[1].split(',').map(k => k.trim());
+    } else if (trimmed.startsWith('Install:')) {
+      skillData.installCommand = trimmed.split(':')[1].trim();
+    }
+  }
+
+  return skillData;
+}
+
+function createZipPackage(directory) {
+  return new Promise((resolve, reject) => {
+    const zipPath = path.join(process.cwd(), `${path.basename(directory)}-package.zip`);
+    const output = createWriteStream(zipPath);
+    const archive = archiver('zip', {
+      zlib: { level: 9 }
+    });
+
+    output.on('close', () => {
+      resolve(zipPath);
+    });
+
+    output.on('error', (err) => {
+      reject(err);
+    });
+
+    archive.pipe(output);
+
+    // Add all files except node_modules and .git
+    archive.directory(directory, false, (data) => {
+      return data.stats.isDirectory() &&
+             !data.name.includes('node_modules') &&
+             !data.name.includes('.git');
+    });
+
+    archive.finalize();
+  });
+}
+
+async function uploadSkill(zipPath, skillData, apiUrl) {
+  const formData = new FormData();
+  formData.append('file', fs.createReadStream(zipPath));
+  formData.append('name', skillData.name);
+  formData.append('description', skillData.description);
+  formData.append('version', skillData.version);
+  formData.append('author', skillData.author);
+  formData.append('keywords', JSON.stringify(skillData.keywords));
+  formData.append('installCommand', skillData.installCommand);
+
+  const response = await axios.post(`${apiUrl}/api/skills/publish`, formData, {
+    headers: {
+      ...formData.getHeaders()
+    }
+  });
+
+  // Clean up ZIP file after successful upload
+  fs.unlinkSync(zipPath);
+
+  return response.data;
+}
+
+module.exports = program;

package/src/commands/search.js

@@ -0,0 +1,116 @@
+const { Command } = require('commander');
+const chalk = require('chalk');
+const axios = require('axios');
+const oraModule = require('ora');
+const ora = oraModule.default || oraModule;
+
+const program = new Command();
+
+program
+  .name('search')
+  .description('Search for skills')
+  .argument('[query]', 'Search query')
+  .option('--verbose', 'Verbose output')
+  .option('-a, --api-url <url>', 'SkillHub API URL', 'http://localhost:3000')
+  .option('-c, --category <category>', 'Filter by category')
+  .option('-k, --keywords <keywords>', 'Filter by keywords (comma-separated)')
+  .option('-r, --rating <rating>', 'Minimum rating')
+  .option('-l, --limit <limit>', 'Maximum number of results', '10')
+  .action(async (query, options) => {
+    const spinner = ora('Searching skills...').start();
+
+    try {
+      const searchParams = {
+        query: query || '',
+        limit: parseInt(options.limit),
+        category: options.category || '',
+        keywords: options.keywords ? options.keywords.split(',').map(k => k.trim()) : [],
+        rating: options.rating ? parseFloat(options.rating) : null
+      };
+
+      const results = await searchSkills(searchParams, options.apiUrl);
+      spinner.succeed(chalk.green(`Found ${results.length} skills`));
+
+      if (results.length === 0) {
+        console.log(chalk.yellow('No skills found matching your criteria.'));
+        return;
+      }
+
+      displaySearchResults(results);
+
+    } catch (error) {
+      spinner.fail(chalk.red(`Search failed: ${error.message}`));
+      if (options.verbose) {
+        console.error(error);
+      }
+      process.exit(1);
+    }
+  });
+
+async function searchSkills(params, apiUrl) {
+  const queryParams = new URLSearchParams({
+    search: params.query,
+    limit: params.limit.toString(),
+    category: params.category
+  });
+
+  if (params.keywords.length > 0) {
+    queryParams.append('keywords', params.keywords.join(','));
+  }
+
+  if (params.rating !== null) {
+    queryParams.append('rating', params.rating.toString());
+  }
+
+  const response = await axios.get(`${apiUrl}/api/skills?${queryParams}`);
+  return response.data?.data?.skills || [];
+}
+
+function displaySearchResults(skills) {
+  console.log(chalk.bold('\n' + '='.repeat(80)));
+  console.log(chalk.bold.cyan('Search Results'));
+  console.log(chalk.bold('='.repeat(80) + '\n'));
+
+  skills.forEach((skill, index) => {
+    const indexNumber = chalk.blue(`${(index + 1).toString().padStart(2)}.`);
+    const title = chalk.bold(skill.name);
+    const version = chalk.gray(`v${skill.version}`);
+    const author = chalk.yellow(`by ${skill.author}`);
+    const category = chalk.cyan(skill.category?.name || skill.category || 'Uncategorized');
+
+    console.log(`${indexNumber} ${title} ${version}`);
+    console.log(`   ${author} • ${category}`);
+
+    // Show rating if available
+    if (skill.rating_avg !== undefined && Number(skill.rating_avg) > 0) {
+      const rating = Number(skill.rating_avg).toFixed(1);
+      const stars = '★'.repeat(Math.floor(rating)) + '☆'.repeat(5 - Math.floor(rating));
+      console.log(`   Rating: ${chalk.yellow(stars)} ${rating}/5`);
+    }
+
+    // Show first few keywords
+    if (skill.tags && skill.tags.length > 0) {
+      const keywords = skill.tags.slice(0, 3).map(k => chalk.green(k)).join(', ');
+      const remaining = skill.tags.length > 3 ? ` +${skill.tags.length - 3} more` : '';
+      console.log(`   Keywords: ${keywords}${remaining}`);
+    }
+
+    // Show description (truncated)
+    if (skill.description) {
+      const truncatedDesc = skill.description.length > 100
+        ? skill.description.substring(0, 100) + '...'
+        : skill.description;
+      console.log(`   ${chalk.gray(truncatedDesc)}`);
+    }
+
+    console.log();
+  });
+
+  console.log(chalk.bold('='.repeat(80)));
+
+  // Show usage tips
+  console.log(chalk.yellow('\nPro tip: Use `myskillshub install <slug> --target all` to install a skill'));
+  console.log(chalk.yellow('Use `myskillshub info <slug>` to view versions and local install status\n'));
+}
+
+module.exports = program;

package/src/index.js

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+
+require('dotenv').config();
+const { program } = require('commander');
+const chalk = require('chalk');
+const { version: cliVersion } = require('../package.json');
+const publishCommand = require('./commands/publish');
+const installCommand = require('./commands/install');
+const searchCommand = require('./commands/search');
+const infoCommand = require('./commands/info');
+
+program
+  .name('myskillshub')
+  .description('CLI tool for SkillHub skill management')
+  .version(cliVersion, '-v, --version', 'Display CLI version');
+
+// Register commands
+program.addCommand(publishCommand);
+program.addCommand(installCommand);
+program.addCommand(searchCommand);
+program.addCommand(infoCommand);
+
+// Handle unknown commands
+program.on('command:*', function (operands) {
+  console.error(chalk.red(`Unknown command: ${operands[0]}`));
+  console.log(chalk.yellow('Available commands:'));
+  program.commands.forEach(cmd => {
+    console.log(chalk.blue(`  ${cmd.name()}`));
+  });
+  process.exit(1);
+});
+
+// Parse command line arguments
+program.parse();