supermind-claude 2.1.1 → 4.0.2

package/cli/commands/skill.js

@@ -0,0 +1,164 @@
+'use strict';
+
+const logger = require('../lib/logger');
+const vendorSkills = require('../lib/vendor-skills');
+
+module.exports = async function skill(flags) {
+  const subcommand = (flags.args && flags.args[0]) || '';
+  const target = flags.args && flags.args[1];
+
+  switch (subcommand) {
+    case 'add':
+      return handleAdd(target, flags);
+    case 'update':
+      return handleUpdate(target, flags);
+    case 'list':
+      return handleList();
+    case 'remove':
+      return handleRemove(target);
+    default:
+      showHelp();
+  }
+};
+
+// ---------------------------------------------------------------------------
+// handleAdd
+// ---------------------------------------------------------------------------
+
+function handleAdd(url, flags) {
+  if (!url) {
+    logger.error('Specify a GitHub URL: supermind-claude skill add <github-url> [--global]');
+    return;
+  }
+
+  try {
+    const result = vendorSkills.addSkill(url, { global: !!flags.global });
+    console.log('');
+    logger.success(`Installed ${result.installed.length} skill(s) from ${result.source}`);
+    for (const name of result.installed) {
+      logger.info(`  - ${name}`);
+    }
+    logger.info(`Commit: ${result.commit}`);
+    console.log('');
+  } catch (err) {
+    logger.error(err.message);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// handleUpdate
+// ---------------------------------------------------------------------------
+
+function handleUpdate(name, flags) {
+  try {
+    if (flags.all) {
+      const result = vendorSkills.updateAll();
+      console.log('');
+      if (result.results.length === 0) {
+        logger.info('No vendor skills installed');
+        return;
+      }
+      logger.success(`Updated ${result.results.filter(r => r.updated).length} skill(s)`);
+      for (const r of result.results) {
+        if (r.error) {
+          logger.warn(`${r.name}: ${r.error}`);
+        } else if (r.updated) {
+          logger.success(`  - ${r.name}: ${r.message || 'Updated'}`);
+        } else {
+          logger.info(`  - ${r.name}: ${r.message || 'No changes'}`);
+        }
+      }
+      console.log('');
+    } else if (name) {
+      const result = vendorSkills.updateSkill(name);
+      console.log('');
+      if (result.updated) {
+        logger.success(`Updated: ${name}`);
+      } else {
+        logger.info(`${name}: ${result.message || 'No changes'}`);
+      }
+      console.log('');
+    } else {
+      logger.error('Specify a skill name or use --all: supermind-claude skill update <name> [--all]');
+    }
+  } catch (err) {
+    logger.error(err.message);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// handleList
+// ---------------------------------------------------------------------------
+
+function handleList() {
+  try {
+    const skills = vendorSkills.listSkills();
+    console.log('');
+    if (skills.length === 0) {
+      logger.info('No vendor skills installed');
+      console.log('');
+      return;
+    }
+
+    // Format as simple table
+    console.log('  Vendor Skills:\n');
+    const maxNameLen = Math.max(...skills.map(s => s.name.length));
+    const maxSourceLen = Math.max(...skills.map(s => s.source.length));
+    const maxScopeLen = Math.max(...skills.map(s => s.scope.length));
+
+    for (const skill of skills) {
+      const padName = skill.name.padEnd(maxNameLen);
+      const padSource = skill.source.padEnd(maxSourceLen);
+      const padScope = skill.scope.padEnd(maxScopeLen);
+      const commit = skill.commit.substring(0, 8);
+      console.log(`    ${padName}  ${padSource}  ${padScope}  ${commit}`);
+    }
+    console.log('');
+  } catch (err) {
+    logger.error(err.message);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// handleRemove
+// ---------------------------------------------------------------------------
+
+function handleRemove(name) {
+  if (!name) {
+    logger.error('Specify a skill name: supermind-claude skill remove <name>');
+    return;
+  }
+
+  try {
+    vendorSkills.removeSkill(name);
+    console.log('');
+    logger.success(`Removed: ${name}`);
+    console.log('');
+  } catch (err) {
+    logger.error(err.message);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// showHelp
+// ---------------------------------------------------------------------------
+
+function showHelp() {
+  console.log(`
+  Usage: supermind-claude skill <command> [args]
+
+  Commands:
+    add <github-url> [--global]   Install skill from GitHub
+    update [name] [--all]         Update skill(s) from source
+    list                          Show installed vendor skills
+    remove <name>                 Remove a vendor skill
+
+  Examples:
+    supermind-claude skill add https://github.com/owner/repo
+    supermind-claude skill add github.com/owner/repo --global
+    supermind-claude skill update my-skill
+    supermind-claude skill update --all
+    supermind-claude skill list
+    supermind-claude skill remove my-skill
+`);
+}

package/cli/commands/uninstall.js

@@ -1,13 +1,15 @@
 'use strict';
 
 const fs = require('fs');
+const path = require('path');
 const readline = require('readline');
 const { PATHS } = require('../lib/platform');
 const logger = require('../lib/logger');
 const { readSettings, writeSettings, removeSupermindEntries, backupSettings } = require('../lib/settings');
 const { removeHooks } = require('../lib/hooks');
-const { removeSkills } = require('../lib/skills');
+const { removeSkills, removeAgents } = require('../lib/skills');
 const { removeTemplates } = require('../lib/templates');
+const { removePlugin } = require('../lib/plugin');
 
 function prompt(question) {
   const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
@@ -31,14 +33,19 @@ module.exports = async function uninstall(flags) {
   console.log('  Removing hooks...');
   removeHooks();
 
-  // Remove skills
-  console.log('  Removing skills...');
+  // Remove skills and agents
+  console.log('  Removing skills and agents...');
   removeSkills();
+  removeAgents();
 
   // Remove templates
   console.log('  Removing templates...');
   removeTemplates();
 
+  // Remove plugin registration
+  console.log('  Removing plugin registration...');
+  removePlugin();
+
   // Clean settings
   console.log('  Cleaning settings...');
   backupSettings();
@@ -47,6 +54,13 @@ module.exports = async function uninstall(flags) {
   writeSettings(cleaned);
   logger.success('Settings cleaned');
 
+  // Remove vendor skills lock file
+  const skillsLockPath = path.join(PATHS.claudeHome, 'skills-lock.json');
+  if (fs.existsSync(skillsLockPath)) {
+    fs.unlinkSync(skillsLockPath);
+    logger.success('Removed vendor skills lock file');
+  }
+
   // Remove version marker
   if (fs.existsSync(PATHS.versionFile)) {
     fs.unlinkSync(PATHS.versionFile);
@@ -72,5 +86,20 @@ module.exports = async function uninstall(flags) {
     }
   }
 
+  // Optional: Improvement log
+  const improvementLog = path.join(PATHS.claudeHome, 'improvement-log.jsonl');
+  if (fs.existsSync(improvementLog)) {
+    if (flags.yes || flags.nonInteractive) {
+      fs.unlinkSync(improvementLog);
+      logger.success('Removed improvement log');
+    } else {
+      const answer = await prompt('  Also remove improvement log? [y/N]: ');
+      if (answer.toLowerCase() === 'y') {
+        fs.unlinkSync(improvementLog);
+        logger.success('Removed improvement log');
+      }
+    }
+  }
+
   console.log(`\n${'\x1b[32m'}\u2713 Supermind uninstalled${'\x1b[0m'}\n`);
 };

package/cli/commands/update.js

@@ -5,9 +5,10 @@ const { PATHS } = require('../lib/platform');
 const logger = require('../lib/logger');
 const { readSettings, writeSettings, mergeSettings, backupSettings } = require('../lib/settings');
 const { installHooks, getHookSettings } = require('../lib/hooks');
-const { installSkills, removeLegacySkills } = require('../lib/skills');
+const { installSkills, removeLegacySkills, installAgents } = require('../lib/skills');
 const { installTemplates } = require('../lib/templates');
 const { detectMcpMode } = require('../lib/mcp');
+const { installPlugin } = require('../lib/plugin');
 const { version } = require('../../package.json');
 
 module.exports = function update(flags) {
@@ -23,7 +24,7 @@ module.exports = function update(flags) {
     logger.info(`Updating from v${installedVersion} to v${version}...`);
   }
 
-  const TOTAL = 4;
+  const TOTAL = 6;
 
   // Step 1: Hooks
   logger.step(1, TOTAL, 'Updating hooks...');
@@ -38,15 +39,35 @@ module.exports = function update(flags) {
   writeSettings(merged);
   logger.success('Hook settings refreshed');
 
-  // Step 3: Skills
-  logger.step(3, TOTAL, 'Updating skills...');
+  // Step 3: Skills & agents
+  logger.step(3, TOTAL, 'Updating skills and agents...');
   removeLegacySkills();
   installSkills();
+  installAgents();
 
   // Step 4: Templates
   logger.step(4, TOTAL, 'Updating templates...');
   installTemplates(detectMcpMode());
 
+  // Step 5: Plugin manifest
+  logger.step(5, TOTAL, 'Updating plugin manifest...');
+  installPlugin();
+
+  // Step 6: Vendor skills check
+  logger.step(6, TOTAL, 'Checking vendor skills...');
+  try {
+    const vendorSkills = require('../lib/vendor-skills');
+    const globalLock = vendorSkills.readLockFile('global');
+    const skillCount = Object.keys(globalLock.skills || {}).length;
+    if (skillCount > 0) {
+      logger.info(`${skillCount} vendor skill(s) tracked (run 'supermind skill update --all' to refresh)`);
+    } else {
+      logger.info('No vendor skills installed');
+    }
+  } catch {
+    logger.info('Vendor skill check skipped');
+  }
+
   // Write version marker
   fs.writeFileSync(PATHS.versionFile, version);
 

package/cli/index.js

@@ -9,12 +9,15 @@ const COMMANDS = {
   doctor: () => require('./commands/doctor'),
   uninstall: () => require('./commands/uninstall'),
   approve: () => require('./commands/approve'),
+  skill: () => require('./commands/skill'),
 };
 
 function parseArgs(argv) {
   const args = argv.slice(2);
   const flags = {};
-  let command = 'install'; // default
+  const positionalArgs = [];
+  let command = null; // no default — show help when no command given
+  let commandFound = false;
 
   for (let i = 0; i < args.length; i++) {
     const arg = args[i];
@@ -25,9 +28,15 @@ function parseArgs(argv) {
     if (arg === '--mcp' && args[i + 1]) { flags.mcp = args[++i]; continue; }
     if (arg === '--list' || arg === '-l') { flags.list = true; continue; }
     if (arg === '--remove' || arg === '-r') { flags.remove = true; continue; }
-    if (!arg.startsWith('-') && COMMANDS[arg]) { command = arg; continue; }
+    if (arg === '--global') { flags.global = true; continue; }
+    if (arg === '--all') { flags.all = true; continue; }
+    if (!arg.startsWith('-')) {
+      if (!commandFound && COMMANDS[arg]) { command = arg; commandFound = true; continue; }
+      positionalArgs.push(arg);
+    }
   }
 
+  flags.args = positionalArgs;
   return { command, flags };
 }
 
@@ -38,16 +47,19 @@ function showHelp() {
   Usage: supermind-claude [command] [options]
 
   Commands:
-    install     Full global setup (default)
+    install     Full global setup
     update      Refresh hooks, skills, and templates
     doctor      Verify installation health
     uninstall   Remove all Supermind components
     approve     Manage auto-approved commands
+    skill       Manage vendor skills (add/update/list/remove)
 
   Options:
     --non-interactive   Skip all prompts, use defaults
     --mcp <mode>        MCP setup: docker, direct, or skip
     --yes, -y           Auto-confirm destructive operations
+    --global            Apply to global installation
+    --all               Apply to all items
     --help, -h          Show this help
     --version, -v       Show version
 `);
@@ -57,7 +69,7 @@ async function main() {
   const { command, flags } = parseArgs(process.argv);
 
   if (flags.version) { console.log(version); process.exit(0); }
-  if (flags.help) { showHelp(); process.exit(0); }
+  if (flags.help || !command) { showHelp(); process.exit(0); }
 
   const run = COMMANDS[command]();
   await run(flags);