joyskills-cli 0.2.6 → 0.2.7

package/src/commands/list.js

@@ -1,8 +1,39 @@
-import { LocalManager } from '../local.js';
 import { RegistryManager } from '../registry.js';
 import { LockfileManager } from '../lockfile.js';
 import * as path from 'path';
 import * as fs from 'fs';
+import * as os from 'os';
+import chalk from 'chalk';
+
+/** Scan all standard skill directories and return unique skill names */
+function scanAllSkillDirs(projectRoot) {
+  const dirs = [
+    path.join(projectRoot, '.agent', 'skills'),
+    path.join(projectRoot, '.claude', 'skills'),
+    path.join(os.homedir(), '.agent', 'skills'),
+    path.join(os.homedir(), '.claude', 'skills'),
+    path.join(projectRoot, 'skills'), // legacy
+  ];
+  const seen = new Set();
+  const skills = [];
+  for (const dir of dirs) {
+    if (!fs.existsSync(dir)) continue;
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+      if (entry.isDirectory() && !seen.has(entry.name)) {
+        seen.add(entry.name);
+        const skillMd = path.join(dir, entry.name, 'SKILL.md');
+        let description = '', version = '';
+        if (fs.existsSync(skillMd)) {
+          const content = fs.readFileSync(skillMd, 'utf-8');
+          description = (content.match(/description:\s*(.+)/) || [])[1]?.trim() || '';
+          version = (content.match(/version:\s*(.+)/) || [])[1]?.trim() || '';
+        }
+        skills.push({ name: entry.name, dir, description, version });
+      }
+    }
+  }
+  return skills;
+}
 
 export function listCommand(program) {
   program
@@ -16,42 +47,40 @@ export function listCommand(program) {
     .option('-r, --registry <name>', 'Show skills from specific registry')
     .action(async (options) => {
       const projectRoot = process.cwd();
-      const localManager = new LocalManager(projectRoot);
       const lockfileManager = new LockfileManager(projectRoot);
 
-      console.log('Available Skills:');
-      console.log('=================');
+      console.log(chalk.blue('Available Skills:'));
+      console.log(chalk.gray('================='));
 
       try {
-        // Load lockfile to know what's installed
         await lockfileManager.load();
         const installedSkills = lockfileManager.lockData.skills;
 
-        // List local skills
-        const localSkills = localManager.listSkills();
+        // Scan all skill directories
+        const localSkills = scanAllSkillDirs(projectRoot);
 
         if (!options.registry) {
-          // Show local skills if requested or if local-only mode
-          if (options.local || localSkills.length > 0) {
-            console.log('\nLocal Skills:');
-            const filteredLocalSkills = localSkills.filter(skill => {
-              if (options.installed && !installedSkills[skill]) return false;
-              if (options.search) {
-                const query = options.search.toLowerCase();
-                return skill.toLowerCase().includes(query);
-              }
-              return true;
-            });
-
-            if (filteredLocalSkills.length > 0) {
-              filteredLocalSkills.forEach(skill => {
-                const isInstalled = installedSkills[skill] ? '✅' : '  ';
-                const version = installedSkills[skill] ? `v${installedSkills[skill].version}` : '';
-                console.log(`  ${isInstalled} ${skill} ${version}`);
+          if (localSkills.length > 0) {
+            console.log(chalk.blue('\nInstalled Skills:'));
+            let filtered = localSkills;
+            if (options.search) {
+              const q = options.search.toLowerCase();
+              filtered = filtered.filter(s => s.name.toLowerCase().includes(q) || s.description.toLowerCase().includes(q));
+            }
+            if (filtered.length > 0) {
+              filtered.forEach(skill => {
+                const lock = installedSkills[skill.name];
+                const ver = lock ? chalk.gray(`v${lock.version}`) : (skill.version ? chalk.gray(`v${skill.version}`) : '');
+                const src = lock ? chalk.gray(`[${lock.source}]`) : '';
+                console.log(`  ✅ ${chalk.bold(skill.name)} ${ver} ${src}`);
+                if (skill.description) console.log(`     ${chalk.gray(skill.description)}`);
               });
             } else {
-              console.log('  No matching local skills found.');
+              console.log('  No matching skills found.');
             }
+          } else {
+            console.log(chalk.yellow('\n  No skills installed.'));
+            console.log(chalk.gray('  Run: joySkills install <skill>'));
           }
         }
 

package/src/commands/manage.js

@@ -0,0 +1,102 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { checkbox, confirm } from '@inquirer/prompts';
+import chalk from 'chalk';
+import { LockfileManager } from '../lockfile.js';
+
+export function manageCommand(program) {
+  program
+    .command('manage')
+    .description('Interactively manage (remove) installed skills')
+    .option('-g, --global', 'Manage global ~/.claude/skills')
+    .option('--universal', 'Manage .agent/skills/')
+    .option('-y, --yes', 'Skip confirmation')
+    .action(async (options) => {
+      try {
+        const projectRoot = process.cwd();
+
+        // Determine which dirs to scan
+        const dirsToScan = options.global
+          ? [path.join(os.homedir(), '.claude', 'skills')]
+          : options.universal
+            ? [path.join(projectRoot, '.agent', 'skills')]
+            : [
+                path.join(projectRoot, '.agent', 'skills'),
+                path.join(projectRoot, '.claude', 'skills'),
+              ];
+
+        // Collect skills from all relevant dirs
+        const seen = new Set();
+        const skills = [];
+        for (const skillsDir of dirsToScan) {
+          if (!fs.existsSync(skillsDir)) continue;
+          for (const entry of fs.readdirSync(skillsDir, { withFileTypes: true })) {
+            if (!entry.isDirectory() || seen.has(entry.name)) continue;
+            seen.add(entry.name);
+            const skillPath = path.join(skillsDir, entry.name);
+            const skillMd = path.join(skillPath, 'SKILL.md');
+            let description = '';
+            if (fs.existsSync(skillMd)) {
+              const content = fs.readFileSync(skillMd, 'utf-8');
+              description = (content.match(/description:\s*(.+)/) || [])[1]?.trim() || '';
+            }
+            skills.push({ name: entry.name, path: skillPath, description });
+          }
+        }
+
+        if (skills.length === 0) {
+          console.log(chalk.yellow('⚠️  No skills installed'));
+          return;
+        }
+
+        let toRemove;
+        if (options.yes) {
+          // -y: remove all without interaction
+          toRemove = skills;
+          console.log(chalk.blue(`\n📦 Removing all ${skills.length} skill(s) (--yes mode):`));
+          for (const s of toRemove) console.log(`   - ${s.name}`);
+        } else {
+          console.log(chalk.blue(`\n📦 Installed skills:`));
+
+          const choices = skills.map(s => ({
+            name: s.description ? `${s.name} — ${chalk.gray(s.description)}` : s.name,
+            value: s,
+            checked: false
+          }));
+
+          toRemove = await checkbox({
+            message: 'Select skills to remove (space to select, enter to confirm):',
+            choices
+          });
+
+          if (toRemove.length === 0) {
+            console.log(chalk.gray('   Nothing selected'));
+            return;
+          }
+
+          console.log(chalk.yellow(`\nAbout to remove ${toRemove.length} skill(s):`));
+          for (const s of toRemove) console.log(`   - ${s.name}`);
+          const ok = await confirm({ message: 'Continue?', default: false });
+          if (!ok) { console.log(chalk.gray('   Cancelled')); return; }
+        }
+
+        // Remove
+        const lockfileManager = new LockfileManager(projectRoot);
+        await lockfileManager.load();
+
+        for (const skill of toRemove) {
+          fs.rmSync(skill.path, { recursive: true, force: true });
+          lockfileManager.removeSkill(skill.name);
+          console.log(chalk.green(`   ✓ Removed ${skill.name}`));
+        }
+
+        await lockfileManager.save();
+        console.log(chalk.green(`\n✅ Removed ${toRemove.length} skill(s)`));
+
+      } catch (error) {
+        console.error(chalk.red(`❌ Manage failed: ${error.message}`));
+        process.exit(1);
+      }
+    });
+}

package/src/commands/read.js

@@ -1,127 +1,70 @@
-#!/usr/bin/env node
-
-import fs from 'fs';
-import path from 'path';
-
-/**
- * joySkills read 命令
- * 
- * 功能：
- * 读取指定 skill 的完整内容（YAML frontmatter + Markdown）
- * 
- * 设计原则：
- * - 100% 兼容 OpenSkills read 的输出格式
- * - 路径查找优先级与 openskills sync 一致
- * - 供 AI 编辑器解析使用
- * 
- * 路径查找优先级：
- * 1. 项目级 .agent/skills（--universal）
- * 2. 全局 ~/.agent/skills
- * 3. 项目级 .claude/skills（--project）
- * 4. 全局 ~/.claude/skills（--global）
- */
-
-export async function readCommand(skillName) {
-  if (!skillName) {
-    console.error('❌ 错误：请指定要读取的 skill 名称');
-    console.log('\n用法: joySkills read <skill-name>\n');
-    console.log('示例: joySkills read rc-onboarding\n');
-    process.exit(1);
-  }
-
-  try {
-    // 查找 skill 路径
-    const skillPath = findSkillPath(skillName);
-    
-    if (!skillPath) {
-      console.error(`❌ 找不到 skill: ${skillName}`);
-      console.log('\n💡 提示:');
-      console.log(`   1. 检查 skill 名称是否正确`);
-      console.log(`   2. 执行 joySkills list 查看已安装的 skills\n`);
-      process.exit(1);
-    }
-
-    // 读取 SKILL.md
-    const skillMdPath = path.join(skillPath, 'SKILL.md');
-    if (!fs.existsSync(skillMdPath)) {
-      console.error(`❌ ${skillName} 缺少 SKILL.md 文件`);
-      process.exit(1);
-    }
-
-    const content = fs.readFileSync(skillMdPath, 'utf-8');
-    
-    // 输出到 stdout（供 AI 编辑器解析）
-    console.log(content);
-
-  } catch (error) {
-    console.error('❌ 读取失败:', error.message);
-    process.exit(1);
-  }
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import chalk from 'chalk';
+
+export function readCommand(program) {
+  program
+    .command('read <skills>')
+    .description('Load and print skill content (comma-separated names supported)')
+    .option('-g, --global', 'Read from global ~/.claude/skills')
+    .option('--universal', 'Read from .agent/skills/')
+    .action(async (skillsInput, options) => {
+      try {
+        const projectRoot = process.cwd();
+
+        // Build search paths in priority order (openskill compatible)
+        const searchPaths = [
+          path.join(projectRoot, '.agent', 'skills'),
+          path.join(os.homedir(), '.agent', 'skills'),
+          path.join(projectRoot, '.claude', 'skills'),
+          path.join(os.homedir(), '.claude', 'skills'),
+          // legacy
+          path.join(projectRoot, 'skills'),
+        ];
+
+        // Support comma-separated skill names
+        const skillNames = skillsInput.split(',').map(s => s.trim()).filter(Boolean);
+
+        for (const skillName of skillNames) {
+          const content = findSkillContent(skillName, searchPaths);
+
+          if (!content) {
+            console.error(chalk.red(`❌ Skill not found: ${skillName}`));
+            console.error(chalk.gray(`   Searched in: ${searchPaths.filter(p => fs.existsSync(p)).join(', ')}`));
+            continue;
+          }
+
+          // Print skill content (for agent consumption)
+          if (skillNames.length > 1) {
+            console.log(chalk.blue(`\n── ${skillName} ──────────────────────────────────`));
+          }
+          console.log(content);
+        }
+
+      } catch (error) {
+        console.error(chalk.red(`❌ Read failed: ${error.message}`));
+        process.exit(1);
+      }
+    });
 }
 
-/**
- * 查找 skill 路径（按优先级）
- * 
- * 优先级与 OpenSkills sync 一致：
- * 1. 项目 .agent > 全局 .agent
- * 2. 项目 .claude > 全局 .claude
- */
-function findSkillPath(skillName) {
-  const homeDir = process.env.HOME || process.env.USERPROFILE;
-  const cwd = process.cwd();
-
-  const searchPaths = [
-    // 1. 项目级 .agent/skills（joySkills 默认 / OpenSkills --universal）
-    path.join(cwd, '.agent', 'skills', skillName),
-    
-    // 2. 全局 ~/.agent/skills（joySkills --global）
-    path.join(homeDir, '.agent', 'skills', skillName),
-    
-    // 3. 项目级 .claude/skills（OpenSkills --project）
-    path.join(cwd, '.claude', 'skills', skillName),
-    
-    // 4. 全局 ~/.claude/skills（OpenSkills --global）
-    path.join(homeDir, '.claude', 'skills', skillName),
-  ];
-
+function findSkillContent(skillName, searchPaths) {
   for (const searchPath of searchPaths) {
-    if (fs.existsSync(searchPath)) {
-      return searchPath;
-    }
-  }
-
-  return null;
-}
-
-/**
- * 列出所有可读取的 skills（辅助命令）
- */
-export function listReadableSkills() {
-  const homeDir = process.env.HOME || process.env.USERPROFILE;
-  const cwd = process.cwd();
+    if (!fs.existsSync(searchPath)) continue;
 
-  const searchDirs = [
-    path.join(cwd, '.agent', 'skills'),
-    path.join(homeDir, '.agent', 'skills'),
-    path.join(cwd, '.claude', 'skills'),
-    path.join(homeDir, '.claude', 'skills'),
-  ];
+    const skillDir = path.join(searchPath, skillName);
+    const skillMd = path.join(skillDir, 'SKILL.md');
 
-  const skills = new Set();
-
-  for (const dir of searchDirs) {
-    if (!fs.existsSync(dir)) continue;
-
-    const entries = fs.readdirSync(dir, { withFileTypes: true });
-    for (const entry of entries) {
-      if (!entry.isDirectory()) continue;
+    if (fs.existsSync(skillMd)) {
+      return fs.readFileSync(skillMd, 'utf-8');
+    }
 
-      const skillMdPath = path.join(dir, entry.name, 'SKILL.md');
-      if (fs.existsSync(skillMdPath)) {
-        skills.add(entry.name);
-      }
+    // Also check if skillName is a direct SKILL.md path
+    const directMd = path.join(searchPath, `${skillName}.md`);
+    if (fs.existsSync(directMd)) {
+      return fs.readFileSync(directMd, 'utf-8');
     }
   }
-
-  return Array.from(skills).sort();
+  return null;
 }

package/src/commands/remove.js

@@ -1,6 +1,23 @@
-import { Command } from 'commander';
-import { LocalManager } from '../local.js';
 import { LockfileManager } from '../lockfile.js';
+import * as path from 'path';
+import * as fs from 'fs';
+import * as os from 'os';
+import chalk from 'chalk';
+
+function findSkillOnDisk(skillName, projectRoot) {
+  const dirs = [
+    path.join(projectRoot, '.agent', 'skills'),
+    path.join(projectRoot, '.claude', 'skills'),
+    path.join(os.homedir(), '.agent', 'skills'),
+    path.join(os.homedir(), '.claude', 'skills'),
+    path.join(projectRoot, 'skills'),
+  ];
+  for (const d of dirs) {
+    const p = path.join(d, skillName);
+    if (fs.existsSync(p)) return p;
+  }
+  return null;
+}
 
 export function removeCommand(program) {
   program
@@ -8,35 +25,26 @@ export function removeCommand(program) {
     .description('Remove a skill')
     .action(async (skillName) => {
       const projectRoot = process.cwd();
-      const localManager = new LocalManager(projectRoot);
       const lockfileManager = new LockfileManager(projectRoot);
 
-      console.log(`Removing skill: ${skillName}`);
+      console.log(chalk.blue(`Removing skill: ${skillName}`));
 
       try {
-        // Load existing lockfile if exists
         await lockfileManager.load();
 
-        // Check if skill exists locally
-        if (!localManager.hasSkill(skillName)) {
-          console.log(`Skill ${skillName} does not exist locally.`);
+        const skillPath = findSkillOnDisk(skillName, projectRoot);
+        if (!skillPath) {
+          console.log(chalk.yellow(`Skill ${skillName} does not exist.`));
           return;
         }
 
-        // Remove the skill
-        const removed = localManager.removeSkill(skillName);
-
-        if (removed) {
-          // Update lockfile
-          lockfileManager.removeSkill(skillName);
-          await lockfileManager.save();
+        fs.rmSync(skillPath, { recursive: true, force: true });
+        lockfileManager.removeSkill(skillName);
+        await lockfileManager.save();
 
-          console.log(`✅ Successfully removed ${skillName}`);
-        } else {
-          console.log(`❌ Failed to remove ${skillName}`);
-        }
+        console.log(chalk.green(`✅ Successfully removed ${skillName}`));
       } catch (error) {
-        console.error(`❌ Failed to remove ${skillName}:`, error);
+        console.error(chalk.red(`❌ Failed to remove ${skillName}:`), error.message);
       }
     });
 }

package/src/commands/status.js

@@ -1,8 +1,20 @@
 import { LockfileManager } from '../lockfile.js';
 import { RegistryManager } from '../registry.js';
-import { LocalManager } from '../local.js';
 import * as path from 'path';
 import * as fs from 'fs';
+import * as os from 'os';
+import chalk from 'chalk';
+
+function skillExistsOnDisk(skillName, projectRoot) {
+  const dirs = [
+    path.join(projectRoot, '.agent', 'skills'),
+    path.join(projectRoot, '.claude', 'skills'),
+    path.join(os.homedir(), '.agent', 'skills'),
+    path.join(os.homedir(), '.claude', 'skills'),
+    path.join(projectRoot, 'skills'),
+  ];
+  return dirs.some(d => fs.existsSync(path.join(d, skillName)));
+}
 
 export function statusCommand(program) {
   program
@@ -11,10 +23,9 @@ export function statusCommand(program) {
     .action(async () => {
       const projectRoot = process.cwd();
       const lockfileManager = new LockfileManager(projectRoot);
-      const localManager = new LocalManager(projectRoot);
 
-      console.log('Skill Status Report:');
-      console.log('====================');
+      console.log(chalk.blue('Skill Status Report:'));
+      console.log(chalk.gray('===================='));
 
       try {
         await lockfileManager.load();
@@ -23,7 +34,7 @@ export function statusCommand(program) {
         const skillIds = Object.keys(installedSkills);
 
         if (skillIds.length === 0) {
-          console.log('No skills installed.');
+          console.log(chalk.yellow('No skills installed.'));
           return;
         }
 
@@ -40,17 +51,17 @@ export function statusCommand(program) {
           }
         }
 
-        console.log(`\nInstalled Skills (${skillIds.length} total):`);
-        console.log('------------------------------');
+        console.log(chalk.blue(`\nInstalled Skills (${skillIds.length} total):`));
+        console.log(chalk.gray('─'.repeat(50)));
 
         for (const skillId of skillIds) {
           const skillEntry = installedSkills[skillId];
 
-          let status = '✅ Installed';
+          let status = chalk.green('✅ Installed');
           let details = '';
 
-          // Check if skill exists locally
-          const hasLocal = localManager.hasSkill(skillId);
+          // Check if skill exists on disk (check all standard dirs)
+          const hasLocal = skillExistsOnDisk(skillId, projectRoot);
 
           // Check registry status
           if (registryManager) {
@@ -59,56 +70,35 @@ export function statusCommand(program) {
               const version = registryManager.getVersion(skillId, skillEntry.version);
               if (version) {
                 if (version.state === 'deprecated') {
-                  status = '⚠️  Deprecated';
+                  status = chalk.yellow('⚠️  Deprecated');
                   details = ' (upgrade recommended)';
                 } else if (version.state === 'draft' || version.state === 'pending_review') {
-                  status = '❌ Not Approved';
+                  status = chalk.red('❌ Not Approved');
                   details = ` (${version.state})`;
                 }
-
-                // Check for newer versions
                 const latest = registryManager.getLatestVersion(skillId);
                 if (latest && latest.version !== skillEntry.version) {
-                  details += ` - newer version v${latest.version} available`;
+                  details += chalk.gray(` → v${latest.version} available`);
                 }
               }
-            } else {
-              status = '❓ Not in Registry';
-              details = ' (local/external skill)';
             }
           }
 
           if (!hasLocal) {
-            status = '⚠️  Missing Local Files';
-            details = ' (files may have been deleted)';
+            status = chalk.red('❌ Missing Files');
+            details = ' (files deleted, run joySkills install to restore)';
           }
 
-          console.log(`${skillId} v${skillEntry.version}: ${status}${details}`);
+          const src = skillEntry.source ? chalk.gray(` [${skillEntry.source}]`) : '';
+          console.log(`  ${status} ${chalk.bold(skillId)} v${skillEntry.version}${src}${details}`);
         }
 
-        // Show registry info
         if (registryManager) {
-          console.log('\nRegistry Status:');
-          console.log('---------------');
-          console.log(`Registry loaded from: ${registryPath}`);
-          console.log(`Total skills in registry: ${registryManager.getAllSkills().length}`);
-        } else {
-          console.log('\nRegistry Status:');
-          console.log('---------------');
-          console.log('No registry found. Using local skills only.');
+          console.log(chalk.blue('\nRegistry:'));
+          console.log(`  Loaded: ${chalk.gray(registryPath)}`);
+          console.log(`  Skills: ${chalk.blue(registryManager.getAllSkills().length)}`);
         }
 
-        // Show local skills
-        const localSkills = localManager.listSkills();
-        const localOnlySkills = localSkills.filter(skillId => !installedSkills[skillId]);
-
-        if (localOnlySkills.length > 0) {
-          console.log(`\nLocal Skills (${localOnlySkills.length} not installed):`);
-          console.log('-------------------------');
-          for (const skillId of localOnlySkills) {
-            console.log(`${skillId} (local only)`);
-          }
-        }
       } catch (error) {
         console.error('Error checking status:', error);
       }