@polymorphism-tech/morph-spec 2.4.0 → 3.0.1

package/src/lib/validation-runner.js

@@ -11,17 +11,32 @@ import { existsSync, readFileSync } from 'fs';
 import { join } from 'path';
 import chalk from 'chalk';
 import { loadState } from './state-manager.js';
+import { loadConstraints } from './decision-constraint-loader.js';
 
 /**
- * Validator registry — maps agent IDs to the validators they activate
+ * Load agent → validators map from agents.json (data-driven)
+ * @param {string} projectPath - Root path of the project
+ * @returns {Object} Map of agent IDs to validator arrays
  */
-const AGENT_VALIDATOR_MAP = {
-  'blazor-builder': ['architecture', 'blazor', 'blazor-concurrency', 'blazor-state', 'css'],
-  'nextjs-expert': ['packages'],
-  'ef-modeler': ['blazor-concurrency'],
-  'standards-architect': ['architecture', 'packages'],
-  'ui-ux-designer': ['css', 'contrast']
-};
+function loadAgentValidatorMap(projectPath) {
+  try {
+    const agentsPath = join(projectPath, 'content/.morph/config/agents.json');
+    const agentsConfig = JSON.parse(readFileSync(agentsPath, 'utf8'));
+
+    const map = {};
+    Object.entries(agentsConfig.agents || {}).forEach(([agentId, agent]) => {
+      if (!agentId.startsWith('_comment') && agent.validators && agent.validators.length > 0) {
+        map[agentId] = agent.validators;
+      }
+    });
+
+    return map;
+  } catch (err) {
+    console.warn(chalk.yellow('⚠️  Failed to load agents.json - no validators will run'));
+    console.warn(chalk.gray(`   Run 'morph-spec init' to set up MORPH-SPEC configuration`));
+    return {}; // Empty map = honest failure
+  }
+}
 
 /**
  * Run all relevant validators for a feature
@@ -39,11 +54,18 @@ export async function runValidation(projectPath, featureName, options = {}) {
     errors: 0,
     warnings: 0,
     issues: [],
-    summary: ''
+    summary: '',
+    results: {} // Per-validator results for hooks integration
   };
 
+  // Load decision constraints from decisions.md
+  const constraints = loadConstraints(projectPath, featureName);
+
   // Determine which validators to run
-  const validatorIds = options.validators || detectValidators(featureName);
+  const validatorIds = options.validators || detectValidators(featureName, projectPath);
+
+  // Merge constraint-enabled validators
+  validatorIds.push(...constraints.enabledValidators);
 
   if (validatorIds.length === 0) {
     result.summary = 'No validators applicable for this feature';
@@ -52,6 +74,9 @@ export async function runValidation(projectPath, featureName, options = {}) {
 
   if (options.verbose) {
     console.log(chalk.gray(`\n  Running validators: ${validatorIds.join(', ')}`));
+    if (constraints.enabledValidators.length > 0) {
+      console.log(chalk.gray(`  (+ ${constraints.enabledValidators.length} from decisions)`));
+    }
   }
 
   // Always run contract compliance if contracts.cs exists
@@ -66,7 +91,13 @@ export async function runValidation(projectPath, featureName, options = {}) {
   // Run each validator
   for (const validatorId of uniqueValidators) {
     try {
-      const validatorResult = await runSingleValidator(validatorId, projectPath, featureName, options);
+      // Pass validator-specific constraints from decisions.md
+      const validatorOptions = {
+        ...options,
+        constraints: constraints.validators[validatorId] || {}
+      };
+
+      const validatorResult = await runSingleValidator(validatorId, projectPath, featureName, validatorOptions);
 
       if (validatorResult) {
         result.errors += validatorResult.errors || 0;
@@ -75,11 +106,21 @@ export async function runValidation(projectPath, featureName, options = {}) {
         if (validatorResult.issues) {
           result.issues.push(...validatorResult.issues);
         }
+
+        // Store per-validator results for hooks
+        result.results[validatorId] = {
+          passed: (validatorResult.errors || 0) === 0,
+          issues: validatorResult.issues || []
+        };
       }
     } catch (err) {
       if (options.verbose) {
         console.log(chalk.yellow(`  ⚠ Validator '${validatorId}' failed: ${err.message}`));
       }
+      result.results[validatorId] = {
+        passed: false,
+        error: err.message
+      };
     }
   }
 
@@ -93,8 +134,11 @@ export async function runValidation(projectPath, featureName, options = {}) {
 
 /**
  * Detect which validators to run based on feature's active agents
+ * @param {string} featureName - Feature name
+ * @param {string} projectPath - Project root path (default: current directory)
+ * @returns {string[]} Array of validator IDs to run
  */
-function detectValidators(featureName) {
+function detectValidators(featureName, projectPath = '.') {
   const state = loadState(false);
   if (!state || !state.features[featureName]) {
     return ['architecture', 'packages']; // Default validators
@@ -104,8 +148,11 @@ function detectValidators(featureName) {
   const agents = feature.activeAgents || [];
   const validatorSet = new Set();
 
+  // Load agent → validators map from agents.json (data-driven)
+  const agentValidatorMap = loadAgentValidatorMap(projectPath);
+
   for (const agentId of agents) {
-    const validators = AGENT_VALIDATOR_MAP[agentId] || [];
+    const validators = agentValidatorMap[agentId] || [];
     validators.forEach(v => validatorSet.add(v));
   }
 
@@ -177,6 +224,11 @@ async function runSingleValidator(validatorId, projectPath, featureName, options
       return await validateContracts(projectPath, featureName, options);
     }
 
+    case 'design-system': {
+      const { validateDesignSystem } = await import('./validators/design-system-validator.js');
+      return await validateDesignSystem(projectPath, featureName, options);
+    }
+
     default:
       if (options.verbose) {
         console.log(chalk.gray(`  Unknown validator: ${validatorId}`));

package/src/lib/validators/design-system-validator.js

@@ -0,0 +1,231 @@
+/**
+ * Design System Validator
+ *
+ * Validates that CSS and Razor files only use design system tokens
+ * instead of hardcoded colors, fonts, or spacing values.
+ *
+ * MORPH-SPEC 3.0 - Phase 3: Design System Enforcement
+ */
+
+import { existsSync, readFileSync, readdirSync, statSync } from 'fs';
+import { join, extname } from 'path';
+import { parseColors, parseTypography, parseSpacing } from '../design-system-generator.js';
+import { detectDesignSystem } from '../design-system-detector.js';
+
+/**
+ * Validate design system compliance
+ * @param {string} projectPath - Root path of the project
+ * @param {string} featureName - Feature name (optional)
+ * @param {Object} options - Validation options
+ * @returns {Object} { errors, warnings, issues }
+ */
+export async function validateDesignSystem(projectPath, featureName = null, options = {}) {
+  const result = {
+    errors: 0,
+    warnings: 0,
+    issues: []
+  };
+
+  // Detect design system
+  const dsDetection = detectDesignSystem(projectPath, featureName);
+
+  if (!dsDetection.hasDesignSystem) {
+    result.errors++;
+    result.issues.push({
+      level: 'error',
+      message: 'No design system found',
+      solution: 'Create a design system at .morph/project/design-system.md or run design system generator'
+    });
+    return result;
+  }
+
+  // Parse design system
+  let designSystem;
+  try {
+    const markdown = readFileSync(dsDetection.path, 'utf8');
+    designSystem = {
+      colors: parseColors(markdown),
+      typography: parseTypography(markdown),
+      spacing: parseSpacing(markdown)
+    };
+  } catch (err) {
+    result.errors++;
+    result.issues.push({
+      level: 'error',
+      message: `Failed to parse design system: ${err.message}`,
+      file: dsDetection.path
+    });
+    return result;
+  }
+
+  // Build allowed color set
+  const allowedColors = new Set();
+  Object.values(designSystem.colors.primary).forEach(hex => allowedColors.add(hex.toLowerCase()));
+  Object.values(designSystem.colors.secondary).forEach(hex => allowedColors.add(hex.toLowerCase()));
+  Object.values(designSystem.colors.neutral).forEach(hex => allowedColors.add(hex.toLowerCase()));
+  Object.values(designSystem.colors.semantic).forEach(hex => allowedColors.add(hex.toLowerCase()));
+
+  // Common system colors (allowed)
+  const systemColors = new Set([
+    '#ffffff', '#fff', '#000000', '#000', 'transparent', 'inherit', 'currentcolor'
+  ]);
+
+  // Scan CSS files
+  const cssFiles = findFiles(projectPath, ['.css'], options.scanPaths || ['wwwroot/css', 'styles']);
+  for (const cssFile of cssFiles) {
+    const cssResult = validateCSSFile(cssFile, allowedColors, systemColors);
+    result.warnings += cssResult.warnings;
+    result.issues.push(...cssResult.issues);
+  }
+
+  // Scan Razor files
+  const razorFiles = findFiles(projectPath, ['.razor'], options.scanPaths || ['Components', 'Pages']);
+  for (const razorFile of razorFiles) {
+    const razorResult = validateRazorFile(razorFile, allowedColors, systemColors);
+    result.warnings += razorResult.warnings;
+    result.issues.push(...razorResult.issues);
+  }
+
+  return result;
+}
+
+/**
+ * Find files with specific extensions in directories
+ */
+function findFiles(projectPath, extensions, scanPaths) {
+  const files = [];
+
+  for (const scanPath of scanPaths) {
+    const fullPath = join(projectPath, scanPath);
+    if (!existsSync(fullPath)) continue;
+
+    try {
+      walkDirectory(fullPath, extensions, files);
+    } catch (err) {
+      // Ignore permission errors
+    }
+  }
+
+  return files;
+}
+
+/**
+ * Recursively walk directory
+ */
+function walkDirectory(dir, extensions, files) {
+  const items = readdirSync(dir);
+
+  for (const item of items) {
+    const fullPath = join(dir, item);
+    const stat = statSync(fullPath);
+
+    if (stat.isDirectory()) {
+      walkDirectory(fullPath, extensions, files);
+    } else if (stat.isFile()) {
+      const ext = extname(fullPath);
+      if (extensions.includes(ext)) {
+        files.push(fullPath);
+      }
+    }
+  }
+}
+
+/**
+ * Validate CSS file for hardcoded colors
+ */
+function validateCSSFile(filePath, allowedColors, systemColors) {
+  const result = {
+    warnings: 0,
+    issues: []
+  };
+
+  try {
+    const content = readFileSync(filePath, 'utf8');
+
+    // Match hex colors: #RGB or #RRGGBB
+    const hexRegex = /#([0-9A-Fa-f]{3}|[0-9A-Fa-f]{6})\b/g;
+
+    let match;
+    let lineNumber = 1;
+    let lastIndex = 0;
+
+    while ((match = hexRegex.exec(content)) !== null) {
+      const hex = match[0].toLowerCase();
+
+      // Count line number
+      const upToMatch = content.substring(lastIndex, match.index);
+      lineNumber += (upToMatch.match(/\n/g) || []).length;
+      lastIndex = match.index;
+
+      // Skip if in allowed or system colors
+      if (allowedColors.has(hex) || systemColors.has(hex)) {
+        continue;
+      }
+
+      result.warnings++;
+      result.issues.push({
+        level: 'warning',
+        message: `Hardcoded color ${hex} not in design system palette`,
+        file: filePath,
+        line: lineNumber,
+        solution: 'Use CSS variable like var(--color-primary-500) instead'
+      });
+    }
+  } catch (err) {
+    // Ignore read errors
+  }
+
+  return result;
+}
+
+/**
+ * Validate Razor file for inline styles with hardcoded colors
+ */
+function validateRazorFile(filePath, allowedColors, systemColors) {
+  const result = {
+    warnings: 0,
+    issues: []
+  };
+
+  try {
+    const content = readFileSync(filePath, 'utf8');
+
+    // Match style="" attributes with hex colors
+    const styleRegex = /style\s*=\s*"([^"]*)"/gi;
+
+    let match;
+    while ((match = styleRegex.exec(content)) !== null) {
+      const styleContent = match[1];
+
+      // Find hex colors in style attribute
+      const hexRegex = /#([0-9A-Fa-f]{3}|[0-9A-Fa-f]{6})\b/g;
+      let hexMatch;
+
+      while ((hexMatch = hexRegex.exec(styleContent)) !== null) {
+        const hex = hexMatch[0].toLowerCase();
+
+        // Skip if in allowed or system colors
+        if (allowedColors.has(hex) || systemColors.has(hex)) {
+          continue;
+        }
+
+        // Count line number
+        const upToMatch = content.substring(0, match.index);
+        const lineNumber = (upToMatch.match(/\n/g) || []).length + 1;
+
+        result.warnings++;
+        result.issues.push({
+          level: 'warning',
+          message: `Inline style with hardcoded color ${hex} not in design system`,
+          file: filePath,
+          line: lineNumber,
+          solution: 'Use CSS class with design system variables or component props instead of inline styles'
+        });
+      }
+    }
+  } catch (err) {
+    // Ignore read errors
+  }
+
+  return result;
+}

package/src/utils/file-copier.js

@@ -1,14 +1,20 @@
 import fs from 'fs-extra';
-import { join, dirname } from 'path';
+import { join, dirname, resolve } from 'path';
 import { fileURLToPath } from 'url';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
+function isSamePath(a, b) {
+  return resolve(a) === resolve(b);
+}
+
 export function getContentDir() {
   return join(__dirname, '..', '..', 'content');
 }
 
 export async function copyDirectory(src, dest, options = {}) {
+  if (isSamePath(src, dest)) return;
+
   const { filter, overwrite = true } = options;
 
   await fs.copy(src, dest, {
@@ -19,6 +25,8 @@ export async function copyDirectory(src, dest, options = {}) {
 }
 
 export async function copyFile(src, dest) {
+  if (isSamePath(src, dest)) return;
+
   await fs.ensureDir(dirname(dest));
   await fs.copy(src, dest, { overwrite: true });
 }