sumulige-claude 1.0.11 → 1.1.1

package/lib/commands.js

@@ -8,18 +8,116 @@ const fs = require('fs');
 const path = require('path');
 const { execSync } = require('child_process');
 const { loadConfig, CONFIG_DIR, CONFIG_FILE, SKILLS_DIR, ensureDir, saveConfig } = require('./config');
-const { copyRecursive, toTitleCase } = require('./utils');
+const { copyRecursive, toTitleCase, CopyMode } = require('./utils');
 const { runMigrations, TEMPLATE_VERSION } = require('./migrations');
+const { checkUpdate, getCurrentVersion } = require('./version-check');
 
 const TEMPLATE_DIR = path.join(__dirname, '../template');
 
+// ============================================================================
+// Helper Functions
+// ============================================================================
+
+/**
+ * Count files in a directory recursively
+ * @param {string} dirPath - Directory path
+ * @returns {number} Number of files
+ */
+function countFiles(dirPath) {
+  let count = 0;
+  const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path.join(dirPath, entry.name);
+    if (entry.isDirectory()) {
+      // Skip certain directories
+      if (entry.name !== 'node_modules' && entry.name !== '.git' && entry.name !== 'sessions') {
+        count += countFiles(fullPath);
+      }
+    } else {
+      count++;
+    }
+  }
+  return count;
+}
+
+/**
+ * Copy a single file with backup support
+ * @param {string} srcPath - Source file path
+ * @param {string} destPath - Destination file path
+ * @param {string} mode - Copy mode (CopyMode enum)
+ * @param {string} backupDir - Backup directory path
+ * @param {string} displayName - Display name for logging
+ */
+function copySingleFile(srcPath, destPath, mode, backupDir, displayName) {
+  if (!fs.existsSync(srcPath)) return;
+
+  // File doesn't exist at destination - just copy
+  if (!fs.existsSync(destPath)) {
+    fs.copyFileSync(srcPath, destPath);
+    setExecutablePermission(destPath);
+    console.log(`   ✅ ${displayName}`);
+    return;
+  }
+
+  // File exists - handle based on mode
+  switch (mode) {
+    case CopyMode.SAFE:
+      // Skip existing files
+      console.log(`   ⊝ ${displayName} (kept existing)`);
+      break;
+
+    case CopyMode.FORCE:
+      // Overwrite without backup
+      fs.copyFileSync(srcPath, destPath);
+      setExecutablePermission(destPath);
+      console.log(`   ✅ ${displayName} (overwritten)`);
+      break;
+
+    case CopyMode.BACKUP:
+    default:
+      // Backup then overwrite
+      const timestamp = new Date().toISOString().replace(/[:.]/g, '-').split('T')[0];
+      const backupFileName = path.basename(destPath).replace(/\.[^.]+$/, '') + '.' + timestamp + '.bak';
+      const backupPath = path.join(backupDir, backupFileName);
+
+      fs.mkdirSync(backupDir, { recursive: true });
+      fs.copyFileSync(destPath, backupPath);
+      setExecutablePermission(backupPath);
+
+      fs.copyFileSync(srcPath, destPath);
+      setExecutablePermission(destPath);
+      console.log(`   ✅ ${displayName} (backed up)`);
+      break;
+  }
+}
+
+/**
+ * Set executable permission for script files
+ * @param {string} filePath - File path
+ */
+function setExecutablePermission(filePath) {
+  if (filePath.endsWith('.sh') || filePath.endsWith('.cjs')) {
+    try {
+      fs.chmodSync(filePath, 0o755);
+    } catch (e) {
+      // Ignore permission errors
+    }
+  }
+}
+
 // ============================================================================
 // Commands
 // ============================================================================
 
 const commands = {
   // -------------------------------------------------------------------------
-  init: () => {
+  init: (...args) => {
+    const isInteractive = args.includes('--interactive') || args.includes('-i');
+
+    if (isInteractive) {
+      return commands['init:interactive']();
+    }
+
     console.log('🚀 Initializing Sumulige Claude...');
 
     // Create config directory
@@ -55,13 +153,164 @@ const commands = {
     console.log('🎉 Sumulige Claude initialized!');
     console.log('');
     console.log('Next steps:');
-    console.log('  sumulige-claude sync      # Sync to current project');
-    console.log('  sumulige-claude agent     # Run agent orchestration');
-    console.log('  sumulige-claude status    # Show configuration');
+    console.log('  smc sync                # Sync to current project');
+    console.log('  smc skills:official     # View available skills');
+    console.log('  smc init --interactive  # Interactive setup');
+  },
+
+  // -------------------------------------------------------------------------
+  version: async () => {
+    const current = getCurrentVersion();
+    console.log(`v${current}`);
+
+    // Check for updates asynchronously
+    setImmediate(async () => {
+      await checkUpdate({ force: false });
+    });
+  },
+
+  // -------------------------------------------------------------------------
+  'init:interactive': () => {
+    const readline = require('readline');
+    const COLORS = {
+      reset: '\x1b[0m',
+      green: '\x1b[32m',
+      blue: '\x1b[34m',
+      yellow: '\x1b[33m',
+      gray: '\x1b[90m',
+      cyan: '\x1b[36m'
+    };
+
+    const log = (msg, color = 'reset') => {
+      console.log(`${COLORS[color]}${msg}${COLORS.reset}`);
+    };
+
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+
+    const question = (prompt) => {
+      return new Promise(resolve => {
+        rl.question(prompt, resolve);
+      });
+    };
+
+    (async () => {
+      log('', 'gray');
+      log('🎯 SMC Interactive Setup', 'blue');
+      log('=====================================', 'gray');
+      log('', 'gray');
+
+      // Step 1: Create config
+      log('Step 1: Configuration', 'cyan');
+      ensureDir(CONFIG_DIR);
+      if (!fs.existsSync(CONFIG_FILE)) {
+        saveConfig(loadConfig());
+        log('✅ Created config', 'green');
+      } else {
+        log('✅ Config exists', 'green');
+      }
+      log('', 'gray');
+
+      // Step 2: Install OpenSkills
+      log('Step 2: OpenSkills', 'cyan');
+      try {
+        execSync('openskills --version', { stdio: 'ignore' });
+        log('✅ OpenSkills already installed', 'green');
+      } catch {
+        log('Installing OpenSkills...', 'gray');
+        try {
+          execSync('npm i -g openskills', { stdio: 'pipe' });
+          log('✅ OpenSkills installed', 'green');
+        } catch (e) {
+          log('⚠️  Failed to install OpenSkills', 'yellow');
+        }
+      }
+      log('', 'gray');
+
+      // Step 3: Select skills to install
+      log('Step 3: Choose Skills to Install', 'cyan');
+      log('', 'gray');
+      log('Available skill groups:', 'gray');
+      log('  1. 📄 Documents (docx, pdf, pptx, xlsx)', 'gray');
+      log('  2. 🎨 Creative (frontend-design, algorithmic-art)', 'gray');
+      log('  3. 🛠️ Development (mcp-builder, webapp-testing)', 'gray');
+      log('  4. 📋 Workflow (doc-coauthoring, internal-comms)', 'gray');
+      log('  5. ✨ All recommended skills', 'gray');
+      log('  6. ⏭️  Skip skill installation', 'gray');
+      log('', 'gray');
+
+      const skillChoice = await question('Select (1-6) [default: 6]: ');
+
+      const installSkills = async (source) => {
+        try {
+          execSync(`openskills install ${source} -y`, { stdio: 'pipe' });
+          execSync('openskills sync -y', { stdio: 'pipe' });
+          log('✅ Skills installed', 'green');
+        } catch (e) {
+          log('⚠️  Skill installation failed', 'yellow');
+        }
+      };
+
+      switch (skillChoice.trim()) {
+        case '1':
+          log('Installing document skills...', 'gray');
+          await installSkills('anthropics/skills');
+          break;
+        case '2':
+          log('Installing creative skills...', 'gray');
+          await installSkills('anthropics/skills');
+          break;
+        case '3':
+          log('Installing development skills...', 'gray');
+          await installSkills('anthropics/skills');
+          break;
+        case '4':
+          log('Installing workflow skills...', 'gray');
+          await installSkills('anthropics/skills');
+          break;
+        case '5':
+          log('Installing all recommended skills...', 'gray');
+          await installSkills('anthropics/skills');
+          break;
+        default:
+          log('⏭️  Skipped skill installation', 'yellow');
+          break;
+      }
+      log('', 'gray');
+
+      // Step 4: Sync to current project
+      log('Step 4: Sync to Current Project', 'cyan');
+      const shouldSync = await question('Sync .claude/ to current directory? [Y/n]: ');
+      if (shouldSync.toLowerCase() !== 'n') {
+        try {
+          execSync('smc sync', { stdio: 'inherit' });
+        } catch (e) {
+          log('⚠️  Sync failed (this is normal if not in a project directory)', 'yellow');
+        }
+      } else {
+        log('⏭️  Skipped sync', 'yellow');
+      }
+      log('', 'gray');
+
+      rl.close();
+
+      log('=====================================', 'gray');
+      log('🎉 Setup complete!', 'green');
+      log('', 'gray');
+      log('Useful commands:', 'gray');
+      log('  smc status              Show configuration status', 'gray');
+      log('  smc skills:official     List available skills', 'gray');
+      log('  smc doctor              Check system health', 'gray');
+      log('', 'gray');
+    })();
   },
 
   // -------------------------------------------------------------------------
-  sync: () => {
+  sync: async (...args) => {
+    const forceCheckUpdate = args.includes('--check-update');
+
     console.log('🔄 Syncing Sumulige Claude to current project...');
     console.log('');
 
@@ -129,6 +378,9 @@ const commands = {
 
     console.log('');
     console.log('✅ Sync complete!');
+
+    // Check for updates (sync is already a network operation)
+    await checkUpdate({ force: forceCheckUpdate, silent: false });
   },
 
   // -------------------------------------------------------------------------
@@ -482,13 +734,81 @@ const commands = {
   },
 
   // -------------------------------------------------------------------------
-  template: (targetPath) => {
-    const targetDir = targetPath ? path.resolve(targetPath) : process.cwd();
+  template: (...args) => {
+    // Parse arguments
+    let targetPath = process.cwd();
+    let copyMode = CopyMode.BACKUP;  // Default: backup before overwrite
+    let showHelp = false;
+
+    for (const arg of args) {
+      if (arg === '--safe') {
+        copyMode = CopyMode.SAFE;
+      } else if (arg === '--force') {
+        copyMode = CopyMode.FORCE;
+      } else if (arg === '--help' || arg === '-h') {
+        showHelp = true;
+      } else if (!arg.startsWith('--')) {
+        targetPath = path.resolve(arg);
+      }
+    }
+
+    // Show help message
+    if (showHelp) {
+      console.log('');
+      console.log('📋 smc template - Deploy Claude Code project template');
+      console.log('');
+      console.log('USAGE:');
+      console.log('  smc template [path] [options]');
+      console.log('');
+      console.log('ARGUMENTS:');
+      console.log('  path        Target directory (default: current directory)');
+      console.log('');
+      console.log('OPTIONS:');
+      console.log('  --safe      Skip existing files (no overwrite)');
+      console.log('  --force     Overwrite without backup (use for new projects)');
+      console.log('  --help, -h  Show this help message');
+      console.log('');
+      console.log('DEFAULT BEHAVIOR:');
+      console.log('  Backup existing files before overwriting.');
+      console.log('  Backups stored in: .claude/backup/');
+      console.log('  Backup format: filename.YYYY-MM-DD.bak');
+      console.log('');
+      console.log('EXAMPLES:');
+      console.log('  smc template                 # Deploy to current dir (with backup)');
+      console.log('  smc template ./my-project    # Deploy to specific dir');
+      console.log('  smc template --safe          # Skip existing files');
+      console.log('  smc template --force         # Overwrite everything');
+      console.log('');
+      console.log('COMPARISON:');
+      console.log('  smc template  = Full deployment (overwrites with backup)');
+      console.log('  smc sync       = Incremental update (only adds missing)');
+      console.log('');
+      return;
+    }
+
+    const targetDir = targetPath;
+    const backupDir = path.join(targetDir, '.claude', 'backup');
+    const stats = { copied: 0, skipped: 0, backedup: 0, backups: [] };
 
     console.log('🚀 Initializing Claude Code project template...');
     console.log('   Target:', targetDir);
+    console.log('   Mode:', copyMode === CopyMode.SAFE ? 'SAFE (skip existing)' : 
+                copyMode === CopyMode.FORCE ? 'FORCE (overwrite)' : 
+                'BACKUP (backup before overwrite)');
     console.log('');
 
+    // Warn if existing .claude directory found
+    const existingClaudeDir = path.join(targetDir, '.claude');
+    if (fs.existsSync(existingClaudeDir)) {
+      if (copyMode === CopyMode.FORCE) {
+        console.log('⚠️  Existing .claude/ directory found -- will be overwritten!');
+        console.log('');
+      } else if (copyMode === CopyMode.BACKUP) {
+        console.log('ℹ️  Existing files will be backed up to: .claude/backup/');
+        console.log('');
+      }
+    }
+
     // Check template directory exists
     if (!fs.existsSync(TEMPLATE_DIR)) {
       console.log('❌ Template not found at:', TEMPLATE_DIR);
@@ -504,11 +824,13 @@ const commands = {
       path.join(targetDir, 'development/todos/active'),
       path.join(targetDir, 'development/todos/completed'),
       path.join(targetDir, 'development/todos/backlog'),
-      path.join(targetDir, 'development/todos/archived')
+      path.join(targetDir, 'development/todos/archived'),
+      backupDir
     ];
 
     dirs.forEach(ensureDir);
     console.log('   ✅ Directories created');
+    console.log('');
 
     // Copy files
     console.log('📋 Copying template files...');
@@ -518,74 +840,103 @@ const commands = {
 
     // Files to copy
     const filesToCopy = [
-      { src: 'CLAUDE-template.md', dest: 'CLAUDE.md' },
-      { src: 'README.md', dest: 'README.md' },
-      { src: 'settings.json', dest: 'settings.json' },
-      { src: 'boris-optimizations.md', dest: 'boris-optimizations.md' }
+      { src: 'CLAUDE-template.md', dest: 'CLAUDE.md', name: '.claude/CLAUDE.md' },
+      { src: 'README.md', dest: 'README.md', name: '.claude/README.md' },
+      { src: 'settings.json', dest: 'settings.json', name: '.claude/settings.json' },
+      { src: 'boris-optimizations.md', dest: 'boris-optimizations.md', name: '.claude/boris-optimizations.md' }
     ];
 
-    filesToCopy.forEach(({ src, dest }) => {
+    filesToCopy.forEach(({ src, dest, name }) => {
       const srcPath = path.join(claudeTemplateDir, src);
+      const destPath = path.join(targetClaudeDir, dest);
       if (fs.existsSync(srcPath)) {
-        fs.copyFileSync(srcPath, path.join(targetClaudeDir, dest));
-        console.log(`   ✅ .claude/${dest}`);
+        const action = copySingleFile(srcPath, destPath, copyMode, backupDir, name);
+        if (action === 'copied') stats.copied++;
+        else if (action === 'skipped') stats.skipped++;
+        else if (action === 'backedup') { stats.copied++; stats.backedup++; }
       }
     });
 
     // Directories to copy recursively
     const dirsToCopy = [
-      { src: 'hooks', overwrite: true },
-      { src: 'commands', overwrite: true },
-      { src: 'skills', overwrite: false },
-      { src: 'templates', overwrite: false },
-      { src: 'thinking-routes', overwrite: false },
-      { src: 'rag', overwrite: true }
+      { src: 'hooks', name: '.claude/hooks/' },
+      { src: 'commands', name: '.claude/commands/' },
+      { src: 'skills', name: '.claude/skills/' },
+      { src: 'templates', name: '.claude/templates/' },
+      { src: 'thinking-routes', name: '.claude/thinking-routes/' },
+      { src: 'rag', name: '.claude/rag/' }
     ];
 
-    dirsToCopy.forEach(({ src, overwrite }) => {
+    dirsToCopy.forEach(({ src, name }) => {
       const srcPath = path.join(claudeTemplateDir, src);
       if (fs.existsSync(srcPath)) {
-        const count = copyRecursive(srcPath, path.join(targetClaudeDir, src), overwrite);
-        console.log(`   ✅ .claude/${src}/ (${count} files)`);
+        const result = copyRecursive(srcPath, path.join(targetClaudeDir, src), copyMode, backupDir);
+        const fileCount = result.copied + result.skipped + result.backedup;
+        const suffix = result.skipped > 0 ? ` (${result.skipped} skipped)` : '';
+        console.log(`   ✅ ${name} (${fileCount} files${suffix})`);
+        stats.copied += result.copied;
+        stats.skipped += result.skipped;
+        stats.backedup += result.backedup;
       }
     });
 
     // Copy prompts
     const promptsDir = path.join(TEMPLATE_DIR, 'prompts');
     if (fs.existsSync(promptsDir)) {
-      const count = copyRecursive(promptsDir, path.join(targetDir, 'prompts'), false);
-      console.log(`   ✅ prompts/ (${count} files)`);
+      const result = copyRecursive(promptsDir, path.join(targetDir, 'prompts'), copyMode, backupDir);
+      const fileCount = result.copied + result.skipped + result.backedup;
+      const suffix = result.skipped > 0 ? ` (${result.skipped} skipped)` : '';
+      console.log(`   ✅ prompts/ (${fileCount} files${suffix})`);
+      stats.copied += result.copied;
+      stats.skipped += result.skipped;
+      stats.backedup += result.backedup;
     }
 
     // Copy todos
     const todosDir = path.join(TEMPLATE_DIR, 'development', 'todos');
     if (fs.existsSync(todosDir)) {
-      const count = copyRecursive(todosDir, path.join(targetDir, 'development', 'todos'), false);
-      console.log(`   ✅ development/todos/ (${count} files)`);
+      const result = copyRecursive(todosDir, path.join(targetDir, 'development', 'todos'), copyMode, backupDir);
+      const fileCount = result.copied + result.skipped + result.backedup;
+      const suffix = result.skipped > 0 ? ` (${result.skipped} skipped)` : '';
+      console.log(`   ✅ development/todos/ (${fileCount} files${suffix})`);
+      stats.copied += result.copied;
+      stats.skipped += result.skipped;
+      stats.backedup += result.backedup;
     }
 
     // Root files
     const rootFiles = ['project-paradigm.md', 'thinkinglens-silent.md', 'CLAUDE-template.md'];
     rootFiles.forEach(file => {
       const src = path.join(TEMPLATE_DIR, file);
+      const dest = path.join(targetDir, file);
       if (fs.existsSync(src)) {
-        fs.copyFileSync(src, path.join(targetDir, file));
-        console.log('   ✅ ' + file);
+        const action = copySingleFile(src, dest, copyMode, backupDir, file);
+        if (action === 'copied') stats.copied++;
+        else if (action === 'skipped') stats.skipped++;
+        else if (action === 'backedup') { stats.copied++; stats.backedup++; }
       }
     });
 
     // Create memory files
+    console.log('');
     console.log('📝 Creating memory files...');
     if (!fs.existsSync(path.join(targetClaudeDir, 'MEMORY.md'))) {
       fs.writeFileSync(path.join(targetClaudeDir, 'MEMORY.md'), '# Memory\n\n<!-- Project memory updated by AI -->\n');
+      console.log('   ✅ MEMORY.md');
+    } else {
+      console.log('   ⊝ MEMORY.md (already exists)');
     }
     if (!fs.existsSync(path.join(targetClaudeDir, 'PROJECT_LOG.md'))) {
       fs.writeFileSync(path.join(targetClaudeDir, 'PROJECT_LOG.md'), '# Project Log\n\n<!-- Build history and decisions -->\n');
+      console.log('   ✅ PROJECT_LOG.md');
+    } else {
+      console.log('   ⊝ PROJECT_LOG.md (already exists)');
     }
-    console.log('   ✅ Memory files created');
 
     // Create ANCHORS.md
-    const anchorsContent = `# [Project Name] - Skill Anchors Index
+    const anchorsPath = path.join(targetClaudeDir, 'ANCHORS.md');
+    if (!fs.existsSync(anchorsPath)) {
+      const anchorsContent = `# [Project Name] - Skill Anchors Index
 
 > This file is auto-maintained by AI as a quick index for the skill system
 > Last updated: ${new Date().toISOString().split('T')[0]}
@@ -600,7 +951,7 @@ const commands = {
 3. MEMORY.md                 → View latest changes
 4. CLAUDE.md                 → Load core knowledge
 5. prompts/                  → View tutorials
-6. .claude/rag/skills.md     → RAG skill index ⭐
+6. .claude/rag/skill-index.json → RAG skill index ⭐
 7. Specific files            → Deep dive into implementation
 \`\`\`
 
@@ -624,14 +975,28 @@ const commands = {
 ## Add Your Anchors Here...
 
 `;
-    fs.writeFileSync(path.join(targetClaudeDir, 'ANCHORS.md'), anchorsContent);
-    console.log('   ✅ .claude/ANCHORS.md');
+      fs.writeFileSync(anchorsPath, anchorsContent);
+      console.log('   ✅ .claude/ANCHORS.md');
+    } else {
+      console.log('   ⊝ .claude/ANCHORS.md (already exists)');
+    }
 
     // Write version file
     const { setProjectVersion } = require('./migrations');
     setProjectVersion(targetDir, TEMPLATE_VERSION);
     console.log(`   ✅ .claude/.version (v${TEMPLATE_VERSION})`);
 
+    // Show summary
+    console.log('');
+    console.log('📊 Summary:');
+    console.log(`   ✅ Copied: ${stats.copied} files`);
+    if (stats.skipped > 0) {
+      console.log(`   ⊝ Skipped: ${stats.skipped} files (already exist)`);
+    }
+    if (stats.backedup > 0) {
+      console.log(`   💾 Backed up: ${stats.backedup} files → .claude/backup/`);
+    }
+
     // Initialize Sumulige Claude if installed
     console.log('');
     console.log('🤖 Initializing Sumulige Claude...');
@@ -651,7 +1016,7 @@ const commands = {
     console.log('   • Skills system with templates');
     console.log('   • RAG dynamic skill index');
     console.log('   • Hooks for automation');
-    console.log('   • TODO management system');
+    console.log('   • TODO management system v2.0 (R-D-T lifecycle)');
     console.log('');
     console.log('Next steps:');
     console.log('   1. Edit .claude/CLAUDE.md with your project info');
@@ -660,6 +1025,7 @@ const commands = {
     console.log('');
   },
 
+
   // -------------------------------------------------------------------------
   kickoff: () => {
     const projectDir = process.cwd();
@@ -703,6 +1069,1466 @@ const commands = {
       console.log('   请先运行: sumulige-claude template');
       console.log('   或: sumulige-claude sync');
     }
+  },
+
+  // -------------------------------------------------------------------------
+  ultrathink: () => {
+    const COLORS = {
+      reset: '\x1b[0m',
+      green: '\x1b[32m',
+      blue: '\x1b[34m',
+      yellow: '\x1b[33m',
+      gray: '\x1b[90m'
+    };
+
+    const log = (msg, color = 'reset') => {
+      console.log(`${COLORS[color]}${msg}${COLORS.reset}`);
+    };
+
+    log('', 'gray');
+    log('🧠 UltraThink Mode', 'blue');
+    log('=====================================', 'gray');
+    log('', 'gray');
+    log('✅ Deep thinking enabled', 'green');
+    log('', 'gray');
+    log('Usage:', 'gray');
+    log('  Mention "ultrathink" or "深度思考" in conversation', 'gray');
+    log('', 'gray');
+    log('=====================================', 'gray');
+    log('', 'gray');
+  },
+
+  // -------------------------------------------------------------------------
+  'skills:official': () => {
+    const fs = require('fs');
+    const path = require('path');
+    const COLORS = {
+      reset: '\x1b[0m',
+      green: '\x1b[32m',
+      blue: '\x1b[34m',
+      yellow: '\x1b[33m',
+      gray: '\x1b[90m',
+      cyan: '\x1b[36m',
+      magenta: '\x1b[35m'
+    };
+
+    const log = (msg, color = 'reset') => {
+      console.log(`${COLORS[color]}${msg}${COLORS.reset}`);
+    };
+
+    const officialSkillsFile = path.join(__dirname, '../config/official-skills.json');
+
+    if (!fs.existsSync(officialSkillsFile)) {
+      log('⚠ Official skills registry not found', 'yellow');
+      return;
+    }
+
+    const registry = JSON.parse(fs.readFileSync(officialSkillsFile, 'utf-8'));
+
+    log('', 'gray');
+    log('📚 Official Skills (anthropics/skills)', 'blue');
+    log('=====================================', 'gray');
+    log('', 'gray');
+    log(`Source: ${registry.source}`, 'gray');
+    log(`Updated: ${registry.last_updated}`, 'gray');
+    log('', 'gray');
+
+    // Check which skills are already installed
+    const skillsDir = path.join(process.env.HOME || process.env.USERPROFILE, '.claude/skills');
+    const installedSkills = fs.existsSync(skillsDir)
+      ? fs.readdirSync(skillsDir).filter(f => {
+        const dir = path.join(skillsDir, f);
+        return fs.statSync(dir).isDirectory();
+      })
+      : [];
+
+    // Group by category
+    const byCategory = {};
+    for (const cat of Object.values(registry.categories)) {
+      byCategory[cat.name] = { skills: [], ...cat };
+    }
+
+    for (const skill of registry.skills) {
+      const catName = registry.categories[skill.category].name;
+      const isInstalled = installedSkills.includes(skill.name);
+      byCategory[catName].skills.push({ ...skill, isInstalled });
+    }
+
+    // Display by category
+    for (const [catName, cat] of Object.entries(byCategory)) {
+      if (cat.skills.length === 0) continue;
+
+      log(`${cat.icon} ${catName}`, 'cyan');
+      log(`   ${cat.description}`, 'gray');
+      log('', 'gray');
+
+      for (const skill of cat.skills) {
+        const status = skill.isInstalled ? '✓' : ' ';
+        const rec = skill.recommended ? ' [推荐]' : '';
+        const color = skill.isInstalled ? 'green' : 'reset';
+        log(`  [${status}] ${skill.name}${rec}`, color);
+        log(`      ${skill.description}`, 'gray');
+      }
+      log('', 'gray');
+    }
+
+    log('=====================================', 'gray');
+    log('', 'gray');
+    log('Commands:', 'gray');
+    log('  smc skills:install-official <name>   Install a skill', 'gray');
+    log('  smc skills:install-all               Install all recommended', 'gray');
+    log('', 'gray');
+  },
+
+  // -------------------------------------------------------------------------
+  'skills:install-official': (skillName) => {
+    const fs = require('fs');
+    const path = require('path');
+    const { execSync } = require('child_process');
+    const COLORS = {
+      reset: '\x1b[0m',
+      green: '\x1b[32m',
+      blue: '\x1b[34m',
+      yellow: '\x1b[33m',
+      gray: '\x1b[90m',
+      red: '\x1b[31m'
+    };
+
+    const log = (msg, color = 'reset') => {
+      console.log(`${COLORS[color]}${msg}${COLORS.reset}`);
+    };
+
+    const officialSkillsFile = path.join(__dirname, '../config/official-skills.json');
+
+    if (!fs.existsSync(officialSkillsFile)) {
+      log('⚠ Official skills registry not found', 'yellow');
+      return;
+    }
+
+    const registry = JSON.parse(fs.readFileSync(officialSkillsFile, 'utf-8'));
+
+    // Check if openskills is installed
+    try {
+      execSync('openskills --version', { stdio: 'ignore' });
+    } catch {
+      log('⚠ OpenSkills not installed', 'yellow');
+      log('', 'gray');
+      log('Installing OpenSkills...', 'gray');
+      try {
+        execSync('npm i -g openskills', { stdio: 'inherit' });
+        log('✅ OpenSkills installed', 'green');
+      } catch (e) {
+        log('❌ Failed to install OpenSkills', 'red');
+        log('   Run: npm i -g openskills', 'gray');
+        return;
+      }
+    }
+
+    // Find the skill
+    const skill = registry.skills.find(s => s.name === skillName);
+
+    if (!skill) {
+      log(`❌ Skill "${skillName}" not found in official registry`, 'red');
+      log('', 'gray');
+      log('Run: smc skills:official');
+      log('to see available skills.', 'gray');
+      return;
+    }
+
+    log(`📦 Installing: ${skillName}`, 'blue');
+    log('', 'gray');
+    log(`Source: ${skill.source}`, 'gray');
+    log(`License: ${skill.license}`, 'gray');
+    log('', 'gray');
+
+    try {
+      execSync(`openskills install ${skill.source} -y`, { stdio: 'inherit' });
+      execSync('openskills sync -y', { stdio: 'pipe' });
+      log('', 'gray');
+      log('✅ Skill installed successfully', 'green');
+      log('', 'gray');
+      log('The skill is now available in your conversations.', 'gray');
+    } catch (e) {
+      log('❌ Installation failed', 'red');
+    }
+  },
+
+  // -------------------------------------------------------------------------
+  'skills:install-all': () => {
+    const fs = require('fs');
+    const path = require('path');
+    const { execSync } = require('child_process');
+    const COLORS = {
+      reset: '\x1b[0m',
+      green: '\x1b[32m',
+      blue: '\x1b[34m',
+      yellow: '\x1b[33m',
+      gray: '\x1b[90m',
+      red: '\x1b[31m',
+      cyan: '\x1b[36m'
+    };
+
+    const log = (msg, color = 'reset') => {
+      console.log(`${COLORS[color]}${msg}${COLORS.reset}`);
+    };
+
+    const officialSkillsFile = path.join(__dirname, '../config/official-skills.json');
+
+    if (!fs.existsSync(officialSkillsFile)) {
+      log('⚠ Official skills registry not found', 'yellow');
+      return;
+    }
+
+    const registry = JSON.parse(fs.readFileSync(officialSkillsFile, 'utf-8'));
+    const recommended = registry.skills.filter(s => s.recommended);
+
+    log('', 'gray');
+    log('📦 Installing All Recommended Skills', 'blue');
+    log('=====================================', 'gray');
+    log('', 'gray');
+    log(`Installing ${recommended.length} skills...`, 'gray');
+    log('', 'gray');
+
+    // Check if openskills is installed
+    try {
+      execSync('openskills --version', { stdio: 'ignore' });
+    } catch {
+      log('⚠ OpenSkills not installed. Installing...', 'yellow');
+      try {
+        execSync('npm i -g openskills', { stdio: 'inherit' });
+        log('✅ OpenSkills installed', 'green');
+        log('', 'gray');
+      } catch (e) {
+        log('❌ Failed to install OpenSkills', 'red');
+        return;
+      }
+    }
+
+    // Install anthropics/skills (includes all skills)
+    try {
+      log(`Installing ${registry.source}...`, 'cyan');
+      execSync(`openskills install ${registry.source} -y`, { stdio: 'inherit' });
+      execSync('openskills sync -y', { stdio: 'pipe' });
+      log('', 'gray');
+      log('✅ All skills installed successfully', 'green');
+      log('', 'gray');
+      log('Installed skills:', 'gray');
+      recommended.forEach(s => log(`  • ${s.name}`, 'gray'));
+      log('', 'gray');
+      log('These skills are now available in your conversations.', 'gray');
+    } catch (e) {
+      log('❌ Installation failed', 'red');
+    }
+  },
+
+  // -------------------------------------------------------------------------
+  doctor: () => {
+    const fs = require('fs');
+    const path = require('path');
+    const { execSync } = require('child_process');
+    const COLORS = {
+      reset: '\x1b[0m',
+      green: '\x1b[32m',
+      blue: '\x1b[34m',
+      yellow: '\x1b[33m',
+      gray: '\x1b[90m',
+      red: '\x1b[31m',
+      cyan: '\x1b[36m'
+    };
+
+    const log = (msg, color = 'reset') => {
+      console.log(`${COLORS[color]}${msg}${COLORS.reset}`);
+    };
+
+    log('', 'gray');
+    log('🏥 SMC Health Check', 'blue');
+    log('=====================================', 'gray');
+    log('', 'gray');
+
+    const checks = [];
+    let passCount = 0;
+    let warnCount = 0;
+    let failCount = 0;
+
+    // Check 1: Global config
+    const globalConfigDir = path.join(process.env.HOME || process.env.USERPROFILE, '.claude');
+    const globalConfigFile = path.join(globalConfigDir, 'config.json');
+
+    if (fs.existsSync(globalConfigFile)) {
+      checks.push({ name: 'Global config', status: 'pass', msg: globalConfigFile });
+      passCount++;
+    } else {
+      checks.push({ name: 'Global config', status: 'fail', msg: 'Run: smc init' });
+      failCount++;
+    }
+
+    // Check 2: Project .claude directory
+    const projectDir = process.cwd();
+    const projectClaudeDir = path.join(projectDir, '.claude');
+
+    if (fs.existsSync(projectClaudeDir)) {
+      checks.push({ name: 'Project .claude/', status: 'pass', msg: projectClaudeDir });
+      passCount++;
+
+      // Check for key files
+      const agentsFile = path.join(projectClaudeDir, 'AGENTS.md');
+      if (fs.existsSync(agentsFile)) {
+        checks.push({ name: 'AGENTS.md', status: 'pass', msg: 'Generated' });
+        passCount++;
+      } else {
+        checks.push({ name: 'AGENTS.md', status: 'warn', msg: 'Run: smc sync' });
+        warnCount++;
+      }
+
+      // Check MEMORY.md age
+      const memoryFile = path.join(projectClaudeDir, 'MEMORY.md');
+      if (fs.existsSync(memoryFile)) {
+        const stats = fs.statSync(memoryFile);
+        const daysSinceUpdate = (Date.now() - stats.mtime.getTime()) / (1000 * 60 * 60 * 24);
+        if (daysSinceUpdate > 30) {
+          checks.push({ name: 'MEMORY.md', status: 'warn', msg: `Updated ${Math.floor(daysSinceUpdate)} days ago` });
+          warnCount++;
+        } else {
+          checks.push({ name: 'MEMORY.md', status: 'pass', msg: `Updated ${Math.floor(daysSinceUpdate)} days ago` });
+          passCount++;
+        }
+      } else {
+        checks.push({ name: 'MEMORY.md', status: 'warn', msg: 'Not found' });
+        warnCount++;
+      }
+
+      // Check hooks
+      const hooksDir = path.join(projectClaudeDir, 'hooks');
+      if (fs.existsSync(hooksDir)) {
+        const hookFiles = fs.readdirSync(hooksDir).filter(f => !f.startsWith('.'));
+        checks.push({ name: 'Hooks', status: 'pass', msg: `${hookFiles.length} hooks` });
+        passCount++;
+      } else {
+        checks.push({ name: 'Hooks', status: 'warn', msg: 'No hooks directory' });
+        warnCount++;
+      }
+
+      // Check skills
+      const skillsDir = path.join(projectClaudeDir, 'skills');
+      if (fs.existsSync(skillsDir)) {
+        const skillDirs = fs.readdirSync(skillsDir).filter(f => {
+          const dir = path.join(skillsDir, f);
+          return fs.statSync(dir).isDirectory() && f !== 'template' && f !== 'examples';
+        });
+        checks.push({ name: 'Project Skills', status: 'pass', msg: `${skillDirs.length} skills` });
+        passCount++;
+      } else {
+        checks.push({ name: 'Project Skills', status: 'warn', msg: 'No skills directory' });
+        warnCount++;
+      }
+    } else {
+      checks.push({ name: 'Project .claude/', status: 'warn', msg: 'Run: smc template or smc sync' });
+      warnCount++;
+    }
+
+    // Check 3: OpenSkills
+    try {
+      execSync('openskills --version', { stdio: 'ignore' });
+      const globalSkillsDir = path.join(globalConfigDir, 'skills');
+      if (fs.existsSync(globalSkillsDir)) {
+        const skillCount = fs.readdirSync(globalSkillsDir).filter(f => {
+          const dir = path.join(globalSkillsDir, f);
+          return fs.statSync(dir).isDirectory() && !f.startsWith('.');
+        }).length;
+        checks.push({ name: 'OpenSkills', status: 'pass', msg: `${skillCount} global skills` });
+        passCount++;
+      } else {
+        checks.push({ name: 'OpenSkills', status: 'pass', msg: 'Installed' });
+        passCount++;
+      }
+    } catch {
+      checks.push({ name: 'OpenSkills', status: 'warn', msg: 'Not installed (run: npm i -g openskills)' });
+      warnCount++;
+    }
+
+    // Check 4: Git
+    try {
+      execSync('git rev-parse --git-dir', { stdio: 'ignore', cwd: projectDir });
+      checks.push({ name: 'Git', status: 'pass', msg: 'Repository detected' });
+      passCount++;
+    } catch {
+      checks.push({ name: 'Git', status: 'warn', msg: 'Not a git repository' });
+      warnCount++;
+    }
+
+    // Display results
+    for (const check of checks) {
+      const icon = check.status === 'pass' ? '✅' : check.status === 'warn' ? '⚠️' : '❌';
+      const color = check.status === 'pass' ? 'green' : check.status === 'warn' ? 'yellow' : 'red';
+      log(`${icon} ${check.name}`, color);
+      log(`   ${check.msg}`, 'gray');
+      log('', 'gray');
+    }
+
+    log('=====================================', 'gray');
+    log(`Summary: ${passCount} passed, ${warnCount} warnings${failCount > 0 ? `, ${failCount} failed` : ''}`, 'gray');
+    log('', 'gray');
+
+    if (failCount > 0) {
+      log('Fix failed checks to continue.', 'red');
+    }
+  },
+
+  // -------------------------------------------------------------------------
+  'skills:search': (keyword) => {
+    const fs = require('fs');
+    const path = require('path');
+    const COLORS = {
+      reset: '\x1b[0m',
+      green: '\x1b[32m',
+      blue: '\x1b[34m',
+      yellow: '\x1b[33m',
+      gray: '\x1b[90m',
+      cyan: '\x1b[36m'
+    };
+
+    const log = (msg, color = 'reset') => {
+      console.log(`${COLORS[color]}${msg}${COLORS.reset}`);
+    };
+
+    if (!keyword) {
+      log('Usage: smc skills:search <keyword>', 'yellow');
+      log('', 'gray');
+      log('Examples:', 'gray');
+      log('  smc skills:search pdf', 'gray');
+      log('  smc skills:search "前端设计"', 'gray');
+      return;
+    }
+
+    log('', 'gray');
+    log(`🔍 Searching for: "${keyword}"`, 'blue');
+    log('=====================================', 'gray');
+    log('', 'gray');
+
+    const results = [];
+    const lowerKeyword = keyword.toLowerCase();
+
+    // Search in official skills registry
+    const officialSkillsFile = path.join(__dirname, '../config/official-skills.json');
+    if (fs.existsSync(officialSkillsFile)) {
+      const registry = JSON.parse(fs.readFileSync(officialSkillsFile, 'utf-8'));
+
+      for (const skill of registry.skills) {
+        const matchName = skill.name.toLowerCase().includes(lowerKeyword);
+        const matchDesc = skill.description.toLowerCase().includes(lowerKeyword);
+        const matchCat = registry.categories[skill.category]?.name.toLowerCase().includes(lowerKeyword);
+
+        if (matchName || matchDesc || matchCat) {
+          results.push({
+            name: skill.name,
+            description: skill.description,
+            category: registry.categories[skill.category]?.name,
+            source: 'official',
+            recommended: skill.recommended
+          });
+        }
+      }
+    }
+
+    // Search in sources.yaml
+    const sourcesFile = path.join(__dirname, '../sources.yaml');
+    if (fs.existsSync(sourcesFile)) {
+      const content = fs.readFileSync(sourcesFile, 'utf-8');
+      // Simple YAML parsing for skills
+      const lines = content.split('\n');
+      let currentSkill = null;
+
+      for (const line of lines) {
+        const nameMatch = line.match(/^\s*-\s*name:\s*(.+)$/);
+        if (nameMatch) {
+          currentSkill = { name: nameMatch[1].trim(), source: 'marketplace' };
+          if (currentSkill.name.toLowerCase().includes(lowerKeyword)) {
+            results.push(currentSkill);
+          }
+        }
+        const descMatch = line.match(/^\s+description:\s*"(.+)"$/);
+        if (descMatch && currentSkill) {
+          currentSkill.description = descMatch[1];
+          if (currentSkill.description.toLowerCase().includes(lowerKeyword)) {
+            results.push({ ...currentSkill });
+          }
+        }
+      }
+    }
+
+    // Search in global skills
+    const globalSkillsDir = path.join(process.env.HOME || process.env.USERPROFILE, '.claude/skills');
+    if (fs.existsSync(globalSkillsDir)) {
+      const skillDirs = fs.readdirSync(globalSkillsDir).filter(f => {
+        const dir = path.join(globalSkillsDir, f);
+        return fs.statSync(dir).isDirectory() && !f.startsWith('.');
+      });
+
+      for (const skillName of skillDirs) {
+        if (skillName.toLowerCase().includes(lowerKeyword)) {
+          // Check if already in results
+          if (!results.some(r => r.name === skillName)) {
+            const skillFile = path.join(globalSkillsDir, skillName, 'SKILL.md');
+            let description = '';
+            if (fs.existsSync(skillFile)) {
+              const content = fs.readFileSync(skillFile, 'utf-8');
+              const descMatch = content.match(/description:\s*(.+)/);
+              if (descMatch) description = descMatch[1];
+            }
+            results.push({
+              name: skillName,
+              description: description || 'Local skill',
+              source: 'installed'
+            });
+          }
+        }
+      }
+    }
+
+    // Display results
+    if (results.length === 0) {
+      log('No skills found matching your search.', 'yellow');
+    } else {
+      for (const result of results) {
+        const sourceIcon = result.source === 'official' ? '🔷' : result.source === 'marketplace' ? '📦' : '✓';
+        const rec = result.recommended ? ' [推荐]' : '';
+        log(`${sourceIcon} ${result.name}${rec}`, 'cyan');
+        if (result.description) {
+          log(`   ${result.description}`, 'gray');
+        }
+        if (result.category) {
+          log(`   分类: ${result.category}`, 'gray');
+        }
+        log('', 'gray');
+      }
+    }
+
+    log('=====================================', 'gray');
+    log(`Found ${results.length} result(s)`, 'gray');
+    log('', 'gray');
+  },
+
+  // -------------------------------------------------------------------------
+  'skills:validate': (skillPath) => {
+    const fs = require('fs');
+    const path = require('path');
+    const COLORS = {
+      reset: '\x1b[0m',
+      green: '\x1b[32m',
+      blue: '\x1b[34m',
+      yellow: '\x1b[33m',
+      gray: '\x1b[90m',
+      red: '\x1b[31m'
+    };
+
+    const log = (msg, color = 'reset') => {
+      console.log(`${COLORS[color]}${msg}${COLORS.reset}`);
+    };
+
+    // Default to current directory if not specified
+    const targetPath = skillPath || path.join(process.cwd(), '.claude/skills');
+
+    if (!fs.existsSync(targetPath)) {
+      log(`❌ Path not found: ${targetPath}`, 'red');
+      return;
+    }
+
+    log('', 'gray');
+    log('🔍 Validating Skills', 'blue');
+    log('=====================================', 'gray');
+    log('', 'gray');
+
+    const checks = [];
+    let passCount = 0;
+    let failCount = 0;
+
+    // Check if it's a directory or a single skill
+    const stats = fs.statSync(targetPath);
+
+    const validateSkill = (skillDir) => {
+      const skillName = path.basename(skillDir);
+      const skillFile = path.join(skillDir, 'SKILL.md');
+      const errors = [];
+      const warnings = [];
+
+      // Check SKILL.md exists
+      if (!fs.existsSync(skillFile)) {
+        errors.push('SKILL.md not found');
+        return { name: skillName, errors, warnings };
+      }
+
+      // Parse SKILL.md
+      const content = fs.readFileSync(skillFile, 'utf-8');
+      const frontmatterMatch = content.match(/^---\n(.*?)\n---/s);
+
+      if (!frontmatterMatch) {
+        errors.push('No frontmatter found (--- delimited YAML required)');
+      } else {
+        const frontmatter = frontmatterMatch[1];
+
+        // Check required fields
+        if (!frontmatter.match(/name:\s*.+/)) {
+          errors.push('Missing "name" in frontmatter');
+        }
+        if (!frontmatter.match(/description:\s*.+/)) {
+          warnings.push('Missing "description" in frontmatter (recommended)');
+        }
+      }
+
+      // Check for references directory if referenced
+      if (content.includes('references/') && !fs.existsSync(path.join(skillDir, 'references'))) {
+        warnings.push('Content references "references/" but directory not found');
+      }
+
+      return { name: skillName, errors, warnings };
+    };
+
+    if (stats.isDirectory()) {
+      // Check if it's a skills directory or a single skill
+      const skillFile = path.join(targetPath, 'SKILL.md');
+      if (fs.existsSync(skillFile)) {
+        // Single skill
+        const result = validateSkill(targetPath);
+        checks.push(result);
+      } else {
+        // Skills directory - validate all subdirectories
+        const entries = fs.readdirSync(targetPath);
+        for (const entry of entries) {
+          const entryPath = path.join(targetPath, entry);
+          const entryStats = fs.statSync(entryPath);
+          if (entryStats.isDirectory() && !entry.startsWith('.')) {
+            const result = validateSkill(entryPath);
+            checks.push(result);
+          }
+        }
+      }
+    }
+
+    // Display results
+    for (const check of checks) {
+      if (check.errors.length === 0 && check.warnings.length === 0) {
+        log(`✅ ${check.name}`, 'green');
+        passCount++;
+      } else if (check.errors.length === 0) {
+        log(`⚠️  ${check.name}`, 'yellow');
+        passCount++;
+      } else {
+        log(`❌ ${check.name}`, 'red');
+        failCount++;
+      }
+
+      for (const error of check.errors) {
+        log(`   ❌ ${error}`, 'red');
+      }
+      for (const warning of check.warnings) {
+        log(`   ⚠️  ${warning}`, 'yellow');
+      }
+      log('', 'gray');
+    }
+
+    log('=====================================', 'gray');
+    log(`Validated ${checks.length} skill(s): ${passCount} passed${failCount > 0 ? `, ${failCount} failed` : ''}`, 'gray');
+    log('', 'gray');
+  },
+
+  // -------------------------------------------------------------------------
+  'skills:update': () => {
+    const fs = require('fs');
+    const path = require('path');
+    const { execSync } = require('child_process');
+    const COLORS = {
+      reset: '\x1b[0m',
+      green: '\x1b[32m',
+      blue: '\x1b[34m',
+      yellow: '\x1b[33m',
+      gray: '\x1b[90m',
+      red: '\x1b[31m'
+    };
+
+    const log = (msg, color = 'reset') => {
+      console.log(`${COLORS[color]}${msg}${COLORS.reset}`);
+    };
+
+    log('', 'gray');
+    log('🔄 Updating Official Skills List', 'blue');
+    log('=====================================', 'gray');
+    log('', 'gray');
+
+    // Fetch latest skills from anthropics/skills
+    const tempDir = path.join(__dirname, '../.tmp');
+    const repoUrl = 'https://github.com/anthropics/skills.git';
+
+    try {
+      // Create temp dir
+      if (!fs.existsSync(tempDir)) {
+        fs.mkdirSync(tempDir, { recursive: true });
+      }
+
+      const cloneDir = path.join(tempDir, 'anthropics-skills');
+
+      // Remove existing clone if present
+      const rimraf = (dir) => {
+        if (fs.existsSync(dir)) {
+          fs.rmSync(dir, { recursive: true, force: true });
+        }
+      };
+
+      rimraf(cloneDir);
+
+      log('Cloning anthropics/skills...', 'gray');
+      execSync(`git clone --depth 1 ${repoUrl} ${cloneDir}`, { stdio: 'pipe' });
+
+      // Read skills directory to get available skills
+      const skillsDir = path.join(cloneDir, 'skills');
+      const skillCategories = fs.readdirSync(skillsDir).filter(f => {
+        const dir = path.join(skillsDir, f);
+        return fs.statSync(dir).isDirectory();
+      });
+
+      log(`Found ${skillCategories.length} skills in repository`, 'gray');
+      log('', 'gray');
+
+      // Update the registry file
+      const registryFile = path.join(__dirname, '../config/official-skills.json');
+      let registry = { version: '1.0.0', last_updated: new Date().toISOString().split('T')[0], source: 'anthropics/skills', categories: {}, skills: [] };
+
+      if (fs.existsSync(registryFile)) {
+        registry = JSON.parse(fs.readFileSync(registryFile, 'utf-8'));
+      }
+
+      // Update timestamp
+      registry.last_updated = new Date().toISOString().split('T')[0];
+
+      fs.writeFileSync(registryFile, JSON.stringify(registry, null, 2));
+
+      // Cleanup
+      rimraf(cloneDir);
+
+      log('✅ Official skills list updated', 'green');
+      log(`   Updated: ${registry.last_updated}`, 'gray');
+      log('', 'gray');
+      log('Run: smc skills:official', 'gray');
+    } catch (e) {
+      log('❌ Update failed', 'red');
+      log(`   ${e.message}`, 'gray');
+    }
+  },
+
+  // -------------------------------------------------------------------------
+  config: (action, key, value) => {
+    const fs = require('fs');
+    const path = require('path');
+    const { loadConfig, saveConfig, CONFIG_FILE } = require('./config');
+    const COLORS = {
+      reset: '\x1b[0m',
+      green: '\x1b[32m',
+      blue: '\x1b[34m',
+      yellow: '\x1b[33m',
+      gray: '\x1b[90m',
+      red: '\x1b[31m'
+    };
+
+    const log = (msg, color = 'reset') => {
+      console.log(`${COLORS[color]}${msg}${COLORS.reset}`);
+    };
+
+    if (!action) {
+      // Show current config
+      const config = loadConfig();
+      log('', 'gray');
+      log('⚙️  SMC Configuration', 'blue');
+      log('=====================================', 'gray');
+      log('', 'gray');
+      log(`File: ${CONFIG_FILE}`, 'gray');
+      log('', 'gray');
+      log(JSON.stringify(config, null, 2));
+      log('', 'gray');
+      log('=====================================', 'gray');
+      log('', 'gray');
+      log('Commands:', 'gray');
+      log('  smc config get <key>     Get a config value', 'gray');
+      log('  smc config set <key> <value>  Set a config value', 'gray');
+      log('', 'gray');
+      return;
+    }
+
+    if (action === 'get') {
+      if (!key) {
+        log('Usage: smc config get <key>', 'yellow');
+        return;
+      }
+      const config = loadConfig();
+      const keys = key.split('.');
+      let value = config;
+      for (const k of keys) {
+        value = value?.[k];
+      }
+      if (value !== undefined) {
+        log(`${key}: ${JSON.stringify(value, null, 2)}`, 'green');
+      } else {
+        log(`Key not found: ${key}`, 'yellow');
+      }
+    } else if (action === 'set') {
+      if (!key || value === undefined) {
+        log('Usage: smc config set <key> <value>', 'yellow');
+        return;
+      }
+      const config = loadConfig();
+      const keys = key.split('.');
+      let target = config;
+      for (let i = 0; i < keys.length - 1; i++) {
+        if (!target[keys[i]]) target[keys[i]] = {};
+        target = target[keys[i]];
+      }
+      // Parse value (try JSON, fallback to string)
+      try {
+        target[keys[keys.length - 1]] = JSON.parse(value);
+      } catch {
+        target[keys[keys.length - 1]] = value;
+      }
+      saveConfig(config);
+      log(`✅ Set ${key} = ${target[keys[keys.length - 1]]}`, 'green');
+    } else {
+      log(`Unknown action: ${action}`, 'red');
+      log('Valid actions: get, set', 'gray');
+    }
+  },
+
+  // -------------------------------------------------------------------------
+  'skills:publish': (skillPath) => {
+    const fs = require('fs');
+    const path = require('path');
+    const { execSync } = require('child_process');
+    const COLORS = {
+      reset: '\x1b[0m',
+      green: '\x1b[32m',
+      blue: '\x1b[34m',
+      yellow: '\x1b[33m',
+      gray: '\x1b[90m',
+      red: '\x1b[31m',
+      cyan: '\x1b[36m'
+    };
+
+    const log = (msg, color = 'reset') => {
+      console.log(`${COLORS[color]}${msg}${COLORS.reset}`);
+    };
+
+    // Default to current directory's skills folder
+    const targetPath = skillPath || path.join(process.cwd(), '.claude/skills');
+
+    if (!fs.existsSync(targetPath)) {
+      log(`❌ Path not found: ${targetPath}`, 'red');
+      log('', 'gray');
+      log('Usage: smc skills:publish [skill-path]', 'yellow');
+      log('  Creates a GitHub repo with your skill', 'gray');
+      return;
+    }
+
+    log('', 'gray');
+    log('📦 Publish Skill to GitHub', 'blue');
+    log('=====================================', 'gray');
+    log('', 'gray');
+
+    const readline = require('readline');
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+
+    const question = (prompt) => {
+      return new Promise(resolve => {
+        rl.question(prompt, resolve);
+      });
+    };
+
+    (async () => {
+      // Get skill info
+      const stat = fs.statSync(targetPath);
+      let skillName, skillDir;
+
+      if (stat.isDirectory()) {
+        const skillFile = path.join(targetPath, 'SKILL.md');
+        if (fs.existsSync(skillFile)) {
+          // Single skill directory
+          skillDir = targetPath;
+          skillName = path.basename(targetPath);
+        } else {
+          // Skills directory - ask which skill
+          const entries = fs.readdirSync(targetPath).filter(f => {
+            const dir = path.join(targetPath, f);
+            return fs.statSync(dir).isDirectory() && !f.startsWith('.') && f !== 'template' && f !== 'examples';
+          });
+
+          if (entries.length === 0) {
+            log('❌ No skills found in directory', 'red');
+            rl.close();
+            return;
+          }
+
+          log('Found skills:', 'gray');
+          entries.forEach((e, i) => log(`  ${i + 1}. ${e}`, 'gray'));
+          log('', 'gray');
+
+          const choice = await question('Select skill [1]: ');
+          const index = parseInt(choice || '1') - 1;
+          skillName = entries[index] || entries[0];
+          skillDir = path.join(targetPath, skillName);
+        }
+      } else {
+        log('❌ Path must be a directory', 'red');
+        rl.close();
+        return;
+      }
+
+      // Read SKILL.md to get info
+      const skillFile = path.join(skillDir, 'SKILL.md');
+      if (!fs.existsSync(skillFile)) {
+        log('❌ SKILL.md not found. A skill must have SKILL.md', 'red');
+        rl.close();
+        return;
+      }
+
+      const skillContent = fs.readFileSync(skillFile, 'utf-8');
+      const nameMatch = skillContent.match(/name:\s*(.+)/);
+      const descMatch = skillContent.match(/description:\s*(.+)/);
+      const displayName = nameMatch ? nameMatch[1].trim() : skillName;
+      const description = descMatch ? descMatch[1].trim() : '';
+
+      log(`Skill: ${displayName}`, 'cyan');
+      if (description) {
+        log(`Description: ${description}`, 'gray');
+      }
+      log(`Path: ${skillDir}`, 'gray');
+      log('', 'gray');
+
+      // Get GitHub info
+      const githubUser = await question('GitHub username: ');
+      if (!githubUser) {
+        log('❌ GitHub username required', 'red');
+        rl.close();
+        return;
+      }
+
+      const repoName = await question(`Repository name [${skillName}]: `) || skillName;
+      const isPrivate = await question('Private repo? [y/N]: ');
+
+      rl.close();
+
+      log('', 'gray');
+      log('📝 Instructions:', 'yellow');
+      log('', 'gray');
+      log(`1. Create GitHub repo:`, 'gray');
+      log(`   https://github.com/new`, 'gray');
+      log(`   Name: ${repoName}`, 'gray');
+      log(`   ${isPrivate.toLowerCase() === 'y' ? 'Private' : 'Public'}`, 'gray');
+      log('', 'gray');
+      log(`2. Initialize git and push:`, 'gray');
+      log(`   cd ${skillDir}`, 'gray');
+      log(`   git init`, 'gray');
+      log(`   git add .`, 'gray');
+      log(`   git commit -m "Initial commit"`, 'gray');
+      log(`   git branch -M main`, 'gray');
+      log(`   git remote add origin https://github.com/${githubUser}/${repoName}.git`, 'gray');
+      log(`   git push -u origin main`, 'gray');
+      log('', 'gray');
+      log(`3. Add to sources.yaml:`, 'gray');
+      log(`   - name: ${skillName}`, 'gray');
+      log(`     source:`, 'gray');
+      log(`       repo: ${githubUser}/${repoName}`, 'gray');
+      log(`       path: .`, 'gray');
+      log(`     target:`, 'gray');
+      log(`       category: tools`, 'gray');
+      log(`       path: template/.claude/skills/tools/${skillName}`, 'gray');
+      log('', 'gray');
+
+      // Ask if user wants to auto-execute
+      const autoExecute = await question('Auto-execute git commands? [y/N]: ');
+      if (autoExecute.toLowerCase() === 'y') {
+        try {
+          log('', 'gray');
+          log('Initializing git...', 'gray');
+          execSync('git init', { cwd: skillDir, stdio: 'pipe' });
+          execSync('git add .', { cwd: skillDir, stdio: 'pipe' });
+          execSync('git commit -m "Initial commit"', { cwd: skillDir, stdio: 'pipe' });
+          execSync('git branch -M main', { cwd: skillDir, stdio: 'pipe' });
+          log('✅ Git initialized', 'green');
+
+          log('Adding remote...', 'gray');
+          execSync(`git remote add origin https://github.com/${githubUser}/${repoName}.git`, { cwd: skillDir, stdio: 'pipe' });
+          log('✅ Remote added', 'green');
+
+          log('', 'gray');
+          log('⚠️  Please create the GitHub repo first, then run:', 'yellow');
+          log(`   cd ${skillDir} && git push -u origin main`, 'gray');
+        } catch (e) {
+          log('❌ Failed to initialize git', 'red');
+          log(`   ${e.message}`, 'gray');
+        }
+      }
+
+      log('', 'gray');
+      log('=====================================', 'gray');
+      log('✅ Skill publishing guide complete', 'green');
+      log('', 'gray');
+    })();
+  },
+
+  // -------------------------------------------------------------------------
+  changelog: (...args) => {
+    const fs = require('fs');
+    const path = require('path');
+    const { execSync } = require('child_process');
+    const COLORS = {
+      reset: '\x1b[0m',
+      green: '\x1b[32m',
+      blue: '\x1b[34m',
+      yellow: '\x1b[33m',
+      gray: '\x1b[90m',
+      red: '\x1b[31m',
+      cyan: '\x1b[36m'
+    };
+
+    const log = (msg, color = 'reset') => {
+      console.log(`${COLORS[color]}${msg}${COLORS.reset}`);
+    };
+
+    // Parse options
+    const options = { from: null, to: null, json: false, help: false };
+    for (let i = 0; i < args.length; i++) {
+      if (args[i] === '--from' && args[i + 1]) options.from = args[++i];
+      if (args[i] === '--to' && args[i + 1]) options.to = args[++i];
+      if (args[i] === '--json') options.json = true;
+      if (args[i] === '--help' || args[i] === '-h') options.help = true;
+    }
+
+    if (options.help) {
+      log('', 'gray');
+      log('📝 Changelog Generator', 'blue');
+      log('=====================================', 'gray');
+      log('', 'gray');
+      log('Generate changelog from git commits.', 'gray');
+      log('', 'gray');
+      log('Usage:', 'gray');
+      log('  smc changelog [options]', 'gray');
+      log('', 'gray');
+      log('Options:', 'gray');
+      log('  --from <tag>    Start from this tag (default: last tag)', 'gray');
+      log('  --to <tag>      End at this tag (default: HEAD)', 'gray');
+      log('  --json          Output as JSON', 'gray');
+      log('  --help, -h      Show this help', 'gray');
+      log('', 'gray');
+      log('Examples:', 'gray');
+      log('  smc changelog                    # Changelog since last tag', 'gray');
+      log('  smc changelog --from v1.0.0      # Since v1.0.0', 'gray');
+      log('  smc changelog --from v1.0 --to v1.1  # Range between tags', 'gray');
+      log('  smc changelog --json             # JSON output', 'gray');
+      log('', 'gray');
+      return;
+    }
+
+    // Check if we're in a git repo
+    const projectDir = process.cwd();
+    try {
+      execSync('git rev-parse --git-dir', { stdio: 'ignore', cwd: projectDir });
+    } catch {
+      log('❌ Not a git repository', 'red');
+      return;
+    }
+
+    log('', 'gray');
+    log('📝 Generating Changelog', 'blue');
+    log('=====================================', 'gray');
+    log('', 'gray');
+
+    // Get version range
+    let fromRef = options.from;
+    let toRef = options.to || 'HEAD';
+
+    if (!fromRef) {
+      // Try to get the last tag
+      try {
+        const lastTag = execSync('git describe --tags --abbrev=0', {
+          cwd: projectDir,
+          stdio: 'pipe',
+          encoding: 'utf-8'
+        }).trim();
+        fromRef = lastTag;
+        log(`From: ${lastTag} (last tag)`, 'gray');
+      } catch {
+        // No tags found, use first commit
+        try {
+          const firstCommit = execSync('git rev-list --max-parents=0 HEAD', {
+            cwd: projectDir,
+            stdio: 'pipe',
+            encoding: 'utf-8'
+          }).trim();
+          fromRef = firstCommit;
+          log(`From: ${firstCommit.substring(0, 8)} (first commit)`, 'gray');
+        } catch {
+          fromRef = 'HEAD~10'; // Fallback to last 10 commits
+          log(`From: HEAD~10 (default)`, 'gray');
+        }
+      }
+    } else {
+      log(`From: ${fromRef}`, 'gray');
+    }
+
+    log(`To: ${toRef}`, 'gray');
+    log('', 'gray');
+
+    // Get commit log
+    const range = `${fromRef}..${toRef}`;
+    let commits = [];
+    try {
+      const logOutput = execSync(
+        `git log ${range} --pretty=format:"%H%x1F%s%x1F%an%x1F%ad" --date=short`,
+        { cwd: projectDir, stdio: 'pipe', encoding: 'utf-8' }
+      );
+      commits = logOutput.trim().split('\n').filter(Boolean).map(line => {
+        const [hash, subject, author, date] = line.split('\x1F');
+        return { hash, subject, author, date };
+      });
+    } catch (e) {
+      // Empty range or invalid refs
+      commits = [];
+    }
+
+    if (commits.length === 0) {
+      log('⚠️  No commits found in range', 'yellow');
+      log('', 'gray');
+      return;
+    }
+
+    log(`Found ${commits.length} commit(s)`, 'gray');
+    log('', 'gray');
+
+    // Parse conventional commits
+    const categories = {
+      feat: { name: 'Features', icon: '✨', commits: [] },
+      fix: { name: 'Bug Fixes', icon: '🐛', commits: [] },
+      docs: { name: 'Documentation', icon: '📝', commits: [] },
+      style: { name: 'Styles', icon: '💄', commits: [] },
+      refactor: { name: 'Refactor', icon: '♻️', commits: [] },
+      perf: { name: 'Performance', icon: '⚡', commits: [] },
+      test: { name: 'Tests', icon: '🧪', commits: [] },
+      build: { name: 'Build', icon: '📦', commits: [] },
+      ci: { name: 'CI', icon: '🤖', commits: [] },
+      chore: { name: 'Chores', icon: '🧹', commits: [] },
+      other: { name: 'Other', icon: '📌', commits: [] }
+    };
+
+    const conventionalCommitRegex = /^(\w+)(?:\(([^)]+)\))?:?\s*(.+)$/;
+
+    commits.forEach(commit => {
+      const match = commit.subject.match(conventionalCommitRegex);
+      if (match) {
+        const [, type, scope, description] = match;
+        const category = categories[type] || categories.other;
+        category.commits.push({
+          hash: commit.hash.substring(0, 8),
+          description: description.trim(),
+          scope: scope || null,
+          author: commit.author,
+          date: commit.date
+        });
+      } else {
+        categories.other.commits.push({
+          hash: commit.hash.substring(0, 8),
+          description: commit.subject,
+          scope: null,
+          author: commit.author,
+          date: commit.date
+        });
+      }
+    });
+
+    if (options.json) {
+      // JSON output
+      const jsonOutput = {};
+      for (const [key, category] of Object.entries(categories)) {
+        if (category.commits.length > 0) {
+          jsonOutput[key] = {
+            name: category.name,
+            icon: category.icon,
+            commits: category.commits
+          };
+        }
+      }
+      console.log(JSON.stringify(jsonOutput, null, 2));
+      return;
+    }
+
+    // Markdown output
+    const today = new Date().toISOString().split('T')[0];
+
+    // Check if CHANGELOG.md exists and append
+    const changelogFile = path.join(projectDir, 'CHANGELOG.md');
+
+    let existingContent = '';
+    if (fs.existsSync(changelogFile)) {
+      existingContent = fs.readFileSync(changelogFile, 'utf-8');
+    }
+
+    // Generate new entry
+    let newEntry = `## [Unreleased] (${today})\n\n`;
+
+    for (const [key, category] of Object.entries(categories)) {
+      if (category.commits.length > 0) {
+        newEntry += `### ${category.icon} ${category.name}\n\n`;
+        category.commits.forEach(commit => {
+          const scopeStr = commit.scope ? `**${commit.scope}**: ` : '';
+          newEntry += `- ${scopeStr}${commit.description} (${commit.hash})\n`;
+        });
+        newEntry += '\n';
+      }
+    }
+
+    // Write or append
+    if (existingContent) {
+      // Check if unreleased section exists
+      const unreleasedRegex = /## \[Unreleased\].*?\n\n([\s\S]*?)(?=## \[|$)/;
+      const match = existingContent.match(unreleasedRegex);
+
+      if (match) {
+        // Replace existing unreleased section
+        const updatedContent = existingContent.replace(
+          unreleasedRegex,
+          newEntry.trimEnd() + '\n\n'
+        );
+        fs.writeFileSync(changelogFile, updatedContent);
+        log('✅ Updated [Unreleased] section in CHANGELOG.md', 'green');
+      } else {
+        // Prepend to existing content
+        const newContent = newEntry + existingContent;
+        fs.writeFileSync(changelogFile, newContent);
+        log('✅ Added to CHANGELOG.md', 'green');
+      }
+    } else {
+      // Create new CHANGELOG.md
+      const header = `# Changelog
+
+All notable changes to this project will be documented in this file.
+
+`;
+      fs.writeFileSync(changelogFile, header + newEntry);
+      log('✅ Created CHANGELOG.md', 'green');
+    }
+
+    log('', 'gray');
+    log('📄 Preview:', 'gray');
+    log('', 'gray');
+    console.log(newEntry);
+
+    log('=====================================', 'gray');
+    log('', 'gray');
+  },
+
+  // ==========================================================================
+  // Quality Gate Commands
+  // ==========================================================================
+
+  'qg:check': async (severity = 'warn') => {
+    const { QualityGate } = require('./quality-gate');
+    const gate = new QualityGate({ projectDir: process.cwd() });
+    const result = await gate.check({ severity });
+    process.exit(result.passed ? 0 : 1);
+  },
+
+  'qg:rules': () => {
+    const registry = require('./quality-rules').registry;
+    const rules = registry.getAll();
+
+    console.log('📋 Available Quality Rules');
+    console.log('');
+    console.log('Rules are checked when running quality gate:');
+    console.log('');
+
+    const byCategory = {};
+    for (const rule of rules) {
+      if (!byCategory[rule.category]) byCategory[rule.category] = [];
+      byCategory[rule.category].push(rule);
+    }
+
+    for (const [category, rules] of Object.entries(byCategory)) {
+      console.log(`${category.toUpperCase()}:`);
+      for (const rule of rules) {
+        const status = rule.enabled ? '✅' : '⊝';
+        const sev = { info: 'I', warn: 'W', error: 'E', critical: 'X' }[rule.severity];
+        console.log(`  ${status} ${rule.id} [${sev}] - ${rule.name}`);
+      }
+      console.log('');
+    }
+  },
+
+  'qg:init': () => {
+    const projectDir = process.cwd();
+    const configDir = path.join(projectDir, '.claude');
+    const targetPath = path.join(configDir, 'quality-gate.json');
+    const sourcePath = path.join(__dirname, '../config/quality-gate.json');
+
+    if (fs.existsSync(targetPath)) {
+      console.log('⚠️  quality-gate.json already exists');
+      return;
+    }
+
+    ensureDir(configDir);
+    fs.copyFileSync(sourcePath, targetPath);
+    console.log('✅ Created .claude/quality-gate.json');
+    console.log('');
+    console.log('To enable Git hooks:');
+    console.log('  ln -s .claude/hooks/pre-commit.cjs .git/hooks/pre-commit');
+    console.log('  ln -s .claude/hooks/pre-push.cjs .git/hooks/pre-push');
+  },
+
+  // ==========================================================================
+  // Config Commands
+  // ==========================================================================
+
+  'config:validate': () => {
+    const { ConfigValidator } = require('./config-validator');
+    const validator = new ConfigValidator();
+
+    console.log('🔍 Validating configuration...');
+    console.log('');
+
+    let hasErrors = false;
+    let hasWarnings = false;
+
+    // Check global config
+    const globalConfigPath = path.join(process.env.HOME, '.claude', 'config.json');
+    console.log(`Global: ${globalConfigPath}`);
+    const globalResult = validator.validateFile(globalConfigPath);
+
+    if (globalResult.valid) {
+      console.log('  ✅ Valid');
+    } else {
+      if (globalResult.errors.length > 0) {
+        hasErrors = true;
+        console.log(`  ❌ ${globalResult.errors.length} error(s)`);
+        globalResult.errors.forEach(e => {
+          console.log(`     [${e.severity}] ${e.path}: ${e.message}`);
+        });
+      }
+      if (globalResult.warnings.length > 0) {
+        hasWarnings = true;
+        console.log(`  ⚠️  ${globalResult.warnings.length} warning(s)`);
+        globalResult.warnings.forEach(e => {
+          console.log(`     [${e.severity}] ${e.path}: ${e.message}`);
+        });
+      }
+      if (globalResult.errors.length === 0 && globalResult.warnings.length === 0) {
+        console.log('  ❌ Validation failed');
+      }
+    }
+    console.log('');
+
+    // Check project config if in project
+    const projectDir = process.cwd();
+    const projectConfigPath = path.join(projectDir, '.claude', 'settings.json');
+    if (fs.existsSync(projectConfigPath)) {
+      console.log(`Project: ${projectConfigPath}`);
+      const projectResult = validator.validateFile(projectConfigPath, 'settings');
+      if (projectResult.valid) {
+        console.log('  ✅ Valid');
+      } else {
+        if (projectResult.errors.length > 0) {
+          hasErrors = true;
+          console.log(`  ❌ ${projectResult.errors.length} error(s)`);
+          projectResult.errors.forEach(e => {
+            console.log(`     [${e.severity}] ${e.path}: ${e.message}`);
+          });
+        }
+        if (projectResult.warnings.length > 0) {
+          hasWarnings = true;
+          console.log(`  ⚠️  ${projectResult.warnings.length} warning(s)`);
+          projectResult.warnings.forEach(e => {
+            console.log(`     [${e.severity}] ${e.path}: ${e.message}`);
+          });
+        }
+        if (projectResult.errors.length === 0 && projectResult.warnings.length === 0) {
+          console.log('  ❌ Validation failed');
+        }
+      }
+    }
+    console.log('');
+
+    if (hasErrors) {
+      console.log('❌ Configuration validation failed');
+      process.exit(1);
+    } else if (hasWarnings) {
+      console.log('⚠️  Configuration has warnings (but is valid)');
+    } else {
+      console.log('✅ All configurations are valid');
+    }
+  },
+
+  'config:backup': () => {
+    const { ConfigManager } = require('./config-manager');
+    const manager = new ConfigManager();
+    const backupPath = manager._createBackup();
+    console.log('✅ Config backed up to:', backupPath);
+  },
+
+  'config:rollback': (version) => {
+    const { ConfigManager } = require('./config-manager');
+    const manager = new ConfigManager();
+
+    const backups = manager.listBackups();
+    if (backups.length === 0) {
+      console.log('❌ No backups available');
+      return;
+    }
+
+    if (!version) {
+      console.log('Available backups:');
+      backups.forEach((b, i) => {
+        console.log(`  ${i + 1}. ${b.version} (${new Date(b.timestamp).toLocaleString()})`);
+      });
+      console.log('');
+      console.log('Usage: smc config:rollback <version>');
+      return;
+    }
+
+    try {
+      const result = manager.rollback(version);
+      console.log('✅ Rolled back to:', result.restoredFrom);
+    } catch (e) {
+      console.log('❌', e.message);
+    }
+  },
+
+  'config:diff': (file1, file2) => {
+    const { ConfigManager } = require('./config-manager');
+    const manager = new ConfigManager();
+
+    if (!file1) {
+      const backups = manager.listBackups();
+      if (backups.length === 0) {
+        console.log('❌ No backups available');
+        return;
+      }
+      file1 = path.join(manager.backupDir, backups[0].file);
+      file2 = null; // Current config
+    }
+
+    const changes = manager.diff(file1, file2);
+    if (changes.length === 0) {
+      console.log('✅ No differences found');
+      return;
+    }
+
+    console.log('📊 Config Diff:');
+    console.log('');
+    for (const change of changes) {
+      const icon = { added: '+', removed: '-', changed: '~' }[change.type];
+      console.log(`  ${icon} ${change.path}`);
+      if (change.type !== 'removed') {
+        console.log(`     from: ${JSON.stringify(change.from)}`);
+      }
+      if (change.type !== 'added') {
+        console.log(`     to:   ${JSON.stringify(change.to)}`);
+      }
+    }
   }
 };
 
@@ -754,10 +2580,10 @@ sumulige-claude skill:list
  * @param {string} cmd - Command name
  * @param {Array} args - Command arguments
  */
-function runCommand(cmd, args) {
+async function runCommand(cmd, args) {
   const command = commands[cmd];
   if (command) {
-    command(...args);
+    await command(...args);
   }
 }