@polymorphism-tech/morph-spec 4.9.0 → 4.10.1

package/src/lib/detectors/claude-config-detector.js

@@ -1,390 +1,136 @@
 /**
- * Claude Config Detector
+ * @fileoverview Claude Config Detector
  *
- * Detects the user's Claude Code environment: plugins, MCP servers,
- * custom skills, commands, hooks, and superpowers installation.
+ * Scans .claude/ settings and plugins for MCP servers, hooks, skills, and commands.
+ * Used by mcp-setup and session-start hooks.
+ *
+ * @module detectors/claude-config-detector
  */
 
+import { existsSync, readFileSync, readdirSync } from 'fs';
 import { join } from 'path';
-import { existsSync, readFileSync, readdirSync, statSync } from 'fs';
 import { homedir } from 'os';
 
 /**
- * Detect full Claude Code configuration for a project
- * @param {string} targetPath - Project root directory
- * @param {Object} options - Options
- * @param {string} options.globalDir - Override global .claude dir (for testing)
- * @returns {Promise<Object>} Detected configuration
+ * Detect Claude Code configuration for a project.
+ *
+ * @param {string} targetPath - Root path of the project
+ * @returns {{ plugins: string[], mcpServers: Array<{name: string, config: Object}>, superpowers: boolean, customSkills: string[], customCommands: string[], hooks: string[] }}
  */
-export async function detectClaudeConfig(targetPath, options = {}) {
-  const home = homedir();
-  const globalClaudeDir = options.globalDir || join(home, '.claude');
-  const projectClaudeDir = join(targetPath, '.claude');
-
+export function detectClaudeConfig(targetPath) {
   const result = {
     plugins: [],
     mcpServers: [],
+    superpowers: false,
     customSkills: [],
     customCommands: [],
     hooks: [],
-    superpowers: { installed: false, version: null, skills: [] }
   };
 
-  // 1. Detect enabled plugins from global settings
-  result.plugins = detectPlugins(globalClaudeDir);
-
-  // 2. Detect MCP servers from global + project settings
-  result.mcpServers = detectMcpServers(globalClaudeDir, projectClaudeDir);
-
-  // 3. Detect custom skills
-  result.customSkills = detectCustomSkills(globalClaudeDir, projectClaudeDir);
-
-  // 4. Detect custom commands
-  result.customCommands = detectCustomCommands(globalClaudeDir, projectClaudeDir);
-
-  // 5. Detect hooks
-  result.hooks = detectHooks(globalClaudeDir, projectClaudeDir);
-
-  // 6. Detect superpowers plugin
-  result.superpowers = detectSuperpowers(result.plugins, result.customSkills);
-
-  return result;
-}
-
-/**
- * Detect enabled plugins from settings.json
- */
-function detectPlugins(globalClaudeDir) {
-  const plugins = [];
-
-  // Read global settings for enabledPlugins
-  const settingsPath = join(globalClaudeDir, 'settings.json');
-  const settings = readJsonSafe(settingsPath);
-  const rawPlugins = settings?.enabledPlugins;
-  const enabledPlugins = Array.isArray(rawPlugins) ? rawPlugins : [];
-
-  // Read installed plugins for version info
-  const installedPath = join(globalClaudeDir, 'plugins', 'installed_plugins.json');
-  const installed = readJsonSafe(installedPath) || {};
-
-  for (const pluginId of enabledPlugins) {
-    const pluginInfo = installed[pluginId] || {};
-    plugins.push({
-      name: extractPluginName(pluginId),
-      id: pluginId,
-      version: pluginInfo.version || null,
-      enabled: true
-    });
-  }
-
-  return plugins;
-}
-
-/**
- * Detect MCP servers from global and project settings
- */
-function detectMcpServers(globalClaudeDir, projectClaudeDir) {
-  const servers = [];
-
-  // Global MCP servers from settings.json
-  const globalSettings = readJsonSafe(join(globalClaudeDir, 'settings.json'));
-  if (globalSettings?.mcpServers) {
-    for (const [name, config] of Object.entries(globalSettings.mcpServers)) {
-      servers.push({ name, source: 'global', config });
-    }
-  }
-
-  // Global MCP servers from settings.local.json
-  const globalLocal = readJsonSafe(join(globalClaudeDir, 'settings.local.json'));
-  if (globalLocal?.mcpServers) {
-    for (const [name, config] of Object.entries(globalLocal.mcpServers)) {
-      if (!servers.find(s => s.name === name)) {
-        servers.push({ name, source: 'global', config });
-      }
-    }
-  }
-
-  // Project MCP servers from .claude/settings.local.json
-  const projectSettings = readJsonSafe(join(projectClaudeDir, 'settings.local.json'));
-  if (projectSettings?.mcpServers) {
-    for (const [name, config] of Object.entries(projectSettings.mcpServers)) {
-      const existing = servers.find(s => s.name === name);
-      if (existing) {
-        existing.source = 'project'; // project overrides global
-      } else {
-        servers.push({ name, source: 'project', config });
+  try {
+    // ── MCP Servers from settings ────────────────────────────────────────────
+    const settingsPaths = [
+      join(targetPath, '.claude', 'settings.json'),
+      join(targetPath, '.claude', 'settings.local.json'),
+    ];
+
+    for (const sp of settingsPaths) {
+      if (existsSync(sp)) {
+        try {
+          const settings = JSON.parse(readFileSync(sp, 'utf8'));
+          const mcps = settings.mcpServers || {};
+          for (const [name, config] of Object.entries(mcps)) {
+            // Avoid duplicates — later file wins
+            const idx = result.mcpServers.findIndex(m => m.name === name);
+            if (idx >= 0) {
+              result.mcpServers[idx] = { name, config };
+            } else {
+              result.mcpServers.push({ name, config });
+            }
+          }
+
+          // Collect hooks
+          if (settings.hooks) {
+            for (const [event, eventHooks] of Object.entries(settings.hooks)) {
+              for (const group of (Array.isArray(eventHooks) ? eventHooks : [])) {
+                for (const h of (group.hooks || [])) {
+                  result.hooks.push(`${event}:${h.type || 'unknown'}`);
+                }
+              }
+            }
+          }
+        } catch { /* invalid JSON */ }
       }
     }
-  }
 
-  return servers;
-}
-
-/**
- * Detect custom skills from .claude/skills/ directories
- */
-function detectCustomSkills(globalClaudeDir, projectClaudeDir) {
-  const skills = [];
-
-  // Global skills
-  const globalSkills = join(globalClaudeDir, 'skills');
-  if (existsSync(globalSkills)) {
-    for (const file of walkMdFiles(globalSkills)) {
-      skills.push({
-        name: extractSkillName(file),
-        path: file,
-        source: 'global'
-      });
+    // ── Plugins from global config ──────────────────────────────────────────
+    const pluginsPath = join(homedir(), '.claude', 'plugins', 'installed_plugins.json');
+    if (existsSync(pluginsPath)) {
+      try {
+        const pluginsData = JSON.parse(readFileSync(pluginsPath, 'utf8'));
+        const plugins = pluginsData.plugins || {};
+        result.plugins = Object.keys(plugins);
+        result.superpowers = 'superpowers@claude-plugins-official' in plugins;
+      } catch { /* invalid JSON */ }
     }
-  }
 
-  // Project skills (may include morph-spec skills)
-  const projectSkills = join(projectClaudeDir, 'skills');
-  if (existsSync(projectSkills)) {
-    for (const file of walkMdFiles(projectSkills)) {
-      const name = extractSkillName(file);
-      // Skip morph-spec framework skills (they're managed by init)
-      if (file.includes('level-0-meta') || file.includes('level-1-workflows')) {
-        continue;
-      }
-      skills.push({
-        name,
-        path: file,
-        source: 'project'
-      });
+    // ── Custom skills ───────────────────────────────────────────────────────
+    const skillsPath = join(targetPath, '.claude', 'skills');
+    if (existsSync(skillsPath)) {
+      try {
+        result.customSkills = readdirSync(skillsPath).filter(f => !f.startsWith('.'));
+      } catch { /* ignore */ }
     }
-  }
 
-  return skills;
-}
-
-/**
- * Detect custom commands from .claude/commands/ directories
- */
-function detectCustomCommands(globalClaudeDir, projectClaudeDir) {
-  const commands = [];
-
-  // Global commands
-  const globalCommands = join(globalClaudeDir, 'commands');
-  if (existsSync(globalCommands)) {
-    for (const file of walkMdFiles(globalCommands)) {
-      commands.push({
-        name: extractCommandName(file),
-        path: file,
-        source: 'global'
-      });
-    }
-  }
-
-  // Project commands (excluding morph-spec managed commands)
-  const projectCommands = join(projectClaudeDir, 'commands');
-  if (existsSync(projectCommands)) {
-    for (const file of walkMdFiles(projectCommands)) {
-      const name = extractCommandName(file);
-      // Skip morph-spec commands
-      if (name.startsWith('morph-')) continue;
-      commands.push({
-        name,
-        path: file,
-        source: 'project'
-      });
-    }
-  }
-
-  return commands;
-}
-
-/**
- * Detect hooks from settings files
- */
-function detectHooks(globalClaudeDir, projectClaudeDir) {
-  const hooks = [];
-
-  // Global hooks
-  const globalSettings = readJsonSafe(join(globalClaudeDir, 'settings.json'));
-  if (globalSettings?.hooks) {
-    for (const [trigger, entries] of Object.entries(globalSettings.hooks)) {
-      hooks.push({ trigger, source: 'global', entries });
+    // ── Custom commands ─────────────────────────────────────────────────────
+    const commandsPath = join(targetPath, '.claude', 'commands');
+    if (existsSync(commandsPath)) {
+      try {
+        result.customCommands = readdirSync(commandsPath).filter(f => f.endsWith('.md'));
+      } catch { /* ignore */ }
     }
-  }
-
-  // Project hooks
-  const projectSettings = readJsonSafe(join(projectClaudeDir, 'settings.local.json'));
-  if (projectSettings?.hooks) {
-    for (const [trigger, entries] of Object.entries(projectSettings.hooks)) {
-      hooks.push({ trigger, source: 'project', entries });
-    }
-  }
-
-  return hooks;
-}
-
-/**
- * Detect superpowers plugin installation
- */
-function detectSuperpowers(plugins, customSkills) {
-  const result = { installed: false, version: null, skills: [] };
-
-  // Check if superpowers is in enabled plugins
-  const superPlugin = plugins.find(p =>
-    p.name === 'superpowers' || p.id?.includes('superpowers')
-  );
-
-  if (superPlugin) {
-    result.installed = true;
-    result.version = superPlugin.version;
-  }
-
-  // Collect superpowers skills from detected skills
-  const superpowerSkills = customSkills.filter(s =>
-    s.path?.includes('superpowers') || s.name?.startsWith('superpowers:')
-  );
-
-  if (superpowerSkills.length > 0) {
-    result.installed = true;
-    result.skills = superpowerSkills.map(s => s.name);
+  } catch {
+    // Fail-safe
   }
 
   return result;
 }
 
-// ============================================================================
-// MCP Phase Mapping
-// ============================================================================
-
 /**
- * Map detected MCPs to morph-spec phases where they're useful
- * @param {Array} mcpServers - Detected MCP servers
- * @returns {Object} Map of phase → relevant MCPs
+ * Cross-reference configured MCPs with the MCP registry's phase matrix.
+ *
+ * @param {Array<{name: string}>} mcpServers - Detected MCP server list
+ * @param {Object} phaseMatrix - From mcp-registry.json → phaseMatrix
+ * @param {string} currentPhase - Current morph-spec phase
+ * @returns {{ available: string[], recommended: string[], missing: string[] }}
  */
-export function mapMcpsToPhases(mcpServers) {
-  const phaseMap = {
-    proposal: [],
-    setup: [],
-    uiux: [],
-    design: [],
-    clarify: [],
-    tasks: [],
-    implement: []
-  };
-
-  const mcpPhaseConfig = {
-    context7: ['proposal', 'design', 'tasks', 'implement'],
-    supabase: ['design', 'implement'],
-    playwright: ['uiux', 'implement'],
-    github: ['setup', 'tasks', 'implement'],
-    figma: ['uiux'],
-    docker: ['implement'],
-    azure: ['implement']
+export function mapMcpsToPhases(mcpServers, phaseMatrix, currentPhase) {
+  const configuredNames = new Set(mcpServers.map(m => m.name.toLowerCase()));
+  const recommended = (phaseMatrix[currentPhase] || []);
+
+  return {
+    available: recommended.filter(name => configuredNames.has(name)),
+    recommended,
+    missing: recommended.filter(name => !configuredNames.has(name)),
   };
-
-  for (const server of mcpServers) {
-    const name = server.name.toLowerCase();
-    for (const [mcpKey, phases] of Object.entries(mcpPhaseConfig)) {
-      if (name.includes(mcpKey)) {
-        for (const phase of phases) {
-          phaseMap[phase].push({
-            name: server.name,
-            source: server.source
-          });
-        }
-      }
-    }
-  }
-
-  return phaseMap;
 }
 
 /**
- * Format detected config as a summary table string
- * @param {Object} config - Detected Claude config
- * @returns {string} Formatted summary
+ * Format a human-readable one-liner summary of detected config.
+ *
+ * @param {{ plugins: string[], mcpServers: Array<{name: string}>, superpowers: boolean }} config
+ * @returns {string}
  */
 export function formatConfigSummary(config) {
-  const lines = [];
-
-  if (config.plugins.length > 0) {
-    lines.push('Plugins:');
-    for (const p of config.plugins) {
-      const ver = p.version ? ` v${p.version}` : '';
-      lines.push(`  - ${p.name}${ver}`);
-    }
-  }
-
+  const parts = [];
   if (config.mcpServers.length > 0) {
-    lines.push('MCP Servers:');
-    for (const s of config.mcpServers) {
-      lines.push(`  - ${s.name} (${s.source})`);
-    }
-  }
-
-  if (config.superpowers.installed) {
-    lines.push(`Superpowers: installed (${config.superpowers.skills.length} skills)`);
-  }
-
-  if (config.customSkills.length > 0) {
-    lines.push(`Custom Skills: ${config.customSkills.length}`);
-  }
-
-  if (config.customCommands.length > 0) {
-    lines.push(`Custom Commands: ${config.customCommands.length}`);
-  }
-
-  return lines.join('\n');
-}
-
-// ============================================================================
-// Helpers
-// ============================================================================
-
-function readJsonSafe(filePath) {
-  try {
-    if (!existsSync(filePath)) return null;
-    return JSON.parse(readFileSync(filePath, 'utf-8'));
-  } catch {
-    return null;
+    parts.push(`MCPs: ${config.mcpServers.map(m => m.name).join(', ')}`);
   }
-}
-
-function extractPluginName(pluginId) {
-  // Plugin IDs can be URLs or package names
-  // e.g., "https://github.com/user/superpowers" → "superpowers"
-  // e.g., "@user/superpowers" → "superpowers"
-  const parts = pluginId.split('/');
-  return parts[parts.length - 1].replace(/\.git$/, '');
-}
-
-function extractSkillName(filePath) {
-  // Extract skill name from file path
-  // e.g., ".claude/skills/superpowers/brainstorming.md" → "superpowers:brainstorming"
-  const parts = filePath.replace(/\\/g, '/').split('/');
-  const mdFile = parts[parts.length - 1].replace('.md', '');
-  const parentDir = parts.length >= 2 ? parts[parts.length - 2] : null;
-
-  if (parentDir && parentDir !== 'skills') {
-    return `${parentDir}:${mdFile}`;
+  if (config.plugins.length > 0) {
+    parts.push(`Plugins: ${config.plugins.length}`);
   }
-  return mdFile;
-}
-
-function extractCommandName(filePath) {
-  return filePath.replace(/\\/g, '/').split('/').pop().replace('.md', '');
-}
-
-function walkMdFiles(dir) {
-  const results = [];
-  try {
-    const entries = readdirSync(dir, { withFileTypes: true });
-    for (const entry of entries) {
-      const fullPath = join(dir, entry.name);
-      if (entry.isDirectory()) {
-        results.push(...walkMdFiles(fullPath));
-      } else if (entry.isFile() && entry.name.endsWith('.md')) {
-        results.push(fullPath);
-      }
-    }
-  } catch {
-    // Permission errors or broken symlinks
+  if (config.superpowers) {
+    parts.push('superpowers: yes');
   }
-  return results;
+  return parts.join(' | ') || 'No Claude config detected';
 }