@haolin-ai/skillman 1.0.1 → 1.0.3

package/README.md

@@ -0,0 +1,102 @@
+# Skillman
+
+A CLI tool to install AI agent skills across multiple platforms.
+
+## Installation
+
+```bash
+npm install -g @haolin-ai/skillman
+```
+
+## Usage
+
+### Interactive Mode (Recommended)
+
+Run without arguments to start the interactive installation wizard:
+
+```bash
+skillman
+```
+
+This will guide you through:
+1. Scanning available skills in the current directory
+2. Selecting a skill to install
+3. Choosing the target agent (Claude Code, OpenClaw, Qoder, etc.)
+4. Selecting installation scope (global or workspace)
+5. Confirming the installation
+
+### Install from URL
+
+Install skills directly from GitHub or any git repository:
+
+```bash
+# GitHub shorthand
+skillman install vercel-labs/agent-skills
+
+# Full GitHub URL
+skillman install https://github.com/vercel-labs/agent-skills
+
+# With subdirectory
+skillman install https://github.com/vercel-labs/agent-skills/tree/main/skills/web-design
+
+# GitLab or other git URLs
+skillman install https://gitlab.com/org/repo
+skillman install git@github.com:org/repo.git
+```
+
+### Commands
+
+```bash
+# List all available agents
+skillman agents
+
+# Preview installation without making changes
+skillman --dry-run
+
+# Show help
+skillman --help
+
+# Show version
+skillman --version
+```
+
+## Features
+
+- **Multi-Agent Support**: Works with Claude Code, OpenClaw, Qoder, Codex, Cursor, and more
+- **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
+- **Smart Path Resolution**: Automatically resolves relative paths to absolute paths
+
+## Configuration
+
+Agent configurations are stored in `src/agents.yaml`. Each agent has:
+- `globalSkillsDir`: Global skills directory (usually in home directory)
+- `skillsDir`: Relative path for workspace-specific skills
+
+## Workspace History
+
+When installing to a workspace scope, Skillman remembers your paths in:
+```
+~/.config/skillman/history.json
+```
+
+History is organized by agent, so each agent has its own list of recently used workspaces.
+
+## Development
+
+```bash
+# Clone the repository
+git clone <repo-url>
+cd skillman
+
+# Install dependencies
+pnpm install
+
+# Run locally
+node bin/skillman.mjs
+```
+
+## License
+
+MIT

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@haolin-ai/skillman",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "A CLI tool to install AI agent skills across multiple platforms",
   "type": "module",
   "bin": {

package/src/cli.js

@@ -5,15 +5,26 @@
 import fs from 'fs/promises';
 import path from 'path';
 import { fileURLToPath } from 'url';
-import { select, confirm, input, Separator } from '@inquirer/prompts';
+import { select, confirm, input, Separator, checkbox } 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';
+import { loadHistory, addWorkspace, saveLastUsed } from './history.js';
+import { downloadSkill, parseUrl, cleanupDownloads } from './downloader.js';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const VERSION = '1.0.0';
+
+// Read version from package.json
+let VERSION = '1.0.0';
+try {
+  const pkgPath = path.join(__dirname, '..', 'package.json');
+  const pkgContent = await fs.readFile(pkgPath, 'utf8');
+  const pkg = JSON.parse(pkgContent);
+  VERSION = pkg.version || '1.0.0';
+} catch {
+  // Fallback to default version
+}
 
 // ANSI colors
 const c = {
@@ -71,6 +82,7 @@ function showHelp() {
 ${c.cyan}${t('help.usage')}:${c.reset}
   skillman                    ${t('help.cmd.interactive')}
   skillman install <path>     ${t('help.cmd.install')}
+  skillman i <path>           ${t('help.cmd.install')}
   skillman agents             ${t('help.cmd.agents')}
 
 ${c.cyan}${t('help.options')}:${c.reset}
@@ -82,6 +94,7 @@ ${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 i github.com/owner/repo  # ${t('help.cmd.install')}
   skillman agents              # ${t('help.cmd.agents')}
 `);
 }
@@ -105,14 +118,32 @@ async function listAgents() {
   }
 }
 
-// Interactive install flow
-async function interactiveInstall(dryRun) {
+// Install from URL or local path
+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`);
 
-  // Step 1: Scan skills
+  const parsed = parseUrl(url);
+  const isRemote = parsed.type !== 'local';
+
+  // Step 1: Download/resolve path
+  let sourcePath;
+  if (isRemote) {
+    log.step(t('msg.downloading') || 'Downloading...');
+    try {
+      sourcePath = await downloadSkill(url);
+      log.success(t('msg.downloaded') || 'Downloaded');
+    } catch (error) {
+      log.error(error.message);
+      process.exit(1);
+    }
+  } else {
+    sourcePath = url;
+  }
+
+  // Step 2: Scan skills
   log.step(t('step.scan'));
+  const skills = await scanSkills(sourcePath);
   
-  const skills = await scanSkills(process.cwd());
   if (skills.length === 0) {
     log.error(t('msg.no_skills'));
     process.exit(1);
@@ -120,25 +151,57 @@ 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
-  }));
+  // 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;
+      }
+    });
 
-  const selectedSkill = await select({
-    message: t('step.select_skill') + ':',
-    choices: skillChoices,
-    pageSize: 10
-  });
+    log.success(`${t('msg.selected_count', { count: selectedSkills.length })}`);
+  }
 
-  log.success(`${t('msg.selected')}: ${selectedSkill.name}`);
+  // Continue with rest of interactive flow
+  await continueInstallMultiple(selectedSkills, dryRun);
 
-  // Step 3: Select agent
+  // Cleanup temp downloads
+  if (isRemote) {
+    await cleanupDownloads();
+  }
+}
+
+// Continue installation after skill selection (multiple skills)
+async function continueInstallMultiple(selectedSkills, dryRun) {
+  // Load last used preferences
+  const { lastAgent, lastScope } = await loadHistory();
   const agents = await loadAgents();
-  const agentChoices = Object.values(agents).map(a => ({
+  
+  // Step 4: Select agent (with default from history)
+  const agentList = Object.values(agents);
+  const defaultAgentIndex = lastAgent 
+    ? agentList.findIndex(a => a.name === lastAgent)
+    : -1;
+  
+  const agentChoices = agentList.map(a => ({
     name: a.displayName,
     value: a
   }));
@@ -146,31 +209,42 @@ async function interactiveInstall(dryRun) {
   const agent = await select({
     message: t('step.select_agent') + ':',
     choices: agentChoices,
-    pageSize: 10
+    pageSize: 10,
+    default: defaultAgentIndex >= 0 ? agentChoices[defaultAgentIndex].value : undefined
   });
 
   log.success(`${t('msg.agent')}: ${agent.displayName}`);
 
-  // Step 4: Select scope
+  // Step 5: Select scope (with default from history)
+  const scopeChoices = [
+    { 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' }
+  ];
+  
+  const defaultScopeIndex = lastScope 
+    ? scopeChoices.findIndex(s => s.value === lastScope)
+    : -1;
+
   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' }
-    ]
+    choices: scopeChoices,
+    default: defaultScopeIndex >= 0 ? scopeChoices[defaultScopeIndex].value : undefined
   });
 
-  // Step 5: If workspace scope, ask for workspace path
+  // Save preferences for next time
+  await saveLastUsed(agent.name, scope);
+
+  // Step 6: If workspace scope, ask for workspace path
   let workspacePath = agent.skillsDir;
   if (scope === 'workspace') {
-    const history = await loadHistory(agent.name);
+    const { workspaces } = await loadHistory(agent.name);
     
     let customPath;
     
-    if (history.length > 0) {
+    if (workspaces.length > 0) {
       // Show history choices with separator
       const historyChoices = [
-        ...history.map((h, idx) => ({
+        ...workspaces.map((h, idx) => ({
           name: `${idx + 1}. ${h}`,
           value: h
         })),
@@ -218,64 +292,116 @@ async function interactiveInstall(dryRun) {
     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
+  // Dry-run preview for all skills
   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'));
+    for (const skill of selectedSkills) {
+      const targetDir = scope === 'global'
+        ? path.join(agent.globalSkillsDir, skill.name)
+        : path.join(workspacePath, skill.name);
+      
+      log.dry(`\n${skill.name}:`);
+      log.dry(`  ${t('msg.source')}: ${skill.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.selected_count', { count: selectedSkills.length })}`);
     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
+  // Step 8: Install all skills
   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);
+  let installedCount = 0;
+  let skippedCount = 0;
+  
+  for (const skill of selectedSkills) {
+    const targetDir = scope === 'global'
+      ? path.join(agent.globalSkillsDir, skill.name)
+      : path.join(workspacePath, skill.name);
+    
+    log.step(`${t('msg.installing') || 'Installing'}: ${skill.name}`);
+    
+    // Check if already exists
+    let shouldInstall = true;
+    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.skipped') || 'Skipped');
+        skippedCount++;
+        shouldInstall = false;
+      }
+    } catch {
+      // Directory doesn't exist, proceed
+    }
+    
+    if (shouldInstall) {
+      await installSkill(skill.path, targetDir);
+      log.success(`${t('msg.target')}: ${targetDir}`);
+      installedCount++;
     }
-  } 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.installed') || 'Installed'}: ${installedCount}`);
+  if (skippedCount > 0) {
+    console.log(`  ${t('msg.skipped') || 'Skipped'}: ${skippedCount}`);
+  }
   console.log(`  ${t('msg.agent')}:    ${agent.displayName}`);
   console.log(`  ${t('msg.scope')}:    ${scope}`);
-  console.log(`  ${t('msg.location')}: ${targetDir}`);
   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}`);
+
+  // Continue with agent selection and installation
+  await continueInstall(selectedSkill, dryRun);
+}
+
 // Main CLI function
 export async function cli() {
   const args = process.argv.slice(2);
@@ -296,9 +422,10 @@ export async function cli() {
     return;
   }
 
-  if (options.command === 'install') {
-    log.error(t('error.not_implemented'));
-    process.exit(1);
+  if (options.command === 'install' || options.command === 'i') {
+    const url = options.positional[0] || process.cwd();
+    await installFromUrl(url, options.dryRun);
+    return;
   }
 
   // Default: interactive install

package/src/downloader.js

@@ -0,0 +1,122 @@
+/**
+ * URL downloader for remote skill installation
+ * Supports GitHub shorthand, full URLs, and git URLs
+ */
+
+import { execSync } from 'child_process';
+import fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
+
+const TEMP_DIR = path.join(os.tmpdir(), 'skillman-downloads');
+
+/**
+ * Parse URL to determine type and extract info
+ * @param {string} url - Input URL or shorthand
+ * @returns {Object} { type, url, subPath }
+ */
+export function parseUrl(url) {
+  // GitHub shorthand: owner/repo or owner/repo/path
+  if (/^[\w-]+\/[\w-]+/.test(url) && !url.includes('://') && !url.startsWith('git@')) {
+    const parts = url.split('/');
+    if (parts.length === 2) {
+      return { type: 'github', url: `https://github.com/${url}.git`, subPath: null };
+    } else if (parts.length >= 3) {
+      // owner/repo/sub/path
+      return { 
+        type: 'github', 
+        url: `https://github.com/${parts[0]}/${parts[1]}.git`, 
+        subPath: parts.slice(2).join('/') 
+      };
+    }
+  }
+
+  // Full GitHub URL with tree/main/path
+  const treeMatch = url.match(/github\.com\/([^\/]+)\/([^\/]+)\/tree\/[^\/]+\/(.+)/);
+  if (treeMatch) {
+    return { 
+      type: 'github', 
+      url: `https://github.com/${treeMatch[1]}/${treeMatch[2]}.git`, 
+      subPath: treeMatch[3] 
+    };
+  }
+
+  // Regular git URLs
+  if (url.startsWith('https://') || url.startsWith('git@') || url.startsWith('http://')) {
+    // Remove .git suffix if present for consistency
+    const cleanUrl = url.replace(/\.git$/, '');
+    return { type: 'git', url: cleanUrl + '.git', subPath: null };
+  }
+
+  // Local path
+  return { type: 'local', url, subPath: null };
+}
+
+/**
+ * Download skill from URL
+ * @param {string} inputUrl - URL or shorthand
+ * @returns {Promise<string>} Path to downloaded skill directory
+ */
+export async function downloadSkill(inputUrl) {
+  const parsed = parseUrl(inputUrl);
+  
+  if (parsed.type === 'local') {
+    return parsed.url;
+  }
+
+  // Create temp directory
+  await fs.mkdir(TEMP_DIR, { recursive: true });
+  
+  // Generate unique directory name
+  const repoName = path.basename(parsed.url, '.git');
+  const timestamp = Date.now();
+  const downloadDir = path.join(TEMP_DIR, `${repoName}-${timestamp}`);
+
+  try {
+    // Clone repository
+    execSync(`git clone --depth 1 "${parsed.url}" "${downloadDir}"`, {
+      stdio: 'pipe',
+      timeout: 60000
+    });
+
+    // If subPath specified, return that subdirectory
+    if (parsed.subPath) {
+      const subDir = path.join(downloadDir, parsed.subPath);
+      try {
+        await fs.access(subDir);
+        return subDir;
+      } catch {
+        throw new Error(`Subdirectory not found: ${parsed.subPath}`);
+      }
+    }
+
+    return downloadDir;
+  } catch (error) {
+    // Cleanup on failure
+    try {
+      await fs.rm(downloadDir, { recursive: true, force: true });
+    } catch {}
+    throw new Error(`Failed to download: ${error.message}`);
+  }
+}
+
+/**
+ * Clean up old downloads
+ */
+export async function cleanupDownloads() {
+  try {
+    const entries = await fs.readdir(TEMP_DIR);
+    const now = Date.now();
+    const oneHour = 60 * 60 * 1000;
+
+    for (const entry of entries) {
+      const entryPath = path.join(TEMP_DIR, entry);
+      try {
+        const stats = await fs.stat(entryPath);
+        if (now - stats.mtime.getTime() > oneHour) {
+          await fs.rm(entryPath, { recursive: true, force: true });
+        }
+      } catch {}
+    }
+  } catch {}
+}

package/src/history.js

@@ -24,9 +24,13 @@ export async function loadHistory(agentName) {
     await ensureDir();
     const data = await fs.readFile(HISTORY_FILE, 'utf8');
     const history = JSON.parse(data);
-    return history[agentName]?.workspaces || [];
+    return {
+      workspaces: history[agentName]?.workspaces || [],
+      lastAgent: history.lastAgent || null,
+      lastScope: history.lastScope || null
+    };
   } catch {
-    return [];
+    return { workspaces: [], lastAgent: null, lastScope: null };
   }
 }
 
@@ -48,16 +52,34 @@ export async function saveHistory(agentName, workspaces) {
   await fs.writeFile(HISTORY_FILE, JSON.stringify(data, null, 2));
 }
 
+export async function saveLastUsed(agentName, scope) {
+  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
+  }
+  
+  if (agentName) data.lastAgent = agentName;
+  if (scope) data.lastScope = scope;
+  data.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);
+  const { workspaces } = await loadHistory(agentName);
+  let newWorkspaces = [...workspaces];
   
   // Remove if exists (to move to front)
-  workspaces = workspaces.filter(w => path.resolve(w) !== normalized);
+  newWorkspaces = newWorkspaces.filter(w => path.resolve(w) !== normalized);
   
   // Add to front
-  workspaces.unshift(normalized);
+  newWorkspaces.unshift(normalized);
   
-  await saveHistory(agentName, workspaces);
-  return workspaces;
+  await saveHistory(agentName, newWorkspaces);
+  return newWorkspaces;
 }

package/src/i18n.js

@@ -34,6 +34,7 @@ const translations = {
     // Steps
     'step.scan': '扫描可安装的 Skills...',
     'step.select_skill': '选择要安装的 Skill',
+    'step.select_skills': '选择要安装的 Skills（空格选择，回车确认）',
     'step.select_agent': '选择目标 Agent',
     'step.select_scope': '选择安装范围',
     'step.install': '开始安装...',
@@ -43,6 +44,7 @@ const translations = {
     'msg.found_skills': '找到 {count} 个 skill',
     'msg.no_skills': '当前目录未找到任何 skill (需要包含 SKILL.md 的文件夹)',
     'msg.selected': '选择',
+    'msg.selected_count': '已选择 {count} 个',
     'msg.agent': 'Agent',
     'msg.scope': '范围',
     'msg.location': '位置',
@@ -57,6 +59,11 @@ const translations = {
     'msg.dry_run_hint': '使用 --dry-run 预览，未执行任何操作',
     'msg.skill_exists': '该 skill 已存在',
     'msg.install_cancelled': '安装已取消',
+    'msg.downloading': '正在下载...',
+    'msg.downloaded': '下载完成',
+    'msg.installing': '正在安装',
+    'msg.skipped': '已跳过',
+    'msg.installed': '已安装',
     
     // Prompts
     'prompt.workspace_path': '输入 Workspace 路径',
@@ -72,6 +79,7 @@ const translations = {
     // Errors
     'error.empty_path': '路径不能为空',
     'error.not_implemented': '该命令尚未实现，请使用交互模式',
+    'error.no_selection': '请至少选择一个 skill',
     
     // Help
     'help.usage': '用法',
@@ -94,6 +102,7 @@ const translations = {
     // Steps
     'step.scan': 'Scanning available skills...',
     'step.select_skill': 'Select skill to install',
+    'step.select_skills': 'Select skills to install (space to select, enter to confirm)',
     'step.select_agent': 'Select target agent',
     'step.select_scope': 'Select installation scope',
     'step.install': 'Starting installation...',
@@ -103,6 +112,7 @@ const translations = {
     '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.selected_count': 'Selected {count}',
     'msg.agent': 'Agent',
     'msg.scope': 'Scope',
     'msg.location': 'Location',
@@ -117,6 +127,11 @@ const translations = {
     'msg.dry_run_hint': 'Running with --dry-run, no changes made',
     'msg.skill_exists': 'Skill already exists',
     'msg.install_cancelled': 'Installation cancelled',
+    'msg.downloading': 'Downloading...',
+    'msg.downloaded': 'Downloaded',
+    'msg.installing': 'Installing',
+    'msg.skipped': 'Skipped',
+    'msg.installed': 'Installed',
     
     // Prompts
     'prompt.workspace_path': 'Enter workspace path',
@@ -132,6 +147,7 @@ const translations = {
     // Errors
     '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',
     
     // Help
     'help.usage': 'Usage',

package/src/scanner.js

@@ -1,17 +1,21 @@
 /**
  * Skill Scanner
  * Scans a directory for installable skills (folders with SKILL.md)
+ * Also checks common skill subdirectories like 'skills/'
  */
 
 import fs from 'fs/promises';
 import path from 'path';
 
+// Common skill container directories
+const SKILL_CONTAINERS = ['skills', '.agents/skills', '.claude/skills'];
+
 /**
- * Scan directory for skills
+ * Scan a single directory for skills
  * @param {string} dir - Directory to scan
- * @returns {Promise<Array<{name: string, path: string, description: string}>>}
+ * @returns {Promise<Array>} Found skills
  */
-export async function scanSkills(dir) {
+async function scanSingleDir(dir) {
   const skills = [];
   
   try {
@@ -40,9 +44,38 @@ export async function scanSkills(dir) {
         // No SKILL.md or parse error, skip
       }
     }
-  } catch (err) {
+  } catch {
     // Directory read error
   }
   
   return skills;
 }
+
+/**
+ * Scan directory for skills
+ * @param {string} dir - Directory to scan
+ * @returns {Promise<Array<{name: string, path: string, description: string}>>}
+ */
+export async function scanSkills(dir) {
+  // First scan root directory
+  const skills = await scanSingleDir(dir);
+  if (skills.length > 0) {
+    return skills;
+  }
+  
+  // If no skills found, check common skill container directories
+  for (const container of SKILL_CONTAINERS) {
+    const containerPath = path.join(dir, container);
+    try {
+      await fs.access(containerPath);
+      const containerSkills = await scanSingleDir(containerPath);
+      if (containerSkills.length > 0) {
+        return containerSkills;
+      }
+    } catch {
+      // Container doesn't exist, skip
+    }
+  }
+  
+  return [];
+}