@haolin-ai/skillman 1.0.1

package/bin/skillman.mjs

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+/**
+ * Skillman - AI Agent Skill Installer
+ * 
+ * A CLI tool to install AI agent skills across multiple platforms.
+ */
+
+import { cli } from '../src/cli.js';
+
+cli().catch(err => {
+  console.error(`\x1b[31m✗\x1b[0m ${err.message}`);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@haolin-ai/skillman",
+  "version": "1.0.1",
+  "description": "A CLI tool to install AI agent skills across multiple platforms",
+  "type": "module",
+  "bin": {
+    "skillman": "./bin/skillman.mjs"
+  },
+  "files": [
+    "bin",
+    "src"
+  ],
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "cli",
+    "ai",
+    "agent",
+    "skills",
+    "installer"
+  ],
+  "author": "",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@inquirer/prompts": "^7.0.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/src/agents.yaml

@@ -0,0 +1,99 @@
+# Agent Configuration
+# Defines skill installation paths for each supported agent
+
+agents:
+  claude-code:
+    name: claude-code
+    displayName: Claude Code
+    skillsDir: .claude/skills
+    globalSkillsDir: ~/.claude/skills
+
+  openclaw:
+    name: openclaw
+    displayName: OpenClaw
+    skillsDir: skills
+    globalSkillsDir: ~/.openclaw/skills
+
+  qoder:
+    name: qoder
+    displayName: Qoder
+    skillsDir: .qoder/skills
+    globalSkillsDir: ~/.qoder/skills
+
+  codex:
+    name: codex
+    displayName: Codex
+    skillsDir: .agents/skills
+    globalSkillsDir: ~/.codex/skills
+
+  opencode:
+    name: opencode
+    displayName: OpenCode
+    skillsDir: .agents/skills
+    globalSkillsDir: ~/.config/opencode/skills
+
+  cursor:
+    name: cursor
+    displayName: Cursor
+    skillsDir: .agents/skills
+    globalSkillsDir: ~/.cursor/skills
+
+  cline:
+    name: cline
+    displayName: Cline
+    skillsDir: .agents/skills
+    globalSkillsDir: ~/.agents/skills
+
+  goose:
+    name: goose
+    displayName: Goose
+    skillsDir: .goose/skills
+    globalSkillsDir: ~/.config/goose/skills
+
+  continue:
+    name: continue
+    displayName: Continue
+    skillsDir: .continue/skills
+    globalSkillsDir: ~/.continue/skills
+
+  augment:
+    name: augment
+    displayName: Augment
+    skillsDir: .augment/skills
+    globalSkillsDir: ~/.augment/skills
+
+  github-copilot:
+    name: github-copilot
+    displayName: GitHub Copilot
+    skillsDir: .agents/skills
+    globalSkillsDir: ~/.copilot/skills
+
+  gemini-cli:
+    name: gemini-cli
+    displayName: Gemini CLI
+    skillsDir: .agents/skills
+    globalSkillsDir: ~/.gemini/skills
+
+  pi:
+    name: pi
+    displayName: Pi
+    skillsDir: .pi/skills
+    globalSkillsDir: ~/.pi/agent/skills
+
+  replit:
+    name: replit
+    displayName: Replit
+    skillsDir: .agents/skills
+    globalSkillsDir: ~/.config/agents/skills
+
+  roo:
+    name: roo
+    displayName: Roo Code
+    skillsDir: .roo/skills
+    globalSkillsDir: ~/.roo/skills
+
+  trae:
+    name: trae
+    displayName: Trae
+    skillsDir: .trae/skills
+    globalSkillsDir: ~/.trae/skills

package/src/cli.js

@@ -0,0 +1,306 @@
+/**
+ * CLI Entry Point
+ */
+
+import fs from 'fs/promises';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { select, confirm, input, Separator } from '@inquirer/prompts';
+import { scanSkills } from './scanner.js';
+import { installSkill } from './installer.js';
+import { loadAgents } from './config.js';
+import { t } from './i18n.js';
+import { loadHistory, addWorkspace } from './history.js';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const VERSION = '1.0.0';
+
+// ANSI colors
+const c = {
+  reset: '\x1b[0m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  red: '\x1b[31m',
+  blue: '\x1b[34m',
+  gray: '\x1b[90m',
+  cyan: '\x1b[36m'
+};
+
+const log = {
+  info: (msg) => console.log(`${c.blue}ℹ${c.reset} ${msg}`),
+  success: (msg) => console.log(`${c.green}✓${c.reset} ${msg}`),
+  warn: (msg) => console.log(`${c.yellow}⚠${c.reset} ${msg}`),
+  error: (msg) => console.log(`${c.red}✗${c.reset} ${msg}`),
+  step: (msg) => console.log(`\n${c.blue}▶${c.reset} ${msg}`),
+  dry: (msg) => console.log(`${c.yellow}[DRY-RUN]${c.reset} ${msg}`)
+};
+
+// Parse CLI arguments
+function parseArgs(args) {
+  const result = {
+    command: null,
+    dryRun: false,
+    help: false,
+    version: false,
+    positional: []
+  };
+
+  for (const arg of args) {
+    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;
+    } else if (!arg.startsWith('-')) {
+      if (!result.command) {
+        result.command = arg;
+      } else {
+        result.positional.push(arg);
+      }
+    }
+  }
+
+  return result;
+}
+
+// Show help
+function showHelp() {
+  console.log(`${c.green}${t('app.name')}${c.reset} - ${t('app.description')}
+
+${c.cyan}${t('help.usage')}:${c.reset}
+  skillman                    ${t('help.cmd.interactive')}
+  skillman install <path>     ${t('help.cmd.install')}
+  skillman agents             ${t('help.cmd.agents')}
+
+${c.cyan}${t('help.options')}:${c.reset}
+  -n, --dry-run    ${t('help.opt.dry_run')}
+  -v, --version    ${t('help.opt.version')}
+  -h, --help       ${t('help.opt.help')}
+
+${c.cyan}${t('help.examples')}:${c.reset}
+  skillman                     # ${t('help.cmd.interactive')}
+  skillman --dry-run           # ${t('help.opt.dry_run')}
+  skillman install ./my-skill  # ${t('help.cmd.install')}
+  skillman agents              # ${t('help.cmd.agents')}
+`);
+}
+
+// Show version
+function showVersion() {
+  console.log(`${t('app.name').toLowerCase()} v${VERSION}`);
+}
+
+// List agents
+async function listAgents() {
+  const agents = await loadAgents();
+  
+  console.log(`\n${c.cyan}${t('msg.agent')}:${c.reset}\n`);
+  
+  for (const [name, agent] of Object.entries(agents)) {
+    console.log(`  ${c.green}${agent.displayName}${c.reset} (${name})`);
+    console.log(`    ${t('option.global')}:    ${c.gray}${agent.globalSkillsDir}${c.reset}`);
+    console.log(`    ${t('option.workspace')}: ${c.gray}${agent.skillsDir}${c.reset}`);
+    console.log();
+  }
+}
+
+// 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`);
+
+  // Step 1: Scan skills
+  log.step(t('step.scan'));
+  
+  const skills = await scanSkills(process.cwd());
+  if (skills.length === 0) {
+    log.error(t('msg.no_skills'));
+    process.exit(1);
+  }
+
+  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 3: Select agent
+  const agents = await loadAgents();
+  const agentChoices = Object.values(agents).map(a => ({
+    name: a.displayName,
+    value: a
+  }));
+
+  const agent = await select({
+    message: t('step.select_agent') + ':',
+    choices: agentChoices,
+    pageSize: 10
+  });
+
+  log.success(`${t('msg.agent')}: ${agent.displayName}`);
+
+  // Step 4: Select scope
+  const scope = await select({
+    message: t('step.select_scope') + ':',
+    choices: [
+      { name: `${t('option.global')} ${c.gray}(${agent.globalSkillsDir})${c.reset}`, value: 'global' },
+      { name: `${t('option.workspace')} ${c.gray}(${t('option.custom_path')})${c.reset}`, value: 'workspace' }
+    ]
+  });
+
+  // Step 5: If workspace scope, ask for workspace path
+  let workspacePath = agent.skillsDir;
+  if (scope === 'workspace') {
+    const history = await loadHistory(agent.name);
+    
+    let customPath;
+    
+    if (history.length > 0) {
+      // Show history choices with separator
+      const historyChoices = [
+        ...history.map((h, idx) => ({
+          name: `${idx + 1}. ${h}`,
+          value: h
+        })),
+        new Separator(),
+        { name: t('prompt.new_path'), value: '__NEW__' }
+      ];
+      
+      const selected = await select({
+        message: t('prompt.select_workspace') + ':',
+        choices: historyChoices
+      });
+      
+      if (selected === '__NEW__') {
+        customPath = await input({
+          message: t('prompt.workspace_path') + ':',
+          default: process.cwd(),
+          validate: (value) => {
+            if (!value.trim()) return t('error.empty_path');
+            return true;
+          }
+        });
+      } else {
+        customPath = selected;
+      }
+    } else {
+      // No history, ask for input
+      customPath = await input({
+        message: t('prompt.workspace_path') + ':',
+        default: process.cwd(),
+        validate: (value) => {
+          if (!value.trim()) return t('error.empty_path');
+          return true;
+        }
+      });
+    }
+    
+    // Save to history (with agent name)
+    await addWorkspace(agent.name, customPath);
+    
+    // Extract relative skills directory from agent config
+    const skillsRelDir = agent.skillsDir.includes(path.sep)
+      ? agent.skillsDir.split(path.sep).slice(-2).join(path.sep)
+      : agent.skillsDir;
+    workspacePath = path.join(customPath.trim(), skillsRelDir);
+    log.info(`${t('msg.workspace_dir')}: ${workspacePath}`);
+  }
+
+  // Step 6: Calculate target path
+  const targetDir = scope === 'global'
+    ? path.join(agent.globalSkillsDir, selectedSkill.name)
+    : path.join(workspacePath, selectedSkill.name);
+
+  // Dry-run preview
+  if (dryRun) {
+    log.step(t('step.preview'));
+    log.dry(`${t('msg.source')}: ${selectedSkill.path}`);
+    log.dry(`${t('msg.target')}: ${targetDir}`);
+    
+    try {
+      await fs.access(targetDir);
+      log.dry(t('msg.exists'));
+    } catch {
+      log.dry(t('msg.not_exists'));
+    }
+    
+    log.dry(t('msg.copy'));
+    
+    console.log(`\n${c.yellow}📋 ${t('msg.preview_summary')}${c.reset}\n`);
+    console.log(`  Skill:    ${selectedSkill.name}`);
+    console.log(`  ${t('msg.agent')}:    ${agent.displayName}`);
+    console.log(`  ${t('msg.scope')}:    ${scope}`);
+    console.log(`  ${t('msg.location')}: ${targetDir}`);
+    console.log(`\n${c.gray}${t('msg.dry_run_hint')}${c.reset}\n`);
+    return;
+  }
+
+  // Step 6: Install
+  log.step(t('step.install'));
+  
+  // Check if already exists
+  try {
+    await fs.access(targetDir);
+    log.warn(t('msg.skill_exists'));
+    const overwrite = await confirm({ message: t('prompt.overwrite') + '?', default: false });
+    if (!overwrite) {
+      log.info(t('msg.install_cancelled'));
+      process.exit(0);
+    }
+  } catch {
+    // Directory doesn't exist, proceed
+  }
+
+  // Install
+  await installSkill(selectedSkill.path, targetDir);
+  log.success(`${t('msg.target')}: ${targetDir}`);
+
+  // Summary
+  console.log(`\n${c.green}✨ ${t('msg.install_complete')}${c.reset}\n`);
+  console.log(`  Skill:    ${selectedSkill.name}`);
+  console.log(`  ${t('msg.agent')}:    ${agent.displayName}`);
+  console.log(`  ${t('msg.scope')}:    ${scope}`);
+  console.log(`  ${t('msg.location')}: ${targetDir}`);
+  console.log();
+}
+
+// Main CLI function
+export async function cli() {
+  const args = process.argv.slice(2);
+  const options = parseArgs(args);
+
+  if (options.help) {
+    showHelp();
+    return;
+  }
+
+  if (options.version) {
+    showVersion();
+    return;
+  }
+
+  if (options.command === 'agents') {
+    await listAgents();
+    return;
+  }
+
+  if (options.command === 'install') {
+    log.error(t('error.not_implemented'));
+    process.exit(1);
+  }
+
+  // Default: interactive install
+  await interactiveInstall(options.dryRun);
+}

package/src/config.js

@@ -0,0 +1,82 @@
+/**
+ * Configuration Manager
+ * Loads and manages agent configurations
+ */
+
+import fs from 'fs/promises';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { homedir } from 'os';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const AGENTS_FILE = path.join(__dirname, 'agents.yaml');
+
+let agentsCache = null;
+
+/**
+ * Load agents configuration from YAML file
+ * @returns {Promise<Record<string, {name: string, displayName: string, skillsDir: string, globalSkillsDir: string}>>}
+ */
+export async function loadAgents() {
+  if (agentsCache) return agentsCache;
+  
+  try {
+    const content = await fs.readFile(AGENTS_FILE, 'utf-8');
+    const agents = {};
+    
+    const lines = content.split('\n');
+    let currentAgent = null;
+    
+    for (const line of lines) {
+      const trimmed = line.trim();
+      
+      if (!trimmed || trimmed.startsWith('#')) continue;
+      
+      // Detect agent entry (e.g., "claude-code:")
+      const agentMatch = line.match(/^(\s*)([\w-]+):\s*$/);
+      if (agentMatch && agentMatch[1].length === 2) {
+        currentAgent = agentMatch[2];
+        agents[currentAgent] = { name: currentAgent };
+        continue;
+      }
+      
+      // Parse properties
+      if (currentAgent) {
+        const propMatch = line.match(/^\s+([\w]+):\s*(.+)$/);
+        if (propMatch) {
+          const [, key, value] = propMatch;
+          let parsedValue = value.trim();
+          
+          // Remove quotes if present
+          if ((parsedValue.startsWith('"') && parsedValue.endsWith('"')) ||
+              (parsedValue.startsWith("'") && parsedValue.endsWith("'"))) {
+            parsedValue = parsedValue.slice(1, -1);
+          }
+          
+          // Expand ~ to home directory
+          if (parsedValue.startsWith('~/')) {
+            parsedValue = path.join(homedir(), parsedValue.slice(2));
+          }
+          
+          agents[currentAgent][key] = parsedValue;
+        }
+      }
+    }
+    
+    agentsCache = agents;
+    return agents;
+  } catch (err) {
+    console.error(`Failed to load agents: ${err.message}`);
+    return {};
+  }
+}
+
+/**
+ * Get a specific agent by name
+ * @param {string} name - Agent name
+ * @returns {Promise<object|null>}
+ */
+export async function getAgent(name) {
+  const agents = await loadAgents();
+  return agents[name] || null;
+}

package/src/history.js

@@ -0,0 +1,63 @@
+/**
+ * Workspace path history management
+ * Stores recently used workspace paths for quick selection
+ */
+
+import fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
+
+const HISTORY_FILE = path.join(os.homedir(), '.config', 'skillman', 'history.json');
+const MAX_HISTORY_SIZE = 10;
+
+async function ensureDir() {
+  const dir = path.dirname(HISTORY_FILE);
+  try {
+    await fs.access(dir);
+  } catch {
+    await fs.mkdir(dir, { recursive: true });
+  }
+}
+
+export async function loadHistory(agentName) {
+  try {
+    await ensureDir();
+    const data = await fs.readFile(HISTORY_FILE, 'utf8');
+    const history = JSON.parse(data);
+    return history[agentName]?.workspaces || [];
+  } catch {
+    return [];
+  }
+}
+
+export async function saveHistory(agentName, workspaces) {
+  await ensureDir();
+  let data = {};
+  try {
+    const existing = await fs.readFile(HISTORY_FILE, 'utf8');
+    data = JSON.parse(existing);
+  } catch {
+    // File doesn't exist or is invalid
+  }
+  
+  data[agentName] = {
+    workspaces: workspaces.slice(0, MAX_HISTORY_SIZE),
+    updatedAt: new Date().toISOString()
+  };
+  
+  await fs.writeFile(HISTORY_FILE, JSON.stringify(data, null, 2));
+}
+
+export async function addWorkspace(agentName, workspacePath) {
+  const normalized = path.resolve(workspacePath);
+  let workspaces = await loadHistory(agentName);
+  
+  // Remove if exists (to move to front)
+  workspaces = workspaces.filter(w => path.resolve(w) !== normalized);
+  
+  // Add to front
+  workspaces.unshift(normalized);
+  
+  await saveHistory(agentName, workspaces);
+  return workspaces;
+}

package/src/i18n.js

@@ -0,0 +1,160 @@
+/**
+ * Internationalization (i18n) module
+ * Supports Chinese (zh) and English (en)
+ */
+
+import { execSync } from 'child_process';
+
+// Detect system language
+function detectLanguage() {
+  try {
+    const locale = process.env.LANG || 
+                   process.env.LC_ALL || 
+                   process.env.LC_MESSAGES ||
+                   execSync('defaults read -g AppleLanguages 2>/dev/null || echo "en"', { encoding: 'utf8' }).trim();
+    
+    if (locale.toLowerCase().includes('zh')) {
+      return 'zh';
+    }
+  } catch {
+    // Fallback to English on error
+  }
+  return 'en';
+}
+
+const lang = detectLanguage();
+
+const translations = {
+  zh: {
+    // Common
+    'app.name': 'Skillman',
+    'app.description': 'AI Agent Skill 安装器',
+    'version': '版本',
+    
+    // Steps
+    'step.scan': '扫描可安装的 Skills...',
+    'step.select_skill': '选择要安装的 Skill',
+    'step.select_agent': '选择目标 Agent',
+    'step.select_scope': '选择安装范围',
+    'step.install': '开始安装...',
+    'step.preview': '预览安装...',
+    
+    // Messages
+    'msg.found_skills': '找到 {count} 个 skill',
+    'msg.no_skills': '当前目录未找到任何 skill (需要包含 SKILL.md 的文件夹)',
+    'msg.selected': '选择',
+    'msg.agent': 'Agent',
+    'msg.scope': '范围',
+    'msg.location': '位置',
+    'msg.source': '源目录',
+    'msg.target': '目标目录',
+    'msg.exists': '目标已存在，将覆盖',
+    'msg.not_exists': '目标不存在，将创建',
+    'msg.copy': '将复制 skill 文件夹到目标位置',
+    'msg.workspace_dir': 'Workspace skills 目录',
+    'msg.install_complete': '安装完成!',
+    'msg.preview_summary': '预览摘要',
+    'msg.dry_run_hint': '使用 --dry-run 预览，未执行任何操作',
+    'msg.skill_exists': '该 skill 已存在',
+    'msg.install_cancelled': '安装已取消',
+    
+    // Prompts
+    'prompt.workspace_path': '输入 Workspace 路径',
+    'prompt.overwrite': '是否覆盖',
+    'prompt.select_workspace': '选择 Workspace 路径',
+    'prompt.new_path': '输入新路径...',
+    
+    // Options
+    'option.global': '全局',
+    'option.workspace': '工作区',
+    'option.custom_path': '自定义路径',
+    
+    // Errors
+    'error.empty_path': '路径不能为空',
+    'error.not_implemented': '该命令尚未实现，请使用交互模式',
+    
+    // Help
+    'help.usage': '用法',
+    'help.options': '选项',
+    'help.examples': '示例',
+    'help.cmd.interactive': '交互式安装 (扫描当前目录)',
+    'help.cmd.install': '从指定路径安装 skill',
+    'help.cmd.agents': '列出可用的 agents',
+    'help.opt.dry_run': '预览安装而不执行更改',
+    'help.opt.version': '显示版本号',
+    'help.opt.help': '显示帮助信息',
+  },
+  
+  en: {
+    // Common
+    'app.name': 'Skillman',
+    'app.description': 'AI Agent Skill Installer',
+    'version': 'Version',
+    
+    // Steps
+    'step.scan': 'Scanning available skills...',
+    'step.select_skill': 'Select skill to install',
+    'step.select_agent': 'Select target agent',
+    'step.select_scope': 'Select installation scope',
+    'step.install': 'Starting installation...',
+    'step.preview': 'Previewing installation...',
+    
+    // Messages
+    'msg.found_skills': 'Found {count} skill(s)',
+    'msg.no_skills': 'No skills found in current directory (folders with SKILL.md required)',
+    'msg.selected': 'Selected',
+    'msg.agent': 'Agent',
+    'msg.scope': 'Scope',
+    'msg.location': 'Location',
+    'msg.source': 'Source',
+    'msg.target': 'Target',
+    'msg.exists': 'Target exists, will overwrite',
+    'msg.not_exists': 'Target does not exist, will create',
+    'msg.copy': 'Will copy skill folder to target location',
+    'msg.workspace_dir': 'Workspace skills directory',
+    'msg.install_complete': 'Installation complete!',
+    'msg.preview_summary': 'Preview Summary',
+    'msg.dry_run_hint': 'Running with --dry-run, no changes made',
+    'msg.skill_exists': 'Skill already exists',
+    'msg.install_cancelled': 'Installation cancelled',
+    
+    // Prompts
+    'prompt.workspace_path': 'Enter workspace path',
+    'prompt.overwrite': 'Overwrite existing',
+    'prompt.select_workspace': 'Select workspace path',
+    'prompt.new_path': 'Enter new path...',
+    
+    // Options
+    'option.global': 'Global',
+    'option.workspace': 'Workspace',
+    'option.custom_path': 'Custom path',
+    
+    // Errors
+    'error.empty_path': 'Path cannot be empty',
+    'error.not_implemented': 'Command not implemented, use interactive mode',
+    
+    // Help
+    'help.usage': 'Usage',
+    'help.options': 'Options',
+    'help.examples': 'Examples',
+    'help.cmd.interactive': 'Interactive install (scan current directory)',
+    'help.cmd.install': 'Install skill from path',
+    'help.cmd.agents': 'List available agents',
+    'help.opt.dry_run': 'Preview installation without making changes',
+    'help.opt.version': 'Show version number',
+    'help.opt.help': 'Show this help message',
+  }
+};
+
+export function t(key, vars = {}) {
+  const text = translations[lang][key] || translations['en'][key] || key;
+  return text.replace(/\{(\w+)\}/g, (match, varName) => vars[varName] ?? match);
+}
+
+export function getLanguage() {
+  return lang;
+}
+
+export function isChinese() {
+  return lang === 'zh';
+}

package/src/index.js

@@ -0,0 +1,7 @@
+/**
+ * Skillman Core Module
+ */
+
+export { scanSkills } from './scanner.js';
+export { installSkill } from './installer.js';
+export { loadAgents, getAgent } from './config.js';

package/src/installer.js

@@ -0,0 +1,40 @@
+/**
+ * Skill Installer
+ * Copies skill files to target location
+ */
+
+import fs from 'fs/promises';
+import path from 'path';
+
+/**
+ * Install skill by copying to target directory
+ * @param {string} srcPath - Source skill directory
+ * @param {string} targetDir - Target installation directory
+ */
+export async function installSkill(srcPath, targetDir) {
+  await copyDir(srcPath, targetDir);
+}
+
+/**
+ * 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);
+    
+    // Skip node_modules and hidden files
+    if (entry.name === 'node_modules' || entry.name.startsWith('.')) continue;
+    
+    if (entry.isDirectory()) {
+      await copyDir(srcPath, destPath);
+    } else {
+      await fs.copyFile(srcPath, destPath);
+    }
+  }
+}

package/src/scanner.js

@@ -0,0 +1,48 @@
+/**
+ * Skill Scanner
+ * Scans a directory for installable skills (folders with SKILL.md)
+ */
+
+import fs from 'fs/promises';
+import path from 'path';
+
+/**
+ * Scan directory for skills
+ * @param {string} dir - Directory to scan
+ * @returns {Promise<Array<{name: string, path: string, description: string}>>}
+ */
+export async function scanSkills(dir) {
+  const skills = [];
+  
+  try {
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+    
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      if (entry.name.startsWith('.') || entry.name === 'node_modules') continue;
+      
+      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
+      }
+    }
+  } catch (err) {
+    // Directory read error
+  }
+  
+  return skills;
+}