supermind-claude 2.0.0

package/cli/lib/hooks.js

@@ -0,0 +1,66 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { PATHS, ensureDir, getPackageRoot } = require('./platform');
+const logger = require('./logger');
+
+function getHookFiles() {
+  const hooksSource = path.join(getPackageRoot(), 'hooks');
+  return fs.readdirSync(hooksSource).filter(f => f.endsWith('.js'));
+}
+
+function installHooks() {
+  ensureDir(PATHS.hooksDir);
+  const hooksSource = path.join(getPackageRoot(), 'hooks');
+  const files = getHookFiles();
+
+  for (const file of files) {
+    fs.copyFileSync(path.join(hooksSource, file), path.join(PATHS.hooksDir, file));
+    logger.success(file);
+  }
+  return files;
+}
+
+function getHookSettings() {
+  const hooksDir = PATHS.hooksDir;
+  return {
+    hooks: {
+      PreToolUse: [{
+        matcher: 'Bash',
+        hooks: [{ type: 'command', command: `node "${path.join(hooksDir, 'bash-permissions.js')}"`, timeout: 5 }],
+      }],
+      SessionStart: [{
+        hooks: [{ type: 'command', command: `node "${path.join(hooksDir, 'session-start.js')}"`, statusMessage: 'Loading session context...' }],
+      }],
+      Stop: [{
+        hooks: [
+          { type: 'command', command: `node "${path.join(hooksDir, 'session-end.js')}"`, async: true },
+          { type: 'command', command: `node "${path.join(hooksDir, 'cost-tracker.js')}"`, async: true },
+        ],
+      }],
+    },
+    statusLine: {
+      type: 'command',
+      command: `node "${path.join(hooksDir, 'statusline-command.js')}"`,
+    },
+  };
+}
+
+// Fallback list if package source is unavailable
+const KNOWN_HOOKS = ['bash-permissions.js', 'session-start.js', 'session-end.js', 'cost-tracker.js', 'statusline-command.js'];
+
+function removeHooks() {
+  if (!fs.existsSync(PATHS.hooksDir)) return;
+  let files;
+  try { files = getHookFiles(); } catch { files = KNOWN_HOOKS; }
+  for (const file of files) {
+    const target = path.join(PATHS.hooksDir, file);
+    if (fs.existsSync(target)) {
+      fs.unlinkSync(target);
+      logger.success(`Removed ${file}`);
+    }
+  }
+}
+
+module.exports = { installHooks, getHookSettings, removeHooks, getHookFiles };

package/cli/lib/logger.js

@@ -0,0 +1,38 @@
+'use strict';
+
+const { version } = require('../../package.json');
+
+const GREEN = '\x1b[32m';
+const YELLOW = '\x1b[33m';
+const RED = '\x1b[31m';
+const DIM = '\x1b[2m';
+const BOLD = '\x1b[1m';
+const CYAN = '\x1b[36m';
+const R = '\x1b[0m';
+
+function banner() {
+  console.log(`\n${CYAN}${BOLD}  \u26a1 Supermind${R} ${DIM}v${version}${R}`);
+  console.log(`${DIM}  Complete Claude Code setup${R}\n`);
+}
+
+function step(n, total, message) {
+  console.log(`${DIM}[${n}/${total}]${R} ${message}`);
+}
+
+function success(message) {
+  console.log(`  ${GREEN}\u2713${R} ${message}`);
+}
+
+function warn(message) {
+  console.log(`  ${YELLOW}\u26a0${R} ${message}`);
+}
+
+function error(message) {
+  console.log(`  ${RED}\u2717${R} ${message}`);
+}
+
+function info(message) {
+  console.log(`  ${DIM}${message}${R}`);
+}
+
+module.exports = { banner, step, success, warn, error, info };

package/cli/lib/mcp.js

@@ -0,0 +1,112 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const readline = require('readline');
+const { execSync } = require('child_process');
+const { PATHS, ensureDir, getPackageRoot } = require('./platform');
+const logger = require('./logger');
+
+function prompt(question) {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise(resolve => rl.question(question, answer => { rl.close(); resolve(answer.trim()); }));
+}
+
+function isDockerAvailable() {
+  try {
+    execSync('docker compose version', { stdio: 'pipe', timeout: 5000 });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function getDirectMcpConfig() {
+  const configPath = path.join(getPackageRoot(), 'airis', 'mcp-config.json');
+  return JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+}
+
+async function setupDocker() {
+  const airisSource = path.join(getPackageRoot(), 'airis');
+  ensureDir(PATHS.airisDir);
+  for (const file of ['docker-compose.yml', 'mcp-config.json']) {
+    const src = path.join(airisSource, file);
+    if (fs.existsSync(src)) {
+      fs.copyFileSync(src, path.join(PATHS.airisDir, file));
+    }
+  }
+  logger.success('AIRIS config copied');
+
+  if (isDockerAvailable()) {
+    logger.info('Starting AIRIS gateway...');
+    try {
+      execSync('docker compose up -d', { cwd: PATHS.airisDir, stdio: 'pipe', timeout: 60000 });
+      logger.success('AIRIS gateway started');
+    } catch {
+      logger.warn('Could not start AIRIS gateway — start manually with: docker compose up -d');
+    }
+  } else {
+    logger.warn('Docker not found — install Docker and run: docker compose up -d');
+  }
+}
+
+async function promptApiKeys(flags) {
+  const keys = {};
+  if (flags.nonInteractive) return keys;
+
+  const tavily = await prompt('  Tavily API key (press Enter to skip): ');
+  if (tavily) keys.TAVILY_API_KEY = tavily;
+
+  return keys;
+}
+
+function setupDirect(apiKeys) {
+  const config = getDirectMcpConfig();
+  const servers = config.mcpServers || {};
+
+  // Inject API keys into server configs that need them
+  if (apiKeys.TAVILY_API_KEY && servers.tavily) {
+    servers.tavily.env = { TAVILY_API_KEY: apiKeys.TAVILY_API_KEY };
+  }
+
+  // Remove servers that require missing API keys
+  if (!apiKeys.TAVILY_API_KEY && servers.tavily?.env?.TAVILY_API_KEY?.startsWith('$')) {
+    logger.warn('Skipping Tavily (no API key)');
+    delete servers.tavily;
+  }
+
+  return servers;
+}
+
+async function setupMcp(flags) {
+  // Determine mode from flags or prompt
+  let mode = flags.mcp;
+  if (!mode && !flags.nonInteractive) {
+    console.log('\n  MCP Server Setup:');
+    console.log('    1) Docker (AIRIS gateway — single endpoint, recommended)');
+    console.log('    2) Direct (individual servers via npx/uvx)');
+    console.log('    3) Skip\n');
+    const answer = await prompt('  Choose [1/2/3]: ');
+    mode = { '1': 'docker', '2': 'direct', '3': 'skip' }[answer] || 'skip';
+  }
+  if (!mode || mode === 'skip') {
+    logger.info('Skipping MCP setup');
+    return {};
+  }
+
+  if (mode === 'docker') {
+    await setupDocker();
+    return {}; // Docker mode uses AIRIS, not settings.json mcpServers
+  }
+
+  if (mode === 'direct') {
+    const apiKeys = await promptApiKeys(flags);
+    const servers = setupDirect(apiKeys);
+    logger.success(`Configured ${Object.keys(servers).length} MCP servers`);
+    return { mcpServers: servers };
+  }
+
+  return {};
+}
+
+module.exports = { setupMcp };

package/cli/lib/platform.js

@@ -0,0 +1,31 @@
+'use strict';
+
+const path = require('path');
+const os = require('os');
+const fs = require('fs');
+
+const home = os.homedir();
+
+const PATHS = {
+  claudeHome: path.join(home, '.claude'),
+  settings: path.join(home, '.claude', 'settings.json'),
+  settingsBackup: path.join(home, '.claude', 'settings.json.backup'),
+  hooksDir: path.join(home, '.claude', 'hooks'),
+  skillsDir: path.join(home, '.claude', 'skills'),
+  templatesDir: path.join(home, '.claude', 'templates'),
+  sessionsDir: path.join(home, '.claude', 'sessions'),
+  versionFile: path.join(home, '.claude', '.supermind-version'),
+  legacyHooksJson: path.join(home, '.claude', 'hooks.json'),
+  airisDir: path.join(home, '.claude', 'airis'),
+};
+
+function ensureDir(dirPath) {
+  fs.mkdirSync(dirPath, { recursive: true });
+}
+
+// Note: assumes platform.js is at cli/lib/platform.js (two levels deep from package root)
+function getPackageRoot() {
+  return path.resolve(__dirname, '..', '..');
+}
+
+module.exports = { PATHS, ensureDir, getPackageRoot };

package/cli/lib/plugins.js

@@ -0,0 +1,19 @@
+'use strict';
+
+function getPluginDefaults() {
+  return {
+    enabledPlugins: {
+      'superpowers@claude-plugins-official': true,
+      'claude-md-management@claude-plugins-official': true,
+      'frontend-design@claude-plugins-official': true,
+      'ui-ux-pro-max@ui-ux-pro-max-skill': true,
+    },
+    extraKnownMarketplaces: {
+      'ui-ux-pro-max-skill': {
+        source: { source: 'github', repo: 'nextlevelbuilder/ui-ux-pro-max-skill' },
+      },
+    },
+  };
+}
+
+module.exports = { getPluginDefaults };

package/cli/lib/settings.js

@@ -0,0 +1,158 @@
+'use strict';
+
+const fs = require('fs');
+const { PATHS } = require('./platform');
+const logger = require('./logger');
+
+// Known Supermind hook filenames — used to identify owned entries
+const SUPERMIND_HOOKS = [
+  'bash-permissions.js', 'session-start.js', 'session-end.js',
+  'cost-tracker.js', 'statusline-command.js',
+];
+
+const SUPERMIND_PLUGINS = [
+  'superpowers@claude-plugins-official',
+  'claude-md-management@claude-plugins-official',
+  'frontend-design@claude-plugins-official',
+  'ui-ux-pro-max@ui-ux-pro-max-skill',
+];
+
+function readSettings() {
+  try {
+    return JSON.parse(fs.readFileSync(PATHS.settings, 'utf-8'));
+  } catch {
+    return {};
+  }
+}
+
+function writeSettings(settings) {
+  fs.writeFileSync(PATHS.settings, JSON.stringify(settings, null, 2) + '\n');
+}
+
+function backupSettings() {
+  if (fs.existsSync(PATHS.settings) && !fs.existsSync(PATHS.settingsBackup)) {
+    fs.copyFileSync(PATHS.settings, PATHS.settingsBackup);
+    logger.info('Backed up existing settings.json');
+  }
+}
+
+function isSupermindHookEntry(entry) {
+  const cmd = entry?.command || '';
+  return SUPERMIND_HOOKS.some(h => cmd.includes(h));
+}
+
+// Merge hook arrays: keep user entries, upsert Supermind entries by filename match
+function mergeHookArray(existing, incoming) {
+  const result = (existing || []).filter(e => !isSupermindHookEntry(e));
+  for (const entry of incoming) {
+    result.push(entry);
+  }
+  return result;
+}
+
+// Merge objects: add missing keys, preserve existing
+function mergeObjects(existing, incoming) {
+  const result = { ...existing };
+  for (const [key, val] of Object.entries(incoming)) {
+    if (!(key in result)) result[key] = val;
+  }
+  return result;
+}
+
+// Merge hook event configs: each event has a { matcher?, hooks: [] } structure
+function mergeHookEvents(existing, incoming) {
+  const result = { ...existing };
+  for (const [event, configs] of Object.entries(incoming)) {
+    if (!result[event]) {
+      result[event] = configs;
+      continue;
+    }
+    // Merge each config entry's hooks array
+    const existingConfigs = Array.isArray(result[event]) ? result[event] : [result[event]];
+    const incomingConfigs = Array.isArray(configs) ? configs : [configs];
+
+    for (const inConfig of incomingConfigs) {
+      const matcher = inConfig.matcher || null;
+      const existingIdx = existingConfigs.findIndex(c => (c.matcher || null) === matcher);
+      if (existingIdx >= 0) {
+        existingConfigs[existingIdx] = {
+          ...existingConfigs[existingIdx],
+          hooks: mergeHookArray(existingConfigs[existingIdx].hooks, inConfig.hooks),
+        };
+      } else {
+        existingConfigs.push(inConfig);
+      }
+    }
+    result[event] = existingConfigs;
+  }
+  return result;
+}
+
+function mergeSettings(existing, defaults) {
+  const result = { ...existing };
+
+  // Scalars: set only if absent
+  for (const key of ['alwaysThinkingEnabled', 'effortLevel', 'voiceEnabled', 'skipDangerousModePermissionPrompt']) {
+    if (!(key in result) && key in defaults) result[key] = defaults[key];
+  }
+
+  // Supermind-owned (always overwrite)
+  if (defaults.statusLine) result.statusLine = defaults.statusLine;
+
+  // Objects: recursive merge
+  if (defaults.permissions) result.permissions = mergeObjects(result.permissions || {}, defaults.permissions);
+  if (defaults.enabledPlugins) result.enabledPlugins = mergeObjects(result.enabledPlugins || {}, defaults.enabledPlugins);
+  if (defaults.extraKnownMarketplaces) result.extraKnownMarketplaces = mergeObjects(result.extraKnownMarketplaces || {}, defaults.extraKnownMarketplaces);
+
+  // Hooks: special merge
+  if (defaults.hooks) result.hooks = mergeHookEvents(result.hooks || {}, defaults.hooks);
+
+  return result;
+}
+
+// Remove Supermind entries from settings (for uninstall)
+function removeSupermindEntries(settings) {
+  const result = { ...settings };
+
+  // Remove statusLine
+  delete result.statusLine;
+
+  // Remove Supermind plugins
+  if (result.enabledPlugins) {
+    for (const id of SUPERMIND_PLUGINS) {
+      delete result.enabledPlugins[id];
+    }
+  }
+
+  // Remove Supermind marketplace entries
+  if (result.extraKnownMarketplaces) {
+    delete result.extraKnownMarketplaces['ui-ux-pro-max-skill'];
+  }
+
+  // Remove Supermind hooks from each event
+  if (result.hooks) {
+    for (const [event, configs] of Object.entries(result.hooks)) {
+      const configArr = Array.isArray(configs) ? configs : [configs];
+      for (const config of configArr) {
+        if (config.hooks) {
+          config.hooks = config.hooks.filter(h => !isSupermindHookEntry(h));
+        }
+      }
+      // Clean up empty configs
+      result.hooks[event] = configArr.filter(c => c.hooks?.length > 0);
+      if (result.hooks[event].length === 0) delete result.hooks[event];
+    }
+    if (Object.keys(result.hooks).length === 0) delete result.hooks;
+  }
+
+  // Note: do NOT delete scalars like alwaysThinkingEnabled/effortLevel —
+  // the user may have set these independently. Supermind only sets them if absent.
+
+  return result;
+}
+
+module.exports = {
+  readSettings, writeSettings, backupSettings,
+  mergeSettings, removeSupermindEntries,
+  SUPERMIND_HOOKS, SUPERMIND_PLUGINS,
+};

package/cli/lib/skills.js

@@ -0,0 +1,70 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { PATHS, ensureDir, getPackageRoot } = require('./platform');
+const logger = require('./logger');
+
+function getSkillDirs() {
+  const skillsSource = path.join(getPackageRoot(), 'skills');
+  return fs.readdirSync(skillsSource).filter(f =>
+    fs.statSync(path.join(skillsSource, f)).isDirectory()
+  );
+}
+
+function copyDirRecursive(src, dest) {
+  ensureDir(dest);
+  for (const entry of fs.readdirSync(src)) {
+    const srcPath = path.join(src, entry);
+    const destPath = path.join(dest, entry);
+    if (fs.statSync(srcPath).isDirectory()) {
+      copyDirRecursive(srcPath, destPath);
+    } else {
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
+function installSkills() {
+  ensureDir(PATHS.skillsDir);
+  const skillsSource = path.join(getPackageRoot(), 'skills');
+  const dirs = getSkillDirs();
+
+  for (const dir of dirs) {
+    copyDirRecursive(path.join(skillsSource, dir), path.join(PATHS.skillsDir, dir));
+    logger.success(dir);
+  }
+  return dirs;
+}
+
+// Fallback list if package source is unavailable
+const KNOWN_SKILLS = ['supermind', 'supermind-init', 'supermind-living-docs'];
+
+function removeSkills() {
+  let dirs;
+  try { dirs = getSkillDirs(); } catch { dirs = KNOWN_SKILLS; }
+  for (const dir of dirs) {
+    const target = path.join(PATHS.skillsDir, dir);
+    if (fs.existsSync(target)) {
+      fs.rmSync(target, { recursive: true, force: true });
+      logger.success(`Removed ${dir}`);
+    }
+  }
+}
+
+// Remove legacy skill paths from previous versions
+function removeLegacySkills() {
+  const legacyPaths = [
+    path.join(PATHS.skillsDir, 'supermind', 'init'),
+    path.join(PATHS.skillsDir, 'supermind', 'living-docs'),
+    path.join(PATHS.skillsDir, 'sm'),
+  ];
+  for (const p of legacyPaths) {
+    if (fs.existsSync(p)) {
+      fs.rmSync(p, { recursive: true, force: true });
+      logger.info(`Cleaned up legacy path: ${path.basename(p)}`);
+    }
+  }
+}
+
+module.exports = { installSkills, removeSkills, removeLegacySkills, getSkillDirs };

package/cli/lib/templates.js

@@ -0,0 +1,24 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { PATHS, ensureDir, getPackageRoot } = require('./platform');
+const logger = require('./logger');
+
+function installTemplates() {
+  ensureDir(PATHS.templatesDir);
+  const src = path.join(getPackageRoot(), 'templates', 'CLAUDE.md');
+  const dest = path.join(PATHS.templatesDir, 'CLAUDE.md');
+  fs.copyFileSync(src, dest);
+  logger.success('CLAUDE.md template');
+}
+
+function removeTemplates() {
+  const dest = path.join(PATHS.templatesDir, 'CLAUDE.md');
+  if (fs.existsSync(dest)) {
+    fs.unlinkSync(dest);
+    logger.success('Removed CLAUDE.md template');
+  }
+}
+
+module.exports = { installTemplates, removeTemplates };