@polymorphism-tech/morph-spec 4.3.6 → 4.5.0

package/src/core/templates/template-registry.js

@@ -252,7 +252,7 @@ export function templateExists(templateId, projectPath = null) {
  * Get template absolute path with fallback logic.
  *
  * Resolution order:
- *   1. Project-local override (.morph/templates/{path})
+ *   1. Project-local override (.morph/framework/templates/{path})
  *   2. Framework universal template (framework/templates/{path})
  *
  * @param {string} templateId - Template identifier
@@ -266,7 +266,7 @@ export function resolveTemplatePathById(templateId, projectPath) {
   }
 
   // 1. Project-local override
-  const projectLocalPath = join(projectPath, '.morph/templates', template.path);
+  const projectLocalPath = join(projectPath, '.morph/framework/templates', template.path);
   if (existsSync(projectLocalPath)) {
     return projectLocalPath;
   }

package/src/core/workflows/workflow-detector.js

@@ -14,6 +14,22 @@ import { join, dirname } from 'path';
 import { fileURLToPath } from 'url';
 import { getPhaseSequence } from '../state/phase-state-machine.js';
 
+/**
+ * Load the canonical phase id set from framework/phases.json.
+ * Falls back to getPhaseSequence() if the file is unavailable.
+ * @returns {Set<string>}
+ */
+function getValidPhaseIds() {
+  try {
+    const phasesPath = join(__dirname, '..', '..', '..', 'framework', 'phases.json');
+    const { phases } = JSON.parse(readFileSync(phasesPath, 'utf8'));
+    return new Set(Object.keys(phases));
+  } catch {
+    // Graceful fallback to state machine list
+    return new Set(getPhaseSequence());
+  }
+}
+
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
 /**
@@ -340,7 +356,7 @@ export function getWorkflowConfig(workflowId, projectPath = '.') {
   const config = workflows.find(w => w.id === workflowId) || null;
 
   if (config) {
-    const validPhases = new Set(getPhaseSequence());
+    const validPhases = getValidPhaseIds();
     const declaredPhases = config.phases?.run || [];
     for (const phase of declaredPhases) {
       if (!validPhases.has(phase)) {

package/src/lib/agents/micro-agent-factory.js

@@ -13,7 +13,7 @@ import { readFileSync, writeFileSync, existsSync, mkdirSync, readdirSync } from
 import { join } from 'path';
 
 const MICRO_AGENTS_DIR = join(process.cwd(), '.morph/micro-agents');
-const AGENTS_CONFIG = join(process.cwd(), '.morph/config/agents.json');
+const AGENTS_CONFIG = join(process.cwd(), '.morph/framework/agents.json');
 
 // ============================================================================
 // Agent Creation

package/src/lib/context/context-bundler.js

@@ -13,6 +13,7 @@
 
 import { readFileSync, writeFileSync, existsSync, mkdirSync, readdirSync } from 'fs';
 import { join } from 'path';
+import { getOutputPath } from '../../core/paths/output-schema.js';
 import { randomUUID } from 'crypto';
 
 const BUNDLES_DIR = join(process.cwd(), '.morph/bundles');
@@ -232,7 +233,7 @@ function buildResumeInstructions(feature, checkpointNum, decisions, nextSteps) {
   return `## Resume Instructions
 
 1. Load minimal standards: run \`morph-spec prime feature\`
-2. Read spec: \`.morph/project/outputs/${feature}/spec.md\` (key sections only)
+2. Read spec: \`${getOutputPath(feature, 'spec')}\` (key sections only)
 3. Check tasks: \`morph-spec state get ${feature}\`
 4. Continue from: ${nextSteps[0] || `task after checkpoint ${checkpointNum}`}
 

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

@@ -0,0 +1,392 @@
+/**
+ * Claude Config Detector
+ *
+ * Detects the user's Claude Code environment: plugins, MCP servers,
+ * custom skills, commands, hooks, and superpowers installation.
+ */
+
+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
+ */
+export async function detectClaudeConfig(targetPath, options = {}) {
+  const home = homedir();
+  const globalClaudeDir = options.globalDir || join(home, '.claude');
+  const projectClaudeDir = join(targetPath, '.claude');
+
+  const result = {
+    plugins: [],
+    mcpServers: [],
+    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 });
+      }
+    }
+  }
+
+  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'
+      });
+    }
+  }
+
+  // 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') ||
+          file.includes('level-2-domains') || file.includes('level-3-technologies') ||
+          file.includes('level-4-patterns')) {
+        continue;
+      }
+      skills.push({
+        name,
+        path: file,
+        source: 'project'
+      });
+    }
+  }
+
+  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 });
+    }
+  }
+
+  // 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);
+  }
+
+  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
+ */
+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']
+  };
+
+  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
+ */
+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}`);
+    }
+  }
+
+  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;
+  }
+}
+
+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}`;
+  }
+  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
+  }
+  return results;
+}

package/src/lib/detectors/conversation-analyzer.js

@@ -21,8 +21,8 @@ export async function analyzeConversation(projectPath) {
     available: false
   };
 
-  // Check if .morph/project/context exists (past decisions)
-  const contextPath = join(projectPath, '.morph', 'project', 'context');
+  // Check if .morph/context exists (past decisions)
+  const contextPath = join(projectPath, '.morph', 'context');
   if (existsSync(contextPath)) {
     result.available = true;
 
@@ -34,8 +34,8 @@ export async function analyzeConversation(projectPath) {
     }
   }
 
-  // Check .morph/project/outputs/*/decisions.md
-  const outputsPath = join(projectPath, '.morph', 'project', 'outputs');
+  // Check .morph/features/*/decisions.md
+  const outputsPath = join(projectPath, '.morph', 'features');
   if (existsSync(outputsPath)) {
     const { readdirSync } = await import('fs');
     const features = readdirSync(outputsPath, { withFileTypes: true })

package/src/lib/detectors/design-system-detector.js

@@ -29,9 +29,10 @@ export function detectDesignSystem(projectPath, featureName = null) {
   if (featureName) {
     const featureDesignSystemPath = join(
       projectPath,
-      '.morph/project/outputs',
+      '.morph/features',
       featureName,
-      'ui-design-system.md'
+      '2-ui',
+      'design-system.md'
     );
 
     if (existsSync(featureDesignSystemPath)) {
@@ -46,7 +47,7 @@ export function detectDesignSystem(projectPath, featureName = null) {
   }
 
   // Priority 2: Project-level design system (markdown)
-  const projectDesignSystemPath = join(projectPath, '.morph/project/design-system.md');
+  const projectDesignSystemPath = join(projectPath, '.morph/context/design-system.md');
   if (existsSync(projectDesignSystemPath)) {
     return {
       hasDesignSystem: true,
@@ -166,7 +167,7 @@ export function getRecommendedLocations(projectPath) {
 
     // Default locations (Blazor)
     const locations = {
-      markdown: '.morph/project/design-system.md',
+      markdown: '.morph/context/design-system.md',
       css: 'wwwroot/css/design-system.css',
       description: 'Project-level design system (shared across features)'
     };
@@ -179,7 +180,7 @@ export function getRecommendedLocations(projectPath) {
     return locations;
   } catch {
     return {
-      markdown: '.morph/project/design-system.md',
+      markdown: '.morph/context/design-system.md',
       css: 'wwwroot/css/design-system.css',
       description: 'Project-level design system (shared across features)'
     };

package/src/lib/detectors/standards-generator.js

@@ -125,7 +125,7 @@ Based on detected patterns in your codebase:
 - **DI**: Constructor injection (${structure.patterns.includes('Dependency Injection') ? '✅ detected' : '⚠️ not detected'})
 - **Tests**: ${structure.patterns.includes('Unit Tests') ? '✅ Present' : '⚠️ Not detected'}
 
-**Recommendation**: Refer to \`.morph/standards/coding.md\` for complete .NET standards.`;
+**Recommendation**: Refer to \`.morph/framework/standards/coding.md\` for complete .NET standards.`;
   }
 
   if (config?.language === 'javascript') {
@@ -233,7 +233,7 @@ function generateRecommendations(structure, config, conversation) {
     }
 
     if (!structure.patterns.includes('AI Agents') && config?.technologies?.includes('Microsoft Agent Framework')) {
-      recommendations.push('Setup detected Agent Framework but no agents found - check .morph/standards/agent-framework-setup.md');
+      recommendations.push('Setup detected Agent Framework but no agents found - check .morph/framework/standards/agent-framework-setup.md');
     }
   }