@haolin-ai/skillman 1.0.6 → 1.0.8

package/README.md

@@ -47,9 +47,22 @@ skillman install git@github.com:org/repo.git
 ### Commands
 
 ```bash
+# Initialize a new skill template
+skillman init [skill-name]
+skillman init my-skill -v 2.0.0 -d "Description" -a "Author"
+
 # List all available agents
 skillman agents
 
+# List installed skills
+skillman list
+
+# Update a skill
+skillman update my-skill
+
+# Uninstall a skill
+skillman uninstall my-skill
+
 # Preview installation without making changes
 skillman --dry-run
 
@@ -63,6 +76,8 @@ skillman --version
 ## Features
 
 - **Multi-Agent Support**: Works with Claude Code, OpenClaw, Qoder, Codex, Cursor, and more
+- **Skill Template Generator**: Quickly create new skills with `skillman init`
+- **Version Management**: Track and manage skill versions with `list`, `update`, and `uninstall` commands
 - **Workspace History**: Remembers previously used workspace paths for quick selection
 - **Bilingual Support**: Automatically switches between English and Chinese based on system language
 - **Dry-Run Mode**: Preview installations before applying changes
@@ -91,7 +106,7 @@ git clone <repo-url>
 cd skillman
 
 # Install dependencies
-pnpm install
+npm install
 
 # Run locally
 node bin/skillman.mjs

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@haolin-ai/skillman",
-  "version": "1.0.6",
+  "version": "1.0.8",
   "description": "A CLI tool to install AI agent skills across multiple platforms",
   "type": "module",
   "bin": {
-    "skillman": "./bin/skillman.mjs"
+    "skillman": "bin/skillman.mjs"
   },
   "files": [
     "bin",

package/src/cli.js

@@ -7,16 +7,27 @@ import path from 'path';
 import { fileURLToPath } from 'url';
 import { select, confirm, input, Separator, checkbox } from '@inquirer/prompts';
 import pkg from '../package.json' with { type: 'json' };
-import { scanSkills } from './scanner.js';
+import { scanSkills, parseSkillFile } from './scanner.js';
 import { installSkill } from './installer.js';
 import { loadAgents } from './config.js';
 import { t } from './i18n.js';
 import { loadHistory, addWorkspace, saveLastUsed } from './history.js';
 import { downloadSkill, parseUrl, cleanupDownloads } from './downloader.js';
+import { InstalledSkillRegistry, formatInstalledSkills, uninstallSkill, updateSkill } from './version.js';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const VERSION = pkg.version || '1.0.0';
 
+// ASCII Art Logo
+const LOGO = `
+███████╗██╗  ██╗██╗██╗     ██╗     ███╗   ███╗ █████╗ ███╗   ██╗
+██╔════╝██║ ██╔╝██║██║     ██║     ████╗ ████║██╔══██╗████╗  ██║
+███████╗█████╔╝ ██║██║     ██║     ██╔████╔██║███████║██╔██╗ ██║
+╚════██║██╔═██╗ ██║██║     ██║     ██║╚██╔╝██║██╔══██║██║╚██╗██║
+███████║██║  ██╗██║███████╗███████╗██║ ╚═╝ ██║██║  ██║██║ ╚████║
+╚══════╝╚═╝  ╚═╝╚═╝╚══════╝╚══════╝╚═╝     ╚═╝╚═╝  ╚═╝╚═╝  ╚═══╝
+`;
+
 // ANSI colors
 const c = {
   reset: '\x1b[0m',
@@ -41,22 +52,51 @@ const log = {
 function parseArgs(args) {
   const result = {
     command: null,
+    subcommand: null,
     dryRun: false,
     help: false,
     version: false,
+    initVersion: '1.0.0',
+    initDescription: '',
+    initAuthor: '',
+    initDir: true,
     positional: []
   };
 
-  for (const arg of args) {
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
     if (arg === '--dry-run' || arg === '-n') {
       result.dryRun = true;
     } else if (arg === '--help' || arg === '-h') {
       result.help = true;
     } else if (arg === '--version' || arg === '-v') {
-      result.version = true;
+      // Check if next arg is a value (for init command)
+      if (args[i + 1] && !args[i + 1].startsWith('-')) {
+        result.initVersion = args[i + 1];
+        i++;
+      } else {
+        result.version = true;
+      }
+    } else if (arg === '--description' || arg === '-d') {
+      if (args[i + 1] && !args[i + 1].startsWith('-')) {
+        result.initDescription = args[i + 1];
+        i++;
+      }
+    } else if (arg === '--author' || arg === '-a') {
+      if (args[i + 1] && !args[i + 1].startsWith('-')) {
+        result.initAuthor = args[i + 1];
+        i++;
+      }
+    } else if (arg === '--dir') {
+      if (args[i + 1] && !args[i + 1].startsWith('-')) {
+        result.initDir = args[i + 1].toLowerCase() !== 'false';
+        i++;
+      }
     } else if (!arg.startsWith('-')) {
       if (!result.command) {
         result.command = arg;
+      } else if (!result.subcommand) {
+        result.subcommand = arg;
       } else {
         result.positional.push(arg);
       }
@@ -72,8 +112,13 @@ function showHelp() {
 
 ${c.cyan}${t('help.usage')}:${c.reset}
   skillman                    ${t('help.cmd.interactive')}
+  skillman init [name]        ${t('help.cmd.init')}
   skillman install <path>     ${t('help.cmd.install')}
   skillman i <path>           ${t('help.cmd.install')}
+  skillman list               ${t('help.cmd.list')}
+  skillman update <skill>     ${t('help.cmd.update')}
+  skillman u <skill>          ${t('help.cmd.update')}
+  skillman uninstall <skill>  ${t('help.cmd.uninstall')}
   skillman agents             ${t('help.cmd.agents')}
 
 ${c.cyan}${t('help.options')}:${c.reset}
@@ -83,9 +128,15 @@ ${c.cyan}${t('help.options')}:${c.reset}
 
 ${c.cyan}${t('help.examples')}:${c.reset}
   skillman                     # ${t('help.cmd.interactive')}
+  skillman init                # Create skill with default name
+  skillman init my-skill       # Create skill with custom name
+  skillman init -v 2.0.0       # Create skill with specific version
   skillman --dry-run           # ${t('help.opt.dry_run')}
   skillman install ./my-skill  # ${t('help.cmd.install')}
   skillman i github.com/owner/repo  # ${t('help.cmd.install')}
+  skillman list                # ${t('help.cmd.list')}
+  skillman update my-skill     # ${t('help.cmd.update')}
+  skillman uninstall my-skill  # ${t('help.cmd.uninstall')}
   skillman agents              # ${t('help.cmd.agents')}
 `);
 }
@@ -109,11 +160,75 @@ async function listAgents() {
   }
 }
 
-// Install from URL or local path
+// Initialize a new skill template
+export async function initSkill(skillName, options) {
+  const name = skillName || 'my-skill';
+  const version = options.initVersion || '1.0.0';
+  const description = options.initDescription || '';
+  const author = options.initAuthor || '';
+  const createDir = options.initDir !== false;
+  
+  console.log(`${c.cyan}${LOGO}${c.reset}`);
+  log.step(t('msg.init_skill') || 'Initializing skill template');
+  
+  const targetDir = createDir ? path.join(process.cwd(), name) : process.cwd();
+  const skillFile = path.join(targetDir, 'SKILL.md');
+  
+  // Check if already exists
+  try {
+    await fs.access(skillFile);
+    log.error(t('error.skill_exists') || 'SKILL.md already exists');
+    process.exit(1);
+  } catch {
+    // File doesn't exist, proceed
+  }
+  
+  // Create directory if needed
+  if (createDir) {
+    await fs.mkdir(targetDir, { recursive: true });
+  }
+  
+  // Build metadata section
+  let metadataSection = `metadata:\n  version: ${version}`;
+  if (author) {
+    metadataSection += `\n  author: ${author}`;
+  }
+  
+  // Generate SKILL.md content
+  const skillContent = `---
+name: ${name}
+description: ${description}
+${metadataSection}
+---
+
+# ${name}
+
+## Purpose
+
+## Responsibilities
+
+## Decision Rules
+
+## Output Contract
+`;
+  
+  await fs.writeFile(skillFile, skillContent);
+  
+  log.success(`${t('msg.created') || 'Created'}: ${skillFile}`);
+  console.log(`\n${c.gray}${t('msg.init_hint') || 'Edit SKILL.md to customize your skill'}${c.reset}`);
+}
+
+// Install from URL or local path with optional version
 async function installFromUrl(url, dryRun) {
-  console.log(`${c.green}${t('app.name')}${c.reset} - ${t('app.description')}${dryRun ? c.yellow + ' [DRY-RUN]' + c.reset : ''}\n`);
+  // Parse version from URL (e.g., skill@1.2.3 or github.com/owner/repo@1.2.3)
+  const versionMatch = url.match(/@([^@\/]+)$/);
+  const requestedVersion = versionMatch ? versionMatch[1] : null;
+  const cleanUrl = requestedVersion ? url.slice(0, -versionMatch[0].length) : url;
+  
+  console.log(`${c.cyan}${LOGO}${c.reset}`);
+  console.log(`${c.gray}${t('app.description')}${dryRun ? c.yellow + ' [DRY-RUN]' + c.reset : ''}\n`);
 
-  const parsed = parseUrl(url);
+  const parsed = parseUrl(cleanUrl);
   const isRemote = parsed.type !== 'local';
 
   // Step 1: Download/resolve path
@@ -142,35 +257,22 @@ async function installFromUrl(url, dryRun) {
 
   log.success(t('msg.found_skills', { count: skills.length }));
 
-  // Step 3: Select skills (if multiple)
-  let selectedSkills;
-  if (skills.length === 1) {
-    selectedSkills = [skills[0]];
-    log.success(`${t('msg.selected')}: ${skills[0].name}`);
-  } else {
-    const skillChoices = skills.map(s => ({
-      name: s.description 
-        ? `${s.name} ${c.gray}(${s.description.slice(0, 40)}${s.description.length > 40 ? '...' : ''})${c.reset}`
-        : s.name,
-      value: s
-    }));
-
-    selectedSkills = await checkbox({
-      message: t('step.select_skills') + ':',
-      choices: skillChoices,
-      pageSize: 10,
-      loop: false,
-      validate: (selected) => {
-        if (selected.length === 0) {
-          return t('error.no_selection') || 'Please select at least one skill';
-        }
-        return true;
-      }
-    });
-
-    log.success(`${t('msg.selected_count', { count: selectedSkills.length })}`);
+  // Check version if specified
+  if (requestedVersion) {
+    const matchingSkills = skills.filter(s => s.version === requestedVersion);
+    if (matchingSkills.length === 0) {
+      const availableVersions = [...new Set(skills.map(s => s.version).filter(Boolean))];
+      log.error(`Version ${requestedVersion} not found. Available versions: ${availableVersions.join(', ') || 'none'}`);
+      process.exit(1);
+    }
+    skills.length = 0;
+    skills.push(...matchingSkills);
+    log.success(`Found ${skills.length} skill(s) matching version ${requestedVersion}`);
   }
 
+  // Step 3: Select skills
+  const selectedSkills = await selectSkills(skills);
+
   // Continue with rest of interactive flow
   await continueInstallMultiple(selectedSkills, dryRun);
 
@@ -329,7 +431,13 @@ async function continueInstallMultiple(selectedSkills, dryRun) {
     let shouldInstall = true;
     try {
       await fs.access(targetDir);
-      log.warn(t('msg.skill_exists'));
+      // Get existing skill version
+      const existingSkillFile = path.join(targetDir, 'SKILL.md');
+      const existingSkill = await parseSkillFile(existingSkillFile);
+      const currentVer = existingSkill?.version || '?';
+      const newVer = skill.version || '?';
+      log.warn(`${skill.name} ${t('msg.already_exists') || 'already exists'}`);
+      console.log(`  ${c.gray}Current:${c.reset} v${currentVer}  ${c.gray}→${c.reset}  ${c.gray}Installing:${c.reset} v${newVer}`);
       const overwrite = await confirm({ message: t('prompt.overwrite') + '?', default: false });
       if (!overwrite) {
         log.info(t('msg.skipped') || 'Skipped');
@@ -341,7 +449,12 @@ async function continueInstallMultiple(selectedSkills, dryRun) {
     }
     
     if (shouldInstall) {
-      await installSkill(skill.path, targetDir);
+      await installSkill(skill.path, targetDir, {
+        name: skill.name,
+        version: skill.version,
+        agent: agent.name,
+        scope: scope
+      });
       log.success(`${t('msg.target')}: ${targetDir}`);
       installedCount++;
     }
@@ -358,9 +471,133 @@ async function continueInstallMultiple(selectedSkills, dryRun) {
   console.log();
 }
 
+// Helper: Select skills from list
+async function selectSkills(skills, message = null) {
+  if (skills.length === 1) {
+    log.success(`${t('msg.selected')}: ${skills[0].name}`);
+    return [skills[0]];
+  }
+  
+  const skillChoices = skills.map(s => {
+    const versionStr = s.version ? `@${s.version}` : '';
+    const descStr = s.description 
+      ? ` ${c.gray}(${s.description.slice(0, 40)}${s.description.length > 40 ? '...' : ''})${c.reset}`
+      : '';
+    return {
+      name: `${s.name}${versionStr}${descStr}`,
+      value: s
+    };
+  });
+
+  const selectedSkills = await checkbox({
+    message: (message || t('step.select_skills')) + ':',
+    choices: skillChoices,
+    pageSize: 10,
+    loop: false,
+    validate: (selected) => {
+      if (selected.length === 0) {
+        return t('error.no_selection') || 'Please select at least one skill';
+      }
+      return true;
+    }
+  });
+
+  log.success(`${t('msg.selected_count', { count: selectedSkills.length })}`);
+  return selectedSkills;
+}
+
+// List installed skills
+async function listSkills() {
+  const registry = new InstalledSkillRegistry();
+  const skills = await registry.load();
+  
+  console.log(`\n${c.cyan}${t('msg.installed_skills')}:${c.reset}\n`);
+  
+  const lines = formatInstalledSkills(skills, t);
+  for (const line of lines) {
+    console.log(line);
+  }
+}
+
+// Uninstall a skill
+async function uninstallCommand(skillName, dryRun) {
+  if (!skillName) {
+    log.error(t('error.no_skill_name') || 'Please specify a skill name');
+    process.exit(1);
+  }
+  
+  const registry = new InstalledSkillRegistry();
+  const skill = await registry.find(skillName);
+  
+  if (!skill) {
+    log.error(t('error.skill_not_installed'));
+    process.exit(1);
+  }
+  
+  if (dryRun) {
+    log.dry(`${t('msg.uninstalling') || 'Would uninstall'}: ${skillName}`);
+    log.dry(`  ${t('msg.target')}: ${skill.targetPath}`);
+    return;
+  }
+  
+  const confirmed = await confirm({ 
+    message: `${t('prompt.uninstall')} ${skillName}?`, 
+    default: false 
+  });
+  
+  if (!confirmed) {
+    log.info(t('msg.cancelled') || 'Cancelled');
+    return;
+  }
+  
+  const success = await uninstallSkill(skillName, registry);
+  
+  if (success) {
+    log.success(`${t('msg.uninstalled')}: ${skillName}`);
+  } else {
+    log.error(t('error.unknown'));
+    process.exit(1);
+  }
+}
+
+// Update a skill
+async function updateCommand(skillName, dryRun) {
+  if (!skillName) {
+    log.error(t('error.no_skill_name') || 'Please specify a skill name');
+    process.exit(1);
+  }
+  
+  const registry = new InstalledSkillRegistry();
+  const skill = await registry.find(skillName);
+  
+  if (!skill) {
+    log.error(t('error.skill_not_installed'));
+    process.exit(1);
+  }
+  
+  if (dryRun) {
+    log.dry(`${t('msg.updating') || 'Would update'}: ${skillName}`);
+    log.dry(`  ${t('msg.source')}: ${skill.sourcePath}`);
+    log.dry(`  ${t('msg.target')}: ${skill.targetPath}`);
+    return;
+  }
+  
+  log.step(`${t('msg.updating') || 'Updating'}: ${skillName}`);
+  
+  const result = await updateSkill(skillName, registry);
+  
+  if (result.success) {
+    log.success(`${t('msg.updated')}: ${skillName}`);
+  } else {
+    log.error(result.message);
+    process.exit(1);
+  }
+}
+
 // Interactive install flow
 async function interactiveInstall(dryRun) {
-  console.log(`${c.green}${t('app.name')}${c.reset} - ${t('app.description')}${dryRun ? c.yellow + ' [DRY-RUN]' + c.reset : ''}\n`);
+  console.log(`${c.cyan}${LOGO}${c.reset}`);
+  console.log(`${c.gray}${t('app.description')}${dryRun ? c.yellow + ' [DRY-RUN]' + c.reset : ''}\n`);
 
   // Step 1: Scan skills
   log.step(t('step.scan'));
@@ -373,24 +610,11 @@ async function interactiveInstall(dryRun) {
 
   log.success(t('msg.found_skills', { count: skills.length }));
 
-  // Step 2: Select skill
-  const skillChoices = skills.map(s => ({
-    name: s.description 
-      ? `${s.name} ${c.gray}(${s.description.slice(0, 40)}${s.description.length > 40 ? '...' : ''})${c.reset}`
-      : s.name,
-    value: s
-  }));
-
-  const selectedSkill = await select({
-    message: t('step.select_skill') + ':',
-    choices: skillChoices,
-    pageSize: 10
-  });
-
-  log.success(`${t('msg.selected')}: ${selectedSkill.name}`);
+  // Step 2: Select skills
+  const selectedSkills = await selectSkills(skills);
 
   // Continue with agent selection and installation
-  await continueInstall(selectedSkill, dryRun);
+  await continueInstallMultiple(selectedSkills, dryRun);
 }
 
 // Main CLI function
@@ -413,12 +637,33 @@ export async function cli() {
     return;
   }
 
+  if (options.command === 'init') {
+    const skillName = options.subcommand || options.positional[0];
+    await initSkill(skillName, options);
+    return;
+  }
+
   if (options.command === 'install' || options.command === 'i') {
     const url = options.positional[0] || process.cwd();
     await installFromUrl(url, options.dryRun);
     return;
   }
 
+  if (options.command === 'list') {
+    await listSkills();
+    return;
+  }
+
+  if (options.command === 'uninstall') {
+    await uninstallCommand(options.subcommand, options.dryRun);
+    return;
+  }
+
+  if (options.command === 'update' || options.command === 'u') {
+    await updateCommand(options.subcommand, options.dryRun);
+    return;
+  }
+
   // Default: interactive install
   await interactiveInstall(options.dryRun);
 }

package/src/i18n.js

@@ -64,12 +64,25 @@ const translations = {
     'msg.installing': '正在安装',
     'msg.skipped': '已跳过',
     'msg.installed': '已安装',
+    'msg.no_installed_skills': '没有已安装的技能',
+    'msg.installed_skills': '已安装的技能',
+    'msg.skill_not_found': '未找到技能',
+    'msg.uninstalled': '已卸载',
+    'msg.updated': '已更新',
+    'msg.updating': '正在更新',
+    'msg.uninstalling': '正在卸载',
+    'msg.cancelled': '已取消',
+    'msg.already_exists': '已存在',
+    'msg.init_skill': '初始化 Skill 模板',
+    'msg.created': '已创建',
+    'msg.init_hint': '编辑 SKILL.md 来自定义你的 skill',
     
     // Prompts
     'prompt.workspace_path': '输入 Workspace 路径',
     'prompt.overwrite': '是否覆盖',
     'prompt.select_workspace': '选择 Workspace 路径',
     'prompt.new_path': '输入新路径...',
+    'prompt.uninstall': '确认卸载',
     
     // Options
     'option.global': '全局',
@@ -80,13 +93,19 @@ const translations = {
     'error.empty_path': '路径不能为空',
     'error.not_implemented': '该命令尚未实现，请使用交互模式',
     'error.no_selection': '请至少选择一个 skill',
+    'error.skill_not_installed': '技能未安装',
+    'error.no_skill_name': '请指定技能名称',
     
     // Help
     'help.usage': '用法',
     'help.options': '选项',
     'help.examples': '示例',
     'help.cmd.interactive': '交互式安装 (扫描当前目录)',
+    'help.cmd.init': '初始化新的 skill 模板',
     'help.cmd.install': '从指定路径安装 skill',
+    'help.cmd.list': '列出已安装的技能',
+    'help.cmd.update': '更新技能',
+    'help.cmd.uninstall': '卸载技能',
     'help.cmd.agents': '列出可用的 agents',
     'help.opt.dry_run': '预览安装而不执行更改',
     'help.opt.version': '显示版本号',
@@ -126,18 +145,32 @@ const translations = {
     'msg.preview_summary': 'Preview Summary',
     'msg.dry_run_hint': 'Running with --dry-run, no changes made',
     'msg.skill_exists': 'Skill already exists',
+    'msg.already_exists': 'already exists',
     'msg.install_cancelled': 'Installation cancelled',
     'msg.downloading': 'Downloading...',
     'msg.downloaded': 'Downloaded',
     'msg.installing': 'Installing',
     'msg.skipped': 'Skipped',
     'msg.installed': 'Installed',
+    'msg.no_installed_skills': 'No skills installed',
+    'msg.installed_skills': 'Installed Skills',
+    'msg.skill_not_found': 'Skill not found',
+    'msg.uninstalled': 'Uninstalled',
+    'msg.updated': 'Updated',
+    'msg.updating': 'Updating',
+    'msg.uninstalling': 'Uninstalling',
+    'msg.cancelled': 'Cancelled',
+    'msg.already_exists': 'already exists',
+    'msg.init_skill': 'Initializing skill template',
+    'msg.created': 'Created',
+    'msg.init_hint': 'Edit SKILL.md to customize your skill',
     
     // Prompts
     'prompt.workspace_path': 'Enter workspace path',
     'prompt.overwrite': 'Overwrite existing',
     'prompt.select_workspace': 'Select workspace path',
     'prompt.new_path': 'Enter new path...',
+    'prompt.uninstall': 'Confirm uninstall',
     
     // Options
     'option.global': 'Global',
@@ -148,13 +181,19 @@ const translations = {
     'error.empty_path': 'Path cannot be empty',
     'error.not_implemented': 'Command not implemented, use interactive mode',
     'error.no_selection': 'Please select at least one skill',
+    'error.skill_not_installed': 'Skill is not installed',
+    'error.no_skill_name': 'Please specify a skill name',
     
     // Help
     'help.usage': 'Usage',
     'help.options': 'Options',
     'help.examples': 'Examples',
     'help.cmd.interactive': 'Interactive install (scan current directory)',
+    'help.cmd.init': 'Initialize new skill template',
     'help.cmd.install': 'Install skill from path',
+    'help.cmd.list': 'List installed skills',
+    'help.cmd.update': 'Update a skill',
+    'help.cmd.uninstall': 'Uninstall a skill',
     'help.cmd.agents': 'List available agents',
     'help.opt.dry_run': 'Preview installation without making changes',
     'help.opt.version': 'Show version number',

package/src/installer.js

@@ -5,14 +5,34 @@
 
 import fs from 'fs/promises';
 import path from 'path';
+import { InstalledSkillRegistry } from './version.js';
 
 /**
  * Install skill by copying to target directory
  * @param {string} srcPath - Source skill directory
  * @param {string} targetDir - Target installation directory
+ * @param {Object} metadata - Installation metadata
+ * @param {string} metadata.name - Skill name
+ * @param {string} metadata.version - Skill version
+ * @param {string} metadata.agent - Target agent name
+ * @param {string} metadata.scope - Installation scope (global|workspace)
  */
-export async function installSkill(srcPath, targetDir) {
+export async function installSkill(srcPath, targetDir, metadata = {}) {
   await copyDir(srcPath, targetDir);
+  
+  // Record installation if metadata provided
+  if (metadata.name) {
+    const registry = new InstalledSkillRegistry();
+    await registry.add({
+      name: metadata.name,
+      version: metadata.version,
+      installedAt: new Date().toISOString(),
+      agent: metadata.agent,
+      scope: metadata.scope,
+      sourcePath: srcPath,
+      targetPath: targetDir
+    });
+  }
 }
 
 /**

package/src/scanner.js

@@ -10,6 +10,42 @@ import path from 'path';
 // Common skill container directories
 const SKILL_CONTAINERS = ['skills', '.agents/skills', '.claude/skills'];
 
+/**
+ * Parse a single SKILL.md file to extract metadata
+ * @param {string} skillFile - Path to SKILL.md
+ * @returns {Promise<Object|null>} Parsed skill info or null if invalid
+ */
+export async function parseSkillFile(skillFile) {
+  try {
+    const content = await fs.readFile(skillFile, 'utf-8');
+    const nameMatch = content.match(/^name:\s*(.+)$/m);
+    const descMatch = content.match(/^description:\s*(.+)$/m);
+    
+    // Parse version from metadata block (supports quoted and unquoted)
+    const metadataMatch = content.match(/metadata:[\s\S]*?(?=\n\w|$)/);
+    let version;
+    if (metadataMatch) {
+      const versionInMeta = metadataMatch[0].match(/^\s+version:\s*(.+)$/m);
+      if (versionInMeta) {
+        // Remove quotes if present (both single and double)
+        version = versionInMeta[1].trim().replace(/^["']|["']$/g, '');
+      }
+    }
+    
+    if (nameMatch) {
+      return {
+        name: nameMatch[1].trim(),
+        description: descMatch ? descMatch[1].trim() : '',
+        version: version
+      };
+    }
+  } catch {
+    // File doesn't exist or can't be read
+  }
+  
+  return null;
+}
+
 /**
  * Scan a single directory for skills
  * @param {string} dir - Directory to scan
@@ -28,20 +64,12 @@ async function scanSingleDir(dir) {
       const skillPath = path.join(dir, entry.name);
       const skillFile = path.join(skillPath, 'SKILL.md');
       
-      try {
-        const content = await fs.readFile(skillFile, 'utf-8');
-        const nameMatch = content.match(/^name:\s*(.+)$/m);
-        const descMatch = content.match(/^description:\s*(.+)$/m);
-        
-        if (nameMatch) {
-          skills.push({
-            name: nameMatch[1].trim(),
-            path: skillPath,
-            description: descMatch ? descMatch[1].trim() : ''
-          });
-        }
-      } catch {
-        // No SKILL.md or parse error, skip
+      const skillInfo = await parseSkillFile(skillFile);
+      if (skillInfo) {
+        skills.push({
+          ...skillInfo,
+          path: skillPath
+        });
       }
     }
   } catch {

package/src/version.js

@@ -0,0 +1,215 @@
+/**
+ * Version Management Module
+ * Handles tracking, listing, updating, and uninstalling skills
+ */
+
+import fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
+
+const CONFIG_DIR = path.join(os.homedir(), '.config', 'skillman');
+const INSTALLED_FILE = path.join(CONFIG_DIR, 'installed.json');
+
+/**
+ * Get the path to the installed skills registry file
+ * @returns {string}
+ */
+export function getInstalledSkillsPath() {
+  return INSTALLED_FILE;
+}
+
+/**
+ * Registry for tracking installed skills
+ */
+export class InstalledSkillRegistry {
+  constructor(registryPath = INSTALLED_FILE) {
+    this.registryPath = registryPath;
+  }
+
+  /**
+   * Load all installed skills from registry
+   * @returns {Promise<Array>}
+   */
+  async load() {
+    try {
+      const content = await fs.readFile(this.registryPath, 'utf-8');
+      const data = JSON.parse(content);
+      return data.skills || [];
+    } catch {
+      return [];
+    }
+  }
+
+  /**
+   * Save skills to registry
+   * @param {Array} skills
+   */
+  async save(skills) {
+    await fs.mkdir(path.dirname(this.registryPath), { recursive: true });
+    const data = {
+      version: 1,
+      updatedAt: new Date().toISOString(),
+      skills
+    };
+    await fs.writeFile(this.registryPath, JSON.stringify(data, null, 2));
+  }
+
+  /**
+   * Add a skill to the registry
+   * @param {Object} skill
+   */
+  async add(skill) {
+    const skills = await this.load();
+    const existingIndex = skills.findIndex(s => s.name === skill.name);
+    
+    if (existingIndex >= 0) {
+      skills[existingIndex] = skill;
+    } else {
+      skills.push(skill);
+    }
+    
+    await this.save(skills);
+  }
+
+  /**
+   * Remove a skill from the registry
+   * @param {string} skillName
+   */
+  async remove(skillName) {
+    const skills = await this.load();
+    const filtered = skills.filter(s => s.name !== skillName);
+    await this.save(filtered);
+  }
+
+  /**
+   * Find a skill by name
+   * @param {string} skillName
+   * @returns {Promise<Object|undefined>}
+   */
+  async find(skillName) {
+    const skills = await this.load();
+    return skills.find(s => s.name === skillName);
+  }
+}
+
+/**
+ * Format installed skills for display
+ * @param {Array} skills
+ * @param {Function} t - Translation function
+ * @returns {Array} Formatted lines
+ */
+export function formatInstalledSkills(skills, t = (key) => key) {
+  if (skills.length === 0) {
+    return [t('msg.no_installed_skills')];
+  }
+
+  const lines = [];
+  lines.push('');
+  
+  // Group by agent
+  const byAgent = skills.reduce((acc, skill) => {
+    const agent = skill.agent || 'unknown';
+    if (!acc[agent]) acc[agent] = [];
+    acc[agent].push(skill);
+    return acc;
+  }, {});
+  
+  for (const [agent, agentSkills] of Object.entries(byAgent)) {
+    lines.push(`${agent}:`);
+    for (const skill of agentSkills) {
+      const scope = skill.scope === 'global' ? 'G' : 'W';
+      const version = skill.version || 'unknown';
+      lines.push(`  ${skill.name}@${version} [${scope}]`);
+    }
+    lines.push('');
+  }
+  
+  return lines;
+}
+
+/**
+ * Uninstall a skill
+ * @param {string} skillName
+ * @param {InstalledSkillRegistry} registry
+ * @returns {Promise<boolean>} - true if uninstalled, false if not found
+ */
+export async function uninstallSkill(skillName, registry = new InstalledSkillRegistry()) {
+  const skill = await registry.find(skillName);
+  
+  if (!skill) {
+    return false;
+  }
+  
+  // Remove from filesystem
+  if (skill.targetPath) {
+    try {
+      await fs.rm(skill.targetPath, { recursive: true, force: true });
+    } catch (error) {
+      // Log but continue - we still want to remove from registry
+      console.warn(`Warning: Could not remove skill directory: ${error.message}`);
+    }
+  }
+  
+  // Remove from registry
+  await registry.remove(skillName);
+  
+  return true;
+}
+
+/**
+ * Update a skill by reinstalling from source
+ * @param {string} skillName
+ * @param {InstalledSkillRegistry} registry
+ * @returns {Promise<{success: boolean, message: string}>}
+ */
+export async function updateSkill(skillName, registry = new InstalledSkillRegistry()) {
+  const skill = await registry.find(skillName);
+  
+  if (!skill) {
+    return { success: false, message: 'Skill not installed' };
+  }
+  
+  if (!skill.sourcePath) {
+    return { success: false, message: 'Cannot update: source path not recorded' };
+  }
+  
+  try {
+    await fs.access(skill.sourcePath);
+  } catch {
+    return { success: false, message: 'Source no longer available' };
+  }
+  
+  // Reinstall
+  await copyDir(skill.sourcePath, skill.targetPath);
+  
+  // Update registry with new timestamp
+  await registry.add({
+    ...skill,
+    updatedAt: new Date().toISOString()
+  });
+  
+  return { success: true, message: 'Updated successfully' };
+}
+
+/**
+ * Copy directory recursively
+ * @param {string} src - Source directory
+ * @param {string} dest - Destination directory
+ */
+async function copyDir(src, dest) {
+  await fs.mkdir(dest, { recursive: true });
+  const entries = await fs.readdir(src, { withFileTypes: true });
+  
+  for (const entry of entries) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+    
+    if (entry.name === 'node_modules' || entry.name.startsWith('.')) continue;
+    
+    if (entry.isDirectory()) {
+      await copyDir(srcPath, destPath);
+    } else {
+      await fs.copyFile(srcPath, destPath);
+    }
+  }
+}