@polymorphism-tech/morph-spec 4.8.19 → 4.10.0

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

@@ -1,189 +1,189 @@
-/**
- * @fileoverview Design System Detector
- *
- * Detects if a design system exists for the project or feature.
- * Checks multiple locations in priority order.
- *
- * @module design-system-detector
- */
-
-import { existsSync, readFileSync } from 'fs';
-import { join } from 'path';
-
-/**
- * Detect design system for project or feature
- * @param {string} projectPath - Root path of the project
- * @param {string|null} featureName - Feature name (optional, checks feature-level if provided)
- * @returns {Object} { hasDesignSystem, path, isProjectLevel, isFeatureLevel, source }
- */
-export function detectDesignSystem(projectPath, featureName = null) {
-  const result = {
-    hasDesignSystem: false,
-    path: null,
-    isProjectLevel: false,
-    isFeatureLevel: false,
-    source: null
-  };
-
-  // Priority 1: Feature-level design system (if feature specified)
-  if (featureName) {
-    const featureDesignSystemPath = join(
-      projectPath,
-      '.morph/features',
-      featureName,
-      '2-ui',
-      'design-system.md'
-    );
-
-    if (existsSync(featureDesignSystemPath)) {
-      return {
-        hasDesignSystem: true,
-        path: featureDesignSystemPath,
-        isProjectLevel: false,
-        isFeatureLevel: true,
-        source: 'feature-output'
-      };
-    }
-  }
-
-  // Priority 2: Project-level design system (markdown)
-  const projectDesignSystemPath = join(projectPath, '.morph/context/design-system.md');
-  if (existsSync(projectDesignSystemPath)) {
-    return {
-      hasDesignSystem: true,
-      path: projectDesignSystemPath,
-      isProjectLevel: true,
-      isFeatureLevel: false,
-      source: 'project-markdown'
-    };
-  }
-
-  // Priority 3: Generated CSS design system
-  const cssDesignSystemPath = join(projectPath, 'wwwroot/css/design-system.css');
-  if (existsSync(cssDesignSystemPath)) {
-    return {
-      hasDesignSystem: true,
-      path: cssDesignSystemPath,
-      isProjectLevel: true,
-      isFeatureLevel: false,
-      source: 'generated-css'
-    };
-  }
-
-  // Priority 4: Check common CSS locations for design system variables
-  const commonCssLocations = [
-    'wwwroot/css/site.css',
-    'wwwroot/css/app.css',
-    'styles/globals.css',
-    'src/styles/globals.css'
-  ];
-
-  for (const cssPath of commonCssLocations) {
-    const fullPath = join(projectPath, cssPath);
-    if (existsSync(fullPath)) {
-      // Check if file contains design system variables (CSS custom properties)
-      try {
-        const content = readFileSync(fullPath, 'utf8');
-
-        // Look for CSS custom properties that indicate a design system
-        // Match :root { ... --variable ... } (with newlines)
-        const hasDesignTokens = /:root\s*\{[\s\S]*?--/.test(content);
-
-        if (hasDesignTokens) {
-          return {
-            hasDesignSystem: true,
-            path: fullPath,
-            isProjectLevel: true,
-            isFeatureLevel: false,
-            source: 'existing-css-variables'
-          };
-        }
-      } catch {
-        // Continue checking other locations
-      }
-    }
-  }
-
-  // No design system found
-  return result;
-}
-
-/**
- * Check if UI agents are active for a feature
- * @param {string} projectPath - Root path of the project
- * @param {string} featureName - Feature name
- * @returns {boolean} True if UI agents are active
- */
-export function hasUIAgentsActive(projectPath, featureName) {
-  try {
-    const statePath = join(projectPath, '.morph/state.json');
-
-    if (!existsSync(statePath)) {
-      return false;
-    }
-
-    const state = JSON.parse(readFileSync(statePath, 'utf8'));
-
-    // Handle both array and object format
-    let feature;
-    if (Array.isArray(state.features)) {
-      feature = state.features.find(f => f.name === featureName);
-    } else if (state.features && typeof state.features === 'object') {
-      feature = state.features[featureName];
-    }
-
-    if (!feature || !feature.activeAgents) {
-      return false;
-    }
-
-    // UI design agents that require a design system before implement phase.
-    // Implementation-only agents (blazor-builder, nextjs-expert, css-specialist)
-    // build from existing designs and do NOT trigger this gate.
-    const uiAgents = [
-      'ui-designer',
-      'uiux-designer',
-      'ui-ux-designer',
-    ];
-
-    return feature.activeAgents.some(agentId => uiAgents.includes(agentId));
-  } catch {
-    return false;
-  }
-}
-
-/**
- * Get recommended design system locations based on project type
- * @param {string} projectPath - Root path of the project
- * @returns {Object} { markdown, css, description }
- */
-export function getRecommendedLocations(projectPath) {
-  try {
-    const configPath = join(projectPath, '.morph/config/config.json');
-
-    let projectType = 'unknown';
-    if (existsSync(configPath)) {
-      const config = JSON.parse(readFileSync(configPath, 'utf8'));
-      projectType = config.project?.type || 'unknown';
-    }
-
-    // Default locations (Blazor)
-    const locations = {
-      markdown: '.morph/context/design-system.md',
-      css: 'wwwroot/css/design-system.css',
-      description: 'Project-level design system (shared across features)'
-    };
-
-    // Adjust based on project type
-    if (projectType === 'nextjs' || projectType.includes('nextjs')) {
-      locations.css = 'styles/design-system.css';
-    }
-
-    return locations;
-  } catch {
-    return {
-      markdown: '.morph/context/design-system.md',
-      css: 'wwwroot/css/design-system.css',
-      description: 'Project-level design system (shared across features)'
-    };
-  }
-}
+/**
+ * @fileoverview Design System Detector
+ *
+ * Detects if a design system exists for the project or feature.
+ * Checks multiple locations in priority order.
+ *
+ * @module design-system-detector
+ */
+
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+
+/**
+ * Detect design system for project or feature
+ * @param {string} projectPath - Root path of the project
+ * @param {string|null} featureName - Feature name (optional, checks feature-level if provided)
+ * @returns {Object} { hasDesignSystem, path, isProjectLevel, isFeatureLevel, source }
+ */
+export function detectDesignSystem(projectPath, featureName = null) {
+  const result = {
+    hasDesignSystem: false,
+    path: null,
+    isProjectLevel: false,
+    isFeatureLevel: false,
+    source: null
+  };
+
+  // Priority 1: Feature-level design system (if feature specified)
+  if (featureName) {
+    const featureDesignSystemPath = join(
+      projectPath,
+      '.morph/features',
+      featureName,
+      '2-ui',
+      'design-system.md'
+    );
+
+    if (existsSync(featureDesignSystemPath)) {
+      return {
+        hasDesignSystem: true,
+        path: featureDesignSystemPath,
+        isProjectLevel: false,
+        isFeatureLevel: true,
+        source: 'feature-output'
+      };
+    }
+  }
+
+  // Priority 2: Project-level design system (markdown)
+  const projectDesignSystemPath = join(projectPath, '.morph/context/design-system.md');
+  if (existsSync(projectDesignSystemPath)) {
+    return {
+      hasDesignSystem: true,
+      path: projectDesignSystemPath,
+      isProjectLevel: true,
+      isFeatureLevel: false,
+      source: 'project-markdown'
+    };
+  }
+
+  // Priority 3: Generated CSS design system
+  const cssDesignSystemPath = join(projectPath, 'wwwroot/css/design-system.css');
+  if (existsSync(cssDesignSystemPath)) {
+    return {
+      hasDesignSystem: true,
+      path: cssDesignSystemPath,
+      isProjectLevel: true,
+      isFeatureLevel: false,
+      source: 'generated-css'
+    };
+  }
+
+  // Priority 4: Check common CSS locations for design system variables
+  const commonCssLocations = [
+    'wwwroot/css/site.css',
+    'wwwroot/css/app.css',
+    'styles/globals.css',
+    'src/styles/globals.css'
+  ];
+
+  for (const cssPath of commonCssLocations) {
+    const fullPath = join(projectPath, cssPath);
+    if (existsSync(fullPath)) {
+      // Check if file contains design system variables (CSS custom properties)
+      try {
+        const content = readFileSync(fullPath, 'utf8');
+
+        // Look for CSS custom properties that indicate a design system
+        // Match :root { ... --variable ... } (with newlines)
+        const hasDesignTokens = /:root\s*\{[\s\S]*?--/.test(content);
+
+        if (hasDesignTokens) {
+          return {
+            hasDesignSystem: true,
+            path: fullPath,
+            isProjectLevel: true,
+            isFeatureLevel: false,
+            source: 'existing-css-variables'
+          };
+        }
+      } catch {
+        // Continue checking other locations
+      }
+    }
+  }
+
+  // No design system found
+  return result;
+}
+
+/**
+ * Check if UI agents are active for a feature
+ * @param {string} projectPath - Root path of the project
+ * @param {string} featureName - Feature name
+ * @returns {boolean} True if UI agents are active
+ */
+export function hasUIAgentsActive(projectPath, featureName) {
+  try {
+    const statePath = join(projectPath, '.morph/state.json');
+
+    if (!existsSync(statePath)) {
+      return false;
+    }
+
+    const state = JSON.parse(readFileSync(statePath, 'utf8'));
+
+    // Handle both array and object format
+    let feature;
+    if (Array.isArray(state.features)) {
+      feature = state.features.find(f => f.name === featureName);
+    } else if (state.features && typeof state.features === 'object') {
+      feature = state.features[featureName];
+    }
+
+    if (!feature || !feature.activeAgents) {
+      return false;
+    }
+
+    // UI design agents that require a design system before implement phase.
+    // Implementation-only agents (blazor-builder, nextjs-expert, css-specialist)
+    // build from existing designs and do NOT trigger this gate.
+    const uiAgents = [
+      'ui-designer',
+      'uiux-designer',
+      'ui-ux-designer',
+    ];
+
+    return feature.activeAgents.some(agentId => uiAgents.includes(agentId));
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Get recommended design system locations based on project type
+ * @param {string} projectPath - Root path of the project
+ * @returns {Object} { markdown, css, description }
+ */
+export function getRecommendedLocations(projectPath) {
+  try {
+    const configPath = join(projectPath, '.morph/config/config.json');
+
+    let projectType = 'unknown';
+    if (existsSync(configPath)) {
+      const config = JSON.parse(readFileSync(configPath, 'utf8'));
+      projectType = config.project?.type || 'unknown';
+    }
+
+    // Default locations (Blazor)
+    const locations = {
+      markdown: '.morph/context/design-system.md',
+      css: 'wwwroot/css/design-system.css',
+      description: 'Project-level design system (shared across features)'
+    };
+
+    // Adjust based on project type
+    if (projectType === 'nextjs' || projectType.includes('nextjs')) {
+      locations.css = 'styles/design-system.css';
+    }
+
+    return locations;
+  } catch {
+    return {
+      markdown: '.morph/context/design-system.md',
+      css: 'wwwroot/css/design-system.css',
+      description: 'Project-level design system (shared across features)'
+    };
+  }
+}

package/src/lib/detectors/index.js

@@ -1,81 +1,179 @@
 /**
- * MORPH-SPEC Detectors - Main Orchestrator
+ * @fileoverview Project Detector
  *
- * Coordinates all detection modules to build a complete picture of the project.
+ * Scans a project directory for stack, architecture, UI library, and integrations.
+ * Used by mcp-setup, morph-init, and session-start hooks.
+ *
+ * @module detectors/index
  */
 
-import { detectStructure } from './structure-detector.js';
-import { detectConfig } from './config-detector.js';
-import { generateStandards } from './standards-generator.js';
-
-// Re-export individual detectors
-export * from './design-system-detector.js';
+import { existsSync, readFileSync, readdirSync } from 'fs';
+import { join } from 'path';
 
 /**
- * Main detection orchestrator
- * @param {string} projectPath - Path to project root
- * @param {Object} options - Detection options
- * @returns {Promise<Object>} Detection results
+ * Detect project structure from filesystem evidence.
+ *
+ * @param {string} targetPath - Root path of the project
+ * @param {Object} [opts] - Options
+ * @param {boolean} [opts.generateStandards=false] - Whether to generate inferred markdown
+ * @returns {{ structure: { stack: string, architecture: string|null, uiLibrary: string|null, integrations: string[], hasVercel: boolean }, inferred: { markdown: string } }}
  */
-export async function detectProject(projectPath, options = {}) {
-  const results = {
-    path: projectPath,
-    timestamp: new Date().toISOString(),
-    structure: null,
-    config: null,
-    conversation: null,
-    inferred: null
+export function detectProject(targetPath, opts = {}) {
+  const structure = {
+    stack: 'unknown',
+    architecture: null,
+    uiLibrary: null,
+    integrations: [],
+    hasVercel: false,
   };
 
   try {
-    // 1. Detect structure (stack, architecture, patterns)
-    if (options.structure !== false) {
-      results.structure = await detectStructure(projectPath);
+    // ── Package.json analysis ──────────────────────────────────────────────
+    const pkgPath = join(targetPath, 'package.json');
+    let pkg = null;
+    if (existsSync(pkgPath)) {
+      try {
+        pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
+      } catch { /* invalid JSON */ }
+    }
+
+    if (pkg) {
+      const allDeps = {
+        ...pkg.dependencies,
+        ...pkg.devDependencies,
+      };
+      const depNames = Object.keys(allDeps);
+      const scripts = Object.keys(pkg.scripts || {});
+
+      // Stack detection from deps
+      if (depNames.includes('next')) {
+        structure.stack = 'nextjs';
+      } else if (depNames.includes('react')) {
+        structure.stack = 'react';
+      } else if (depNames.includes('vue')) {
+        structure.stack = 'vue';
+      } else if (depNames.includes('express') || depNames.includes('fastify') || depNames.includes('hono')) {
+        structure.stack = 'nodejs';
+      } else if (pkg.name) {
+        structure.stack = 'nodejs';
+      }
+
+      // UI library detection
+      if (existsSync(join(targetPath, 'components.json')) || depNames.includes('@shadcn/ui')) {
+        structure.uiLibrary = 'shadcn';
+      } else if (depNames.some(d => d.includes('mudblazor'))) {
+        structure.uiLibrary = 'mudblazor';
+      } else if (depNames.some(d => d.includes('fluent'))) {
+        structure.uiLibrary = 'fluent-ui';
+      }
+
+      // Integrations
+      if (depNames.includes('@supabase/supabase-js') || depNames.includes('@supabase/ssr')) {
+        structure.integrations.push('supabase');
+      }
+      if (depNames.includes('@clerk/nextjs') || depNames.includes('@clerk/clerk-sdk-node')) {
+        structure.integrations.push('clerk');
+      }
+      if (depNames.includes('stripe')) {
+        structure.integrations.push('stripe');
+      }
+
+      // Vercel detection
+      if (depNames.includes('vercel') || scripts.includes('vercel') ||
+          scripts.some(s => (pkg.scripts[s] || '').includes('vercel'))) {
+        structure.hasVercel = true;
+      }
+    }
+
+    // ── .csproj detection ──────────────────────────────────────────────────
+    if (structure.stack === 'unknown') {
+      // Check for .csproj in common locations
+      const csprojLocations = ['.', 'src', 'src/Api', 'src/Web'];
+      for (const loc of csprojLocations) {
+        try {
+          const dir = join(targetPath, loc);
+          if (existsSync(dir)) {
+            const entries = readdirSyncSafe(dir);
+            if (entries.some(e => e.endsWith('.csproj'))) {
+              structure.stack = 'dotnet';
+              // Check for Blazor
+              for (const entry of entries.filter(e => e.endsWith('.csproj'))) {
+                try {
+                  const content = readFileSync(join(dir, entry), 'utf8');
+                  if (content.includes('Microsoft.AspNetCore.Components') || content.includes('Blazor')) {
+                    structure.stack = 'blazor';
+                  }
+                } catch { /* ignore */ }
+              }
+              break;
+            }
+          }
+        } catch { /* ignore */ }
+      }
     }
 
-    // 2. Detect config (technologies, dependencies, versions)
-    if (options.config !== false) {
-      results.config = await detectConfig(projectPath);
+    // ── vercel.json detection ──────────────────────────────────────────────
+    if (existsSync(join(targetPath, 'vercel.json'))) {
+      structure.hasVercel = true;
     }
 
-    // 3. Generate inferred standards
-    if (options.generateStandards !== false) {
-      results.inferred = await generateStandards(results);
+    // ── tsconfig.json detection (fallback for stack) ────────────────────────
+    if (structure.stack === 'unknown' && existsSync(join(targetPath, 'tsconfig.json'))) {
+      structure.stack = 'nodejs';
     }
 
-    return results;
-  } catch (error) {
-    throw new Error(`Detection failed: ${error.message}`);
+    // ── Architecture detection ─────────────────────────────────────────────
+    try {
+      const configPath = join(targetPath, '.morph/config/config.json');
+      if (existsSync(configPath)) {
+        const config = JSON.parse(readFileSync(configPath, 'utf8'));
+        if (config.architecture?.style) {
+          structure.architecture = config.architecture.style;
+        }
+      }
+    } catch { /* ignore */ }
+
+    // ── Docker detection ───────────────────────────────────────────────────
+    if (existsSync(join(targetPath, 'docker-compose.yml')) ||
+        existsSync(join(targetPath, 'docker-compose.yaml')) ||
+        existsSync(join(targetPath, 'Dockerfile'))) {
+      structure.integrations.push('docker');
+    }
+  } catch {
+    // Fail-safe — return defaults
   }
+
+  return {
+    structure,
+    inferred: {
+      markdown: opts.generateStandards ? generateInferredMarkdown(structure) : '',
+    },
+  };
 }
 
 /**
- * Get detection summary
- * @param {Object} results - Detection results
- * @returns {string} Human-readable summary
+ * Safe readdir that returns [] on error.
+ * @param {string} dir
+ * @returns {string[]}
  */
-export function getDetectionSummary(results) {
-  const { structure, config } = results;
-
-  const lines = [
-    '## Detection Summary',
-    '',
-    '### Stack',
-    `- **Type**: ${structure?.stack || 'unknown'}`,
-    `- **Architecture**: ${structure?.architecture || 'unknown'}`,
-    ...(structure?.uiLibrary ? [`- **UI Library**: ${structure.uiLibrary}`] : []),
-    '',
-    '### Technologies',
-    `- **Language**: ${config?.language || 'unknown'}`,
-    `- **Version**: ${config?.version || 'unknown'}`,
-    `- **Package Manager**: ${config?.packageManager || 'unknown'}`,
-    '',
-    '### Patterns Detected',
-    ...(structure?.patterns || []).map(p => `- ${p}`),
-    '',
-    '### Recommendations',
-    ...(results.inferred?.recommendations || []).map(r => `- ${r}`)
-  ];
+function readdirSyncSafe(dir) {
+  try {
+    return readdirSync(dir);
+  } catch {
+    return [];
+  }
+}
 
+/**
+ * Generate a markdown summary from detected structure.
+ * @param {Object} structure
+ * @returns {string}
+ */
+function generateInferredMarkdown(structure) {
+  const lines = [`## Detected Stack: ${structure.stack}`];
+  if (structure.architecture) lines.push(`Architecture: ${structure.architecture}`);
+  if (structure.uiLibrary) lines.push(`UI Library: ${structure.uiLibrary}`);
+  if (structure.integrations.length > 0) lines.push(`Integrations: ${structure.integrations.join(', ')}`);
+  if (structure.hasVercel) lines.push(`Vercel: detected`);
   return lines.join('\n');
 }

package/src/lib/generators/context-generator.js

@@ -358,7 +358,7 @@ export async function generateFeatureContext(projectPath, featureName) {
   }
 
   try {
-    const tasksPath = path.join(outputsDir, '3-tasks', 'tasks.json');
+    const tasksPath = path.join(outputsDir, '4-tasks', 'tasks.json');
     const tasksContent = await fs.readFile(tasksPath, 'utf8');
     tasks = JSON.parse(tasksContent).tasks || [];
   } catch (err) {
@@ -483,7 +483,7 @@ export async function generateFeatureContext(projectPath, featureName) {
     PROPOSAL_PATH: getOutputPath(featureName, 'proposal'),
     SPEC_PATH: getOutputPath(featureName, 'spec'),
     CONTRACTS_PATH: getOutputPath(featureName, 'contracts'),
-    TASKS_PATH: `.morph/features/${featureName}/3-tasks/tasks.json`,
+    TASKS_PATH: `.morph/features/${featureName}/4-tasks/tasks.json`,
     DECISIONS_PATH: getOutputPath(featureName, 'decisions'),
     RECAP_PATH: getOutputPath(featureName, 'recap'),