@polymorphism-tech/morph-spec 2.1.2 → 2.3.0

package/src/commands/create-story.js

@@ -6,6 +6,7 @@
 
 import fs from 'fs';
 import path from 'path';
+import yaml from 'yaml';
 import ora from 'ora';
 import chalk from 'chalk';
 import { logger } from '../utils/logger.js';
@@ -257,10 +258,77 @@ export async function createStoryCommand(feature, storyId, options) {
       // Write file
       await writeFile(outputPath, renderedStory);
 
+      // ============================================================================
+      // Update sprint-status.yaml (create if doesn't exist)
+      // ============================================================================
+      const sprintStatusPath = path.join(process.cwd(), `.morph/project/outputs/${feature}/sprint-status.yaml`);
+      let sprintStatus;
+
+      if (fs.existsSync(sprintStatusPath)) {
+        // Load existing
+        const content = fs.readFileSync(sprintStatusPath, 'utf-8');
+        sprintStatus = yaml.parse(content);
+      } else {
+        // Create new
+        sprintStatus = {
+          feature: feature,
+          epic: options.epic || toTitleCase(feature),
+          created: new Date().toISOString().split('T')[0],
+          updated: new Date().toISOString().split('T')[0],
+          stories: [],
+          metrics: {
+            total_stories: 0,
+            ready: 0,
+            in_progress: 0,
+            ready_for_qa: 0,
+            done: 0,
+            completion_percent: 0
+          },
+          current: null,
+          next: null
+        };
+      }
+
+      // Add new story to sprint-status
+      sprintStatus.stories.push({
+        id: storyId,
+        title: storyData.storyTitle,
+        file: `stories/${storyId}.md`,
+        status: 'ready',
+        created: new Date().toISOString().split('T')[0],
+        assigned: null,
+        started: null,
+        completed: null
+      });
+
+      // Update metrics
+      sprintStatus.metrics.total_stories = sprintStatus.stories.length;
+      sprintStatus.metrics.ready = sprintStatus.stories.filter(s => s.status === 'ready').length;
+      sprintStatus.metrics.in_progress = sprintStatus.stories.filter(s => s.status === 'in_progress').length;
+      sprintStatus.metrics.ready_for_qa = sprintStatus.stories.filter(s => s.status === 'ready_for_qa').length;
+      sprintStatus.metrics.done = sprintStatus.stories.filter(s => s.status === 'done').length;
+      sprintStatus.metrics.completion_percent = sprintStatus.stories.length > 0
+        ? Math.round((sprintStatus.metrics.done / sprintStatus.stories.length) * 100)
+        : 0;
+      sprintStatus.updated = new Date().toISOString().split('T')[0];
+
+      // Set next story if null
+      if (!sprintStatus.next) {
+        sprintStatus.next = {
+          story_id: storyId,
+          recommendation: `Story ${storyId} is ready for development`
+        };
+      }
+
+      // Write sprint-status.yaml
+      const yamlContent = yaml.stringify(sprintStatus);
+      fs.writeFileSync(sprintStatusPath, yamlContent);
+
       spinner.succeed('Story created!');
       logger.blank();
 
       logger.success(`Story file: ${chalk.cyan(outputPath)}`);
+      logger.success(`Updated: ${chalk.cyan('sprint-status.yaml')}`);
       logger.blank();
 
       logger.header('Dev Notes Auto-Injected:');

package/src/commands/init.js

@@ -1,4 +1,5 @@
 import { join } from 'path';
+import fs from 'fs-extra';
 import ora from 'ora';
 import chalk from 'chalk';
 import { logger } from '../utils/logger.js';
@@ -12,7 +13,8 @@ import {
   ensureDir,
   writeFile,
   readFile,
-  updateGitignore
+  updateGitignore,
+  createSymlink
 } from '../utils/file-copier.js';
 import { saveProjectMorphVersion, getInstalledCLIVersion } from '../utils/version-checker.js';
 
@@ -139,12 +141,56 @@ Run \`morph-spec detect\` to analyze your project.
       await copyFile(pricingSchemaSrc, pricingSchemaDest);
     }
 
-    // 9. Copy .claude commands and skills
-    spinner.text = 'Copying Claude commands and skills...';
+    // 9. Copy .claude commands and create symlinks for skills
+    spinner.text = 'Setting up Claude Code integration...';
     const claudeSrc = join(contentDir, '.claude');
     const claudeDest = join(targetPath, '.claude');
+
+    let symlinkCount = 0;
+    let copyCount = 0;
+
     if (await pathExists(claudeSrc)) {
-      await copyDirectory(claudeSrc, claudeDest);
+      // Copy commands directory (slash commands)
+      const commandsSrc = join(claudeSrc, 'commands');
+      const commandsDest = join(claudeDest, 'commands');
+      if (await pathExists(commandsSrc)) {
+        await copyDirectory(commandsSrc, commandsDest);
+      }
+
+      // Create symlinks for skills (or copy if symlink fails)
+      const skillsSrc = join(claudeSrc, 'skills');
+      const skillsDest = join(claudeDest, 'skills');
+
+      if (await pathExists(skillsSrc)) {
+        // Ensure skills destination directory exists
+        await ensureDir(skillsDest);
+
+        // Recursively walk through skills directory
+        const walkDir = async (dir, basePath) => {
+          const entries = await fs.readdir(dir, { withFileTypes: true });
+
+          for (const entry of entries) {
+            const srcPath = join(dir, entry.name);
+            const relPath = join(basePath, entry.name);
+            const destPath = join(skillsDest, relPath);
+
+            if (entry.isDirectory()) {
+              await ensureDir(destPath);
+              await walkDir(srcPath, relPath);
+            } else if (entry.isFile() && entry.name.endsWith('.md')) {
+              // Create symlink for skill files
+              const result = await createSymlink(srcPath, destPath, 'file');
+              if (result === 'symlink') {
+                symlinkCount++;
+              } else {
+                copyCount++;
+              }
+            }
+          }
+        };
+
+        await walkDir(skillsSrc, '');
+      }
     }
 
     // 10. Save version info
@@ -180,7 +226,15 @@ Run \`morph-spec detect\` to analyze your project.
     logger.dim(`  ✓ .morph/standards/ (coding.md, architecture.md, azure.md, ...)`);
     logger.dim(`  ✓ .morph/templates/ (Bicep, integrations, saas, ...)`);
     logger.dim(`  ✓ .morph/project/ (context, standards, outputs)`);
-    logger.dim(`  ✓ .claude/ (commands, skills)`);
+    logger.dim(`  ✓ .claude/commands/ (slash commands)`);
+
+    if (symlinkCount > 0) {
+      logger.dim(`  ✓ .claude/skills/ (${symlinkCount} symlinked)`);
+    } else if (copyCount > 0) {
+      logger.dim(`  ✓ .claude/skills/ (${copyCount} copied)`);
+      logger.warn(`  ⚠ Symlinks not supported (copied instead). Skills won't auto-update.`);
+    }
+
     logger.blank();
 
   } catch (error) {

package/src/commands/state.js

@@ -236,7 +236,7 @@ async function listCommand(options) {
         ? `${feature.tasks.completed}/${feature.tasks.total}`
         : '0/0';
 
-      logger.info(`${statusEmoji}  ${chalk.bright(name)}`);
+      logger.info(`${statusEmoji}  ${chalk.bold(name)}`);
       logger.dim(`   Phase: ${feature.phase.padEnd(16)} │ Tasks: ${progress}`);
       logger.dim(`   Agents: ${feature.activeAgents.slice(0, 5).join(', ') || 'None'}`);
       logger.blank();

package/src/commands/task.js

@@ -0,0 +1,75 @@
+/**
+ * Task management commands
+ * Wrapper for bin/task-manager.js (CommonJS) to ESM
+ */
+
+import { spawn } from 'child_process';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import chalk from 'chalk';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const taskManagerPath = join(__dirname, '..', '..', 'bin', 'task-manager.js');
+
+/**
+ * Execute task-manager.js with given arguments
+ */
+function executeTaskManager(args) {
+  return new Promise((resolve, reject) => {
+    const child = spawn('node', [taskManagerPath, ...args], {
+      stdio: 'inherit',
+      shell: true
+    });
+
+    child.on('close', (code) => {
+      if (code === 0) {
+        resolve();
+      } else {
+        reject(new Error(`Task manager exited with code ${code}`));
+      }
+    });
+
+    child.on('error', (error) => {
+      reject(error);
+    });
+  });
+}
+
+/**
+ * Complete tasks command
+ */
+export async function taskDoneCommand(featureName, taskIds, options) {
+  try {
+    const args = ['done', featureName, ...taskIds];
+    await executeTaskManager(args);
+  } catch (error) {
+    console.error(chalk.red(`Error: ${error.message}`));
+    process.exit(1);
+  }
+}
+
+/**
+ * Start task command
+ */
+export async function taskStartCommand(featureName, taskId, options) {
+  try {
+    const args = ['start', featureName, taskId];
+    await executeTaskManager(args);
+  } catch (error) {
+    console.error(chalk.red(`Error: ${error.message}`));
+    process.exit(1);
+  }
+}
+
+/**
+ * Get next task command
+ */
+export async function taskNextCommand(featureName, options) {
+  try {
+    const args = ['next', featureName];
+    await executeTaskManager(args);
+  } catch (error) {
+    console.error(chalk.red(`Error: ${error.message}`));
+    process.exit(1);
+  }
+}

package/src/lib/continuous-validator.js

@@ -0,0 +1,440 @@
+/**
+ * Continuous Validator
+ *
+ * Background watcher that validates project in real-time.
+ * Detects issues before they become problems.
+ *
+ * MORPH-SPEC 3.0 - Sprint 4
+ */
+
+import { readFileSync, existsSync, watch } from 'fs';
+import { glob } from 'glob';
+import { join, dirname } from 'path';
+import chalk from 'chalk';
+
+export class ContinuousValidator {
+  constructor(projectPath = '.') {
+    this.projectPath = projectPath;
+    this.watchers = [];
+    this.validationInterval = null;
+  }
+
+  /**
+   * Start continuous validation
+   */
+  async start(options = {}) {
+    const { watchMode = true, interval = 30000 } = options;
+
+    console.log(chalk.cyan('🔍 Starting continuous validation...'));
+
+    // Initial validation
+    await this.runAllValidations();
+
+    if (watchMode) {
+      // Watch for file changes
+      this.setupFileWatchers();
+
+      // Periodic validation
+      this.validationInterval = setInterval(() => {
+        this.runAllValidations();
+      }, interval);
+
+      console.log(chalk.gray(`Watching for changes (interval: ${interval/1000}s)...`));
+    }
+  }
+
+  /**
+   * Stop continuous validation
+   */
+  stop() {
+    // Stop file watchers
+    this.watchers.forEach(watcher => watcher.close());
+    this.watchers = [];
+
+    // Stop periodic validation
+    if (this.validationInterval) {
+      clearInterval(this.validationInterval);
+      this.validationInterval = null;
+    }
+
+    console.log(chalk.gray('Stopped continuous validation'));
+  }
+
+  /**
+   * Setup file watchers
+   */
+  setupFileWatchers() {
+    const watchPaths = [
+      '**/*.csproj',
+      '**/Program.cs',
+      'wwwroot/css/**/*.css',
+      'infra/**/*.bicep'
+    ];
+
+    for (const pattern of watchPaths) {
+      const watcher = watch(pattern, { persistent: false }, async (eventType, filename) => {
+        if (filename) {
+          console.log(chalk.gray(`File changed: ${filename}`));
+          await this.runAllValidations();
+        }
+      });
+
+      this.watchers.push(watcher);
+    }
+  }
+
+  /**
+   * Run all validations
+   */
+  async runAllValidations() {
+    const results = await Promise.all([
+      this.validatePackageCompatibility(),
+      this.validateArchitecturePatterns(),
+      this.validateProgramCs(),
+      this.validateUIContrast(),
+      this.validateCosts()
+    ]);
+
+    const errors = results.filter(r => r.level === 'error');
+    const warnings = results.filter(r => r.level === 'warning');
+    const infos = results.filter(r => r.level === 'info');
+
+    // Display summary
+    if (errors.length === 0 && warnings.length === 0) {
+      console.log(chalk.green('✅ All validations passed'));
+    } else {
+      if (errors.length > 0) {
+        console.log(chalk.red(`\n❌ ${errors.length} error(s) found:`));
+        errors.forEach(e => console.log(chalk.red(`  - ${e.message}`)));
+      }
+
+      if (warnings.length > 0) {
+        console.log(chalk.yellow(`\n⚠️  ${warnings.length} warning(s):`));
+        warnings.forEach(w => console.log(chalk.yellow(`  - ${w.message}`)));
+      }
+    }
+
+    // Auto-fix errors if possible
+    const fixableErrors = errors.filter(e => e.autoFix);
+    if (fixableErrors.length > 0) {
+      console.log(chalk.cyan(`\n🔧 Auto-fixing ${fixableErrors.length} issue(s)...`));
+      for (const error of fixableErrors) {
+        try {
+          await error.autoFix();
+          console.log(chalk.green(`  ✅ Fixed: ${error.message}`));
+        } catch (ex) {
+          console.log(chalk.red(`  ❌ Failed to fix: ${error.message}`));
+        }
+      }
+    }
+
+    return { errors, warnings, infos };
+  }
+
+  /**
+   * Validate package compatibility (.NET 10)
+   */
+  async validatePackageCompatibility() {
+    try {
+      const csprojFiles = await glob('**/*.csproj', { ignore: '**/obj/**' });
+
+      for (const file of csprojFiles) {
+        const content = readFileSync(file, 'utf-8');
+
+        // Extract .NET version
+        const tfmMatch = content.match(/<TargetFramework>(.*?)<\/TargetFramework>/);
+        if (!tfmMatch) continue;
+
+        const targetFramework = tfmMatch[1];
+        const dotnetVersion = parseInt(targetFramework.replace('net', ''));
+
+        if (dotnetVersion < 10) {
+          return {
+            level: 'info',
+            message: `${file}: Using .NET ${dotnetVersion} (consider upgrading to .NET 10)`
+          };
+        }
+
+        // Package compatibility matrix
+        const incompatiblePackages = this.checkPackageCompatibility(content, dotnetVersion);
+
+        if (incompatiblePackages.length > 0) {
+          return {
+            level: 'error',
+            message: `${file}: Incompatible packages with .NET ${dotnetVersion}:\n` +
+                     incompatiblePackages.map(p => `    - ${p.name} ${p.version} → upgrade to ${p.requiredVersion}`).join('\n'),
+            packages: incompatiblePackages
+          };
+        }
+      }
+
+      return { level: 'ok' };
+    } catch (error) {
+      return { level: 'error', message: `Package validation failed: ${error.message}` };
+    }
+  }
+
+  /**
+   * Check package compatibility
+   */
+  checkPackageCompatibility(csprojContent, dotnetVersion) {
+    const incompatible = [];
+
+    // Compatibility matrix (from dotnet10-compatibility.md)
+    const matrix = {
+      'MudBlazor': {
+        10: '8.15.0',
+        pattern: /<PackageReference Include="MudBlazor" Version="(.*?)"/
+      },
+      'Microsoft.FluentUI.AspNetCore.Components': {
+        10: '5.0.0',
+        pattern: /<PackageReference Include="Microsoft\.FluentUI\.AspNetCore\.Components" Version="(.*?)"/
+      },
+      'Hangfire.AspNetCore': {
+        10: '1.8.22',
+        pattern: /<PackageReference Include="Hangfire\.AspNetCore" Version="(.*?)"/
+      }
+    };
+
+    for (const [pkg, config] of Object.entries(matrix)) {
+      const match = csprojContent.match(config.pattern);
+      if (match) {
+        const installedVersion = match[1];
+        const requiredVersion = config[dotnetVersion];
+
+        if (requiredVersion && this.compareVersions(installedVersion, requiredVersion) < 0) {
+          incompatible.push({
+            name: pkg,
+            version: installedVersion,
+            requiredVersion
+          });
+        }
+      }
+    }
+
+    return incompatible;
+  }
+
+  /**
+   * Compare semantic versions
+   */
+  compareVersions(v1, v2) {
+    const parts1 = v1.split('.').map(Number);
+    const parts2 = v2.split('.').map(Number);
+
+    for (let i = 0; i < Math.max(parts1.length, parts2.length); i++) {
+      const p1 = parts1[i] || 0;
+      const p2 = parts2[i] || 0;
+      if (p1 < p2) return -1;
+      if (p1 > p2) return 1;
+    }
+
+    return 0;
+  }
+
+  /**
+   * Validate architecture patterns
+   */
+  async validateArchitecturePatterns() {
+    try {
+      const blazorFiles = await glob('**/*.razor.cs', { ignore: '**/obj/**' });
+
+      for (const file of blazorFiles) {
+        const content = readFileSync(file, 'utf-8');
+
+        // Check for Application layer injection (anti-pattern)
+        if (/\[Inject\].*I\w+Command/.test(content)) {
+          return {
+            level: 'error',
+            message: `${file}: Blazor component injecting Application layer directly (use HttpClient pattern)`,
+            reference: 'framework/standards/blazor-pitfalls.md'
+          };
+        }
+
+        // Check for DbContext injection (anti-pattern)
+        if (/\[Inject\].*DbContext/.test(content)) {
+          return {
+            level: 'error',
+            message: `${file}: Blazor component injecting DbContext directly (use HttpClient → API → Handler)`,
+            reference: 'framework/standards/blazor-pitfalls.md'
+          };
+        }
+
+        // Check for JSRuntime in OnInitialized (pitfall)
+        if (/OnInitialized.*JSRuntime/.test(content.replace(/\s+/g, ''))) {
+          return {
+            level: 'warning',
+            message: `${file}: Possible JSRuntime call in OnInitialized (use OnAfterRenderAsync)`,
+            reference: 'framework/standards/blazor-lifecycle.md'
+          };
+        }
+      }
+
+      return { level: 'ok' };
+    } catch (error) {
+      return { level: 'error', message: `Architecture validation failed: ${error.message}` };
+    }
+  }
+
+  /**
+   * Validate Program.cs setup
+   */
+  async validateProgramCs() {
+    try {
+      const programCs = 'Program.cs';
+      if (!existsSync(programCs)) {
+        return { level: 'ok' }; // Not a Blazor project
+      }
+
+      const content = readFileSync(programCs, 'utf-8');
+
+      const checks = [
+        { pattern: /app\.UseStaticFiles\(\)/, message: 'app.UseStaticFiles() is missing', critical: true },
+        { pattern: /AddHttpClient\(\)/, message: 'AddHttpClient() is missing', critical: true },
+        { pattern: /AddHttpContextAccessor\(\)/, message: 'AddHttpContextAccessor() is missing', critical: true }
+      ];
+
+      for (const check of checks) {
+        if (!check.pattern.test(content)) {
+          return {
+            level: check.critical ? 'error' : 'warning',
+            message: `Program.cs: ${check.message}`,
+            reference: 'framework/standards/program-cs-checklist.md'
+          };
+        }
+      }
+
+      // Check middleware order (UseStaticFiles before UseAntiforgery)
+      const staticFilesIndex = content.indexOf('UseStaticFiles');
+      const antiforgeryIndex = content.indexOf('UseAntiforgery');
+
+      if (staticFilesIndex > 0 && antiforgeryIndex > 0 && staticFilesIndex > antiforgeryIndex) {
+        return {
+          level: 'error',
+          message: 'Program.cs: app.UseStaticFiles() must come BEFORE app.UseAntiforgery()',
+          reference: 'framework/standards/program-cs-checklist.md'
+        };
+      }
+
+      return { level: 'ok' };
+    } catch (error) {
+      return { level: 'error', message: `Program.cs validation failed: ${error.message}` };
+    }
+  }
+
+  /**
+   * Validate UI contrast (WCAG 2.1 AA)
+   */
+  async validateUIContrast() {
+    try {
+      const cssFiles = await glob('wwwroot/css/**/*.css', { ignore: '**/node_modules/**' });
+
+      for (const file of cssFiles) {
+        const content = readFileSync(file, 'utf-8');
+
+        // Extract color variables
+        const colors = this.extractColors(content);
+
+        // Check common color pairs
+        const issues = [];
+        const bgColors = colors.filter(c => c.name.includes('background') || c.name.includes('bg'));
+        const textColors = colors.filter(c => c.name.includes('text') || c.name.includes('color'));
+
+        for (const bg of bgColors) {
+          for (const text of textColors) {
+            const ratio = this.calculateContrastRatio(bg.value, text.value);
+            if (ratio < 4.5) { // WCAG AA minimum for text
+              issues.push({ bg: bg.name, text: text.name, ratio: ratio.toFixed(2) });
+            }
+          }
+        }
+
+        if (issues.length > 0) {
+          return {
+            level: 'warning',
+            message: `${file}: Low contrast detected (WCAG AA requires 4.5:1):\n` +
+                     issues.map(i => `    - ${i.text} on ${i.bg}: ${i.ratio}:1`).join('\n')
+          };
+        }
+      }
+
+      return { level: 'ok' };
+    } catch (error) {
+      return { level: 'ok' }; // CSS parsing is optional
+    }
+  }
+
+  /**
+   * Extract colors from CSS
+   */
+  extractColors(css) {
+    const colors = [];
+    const hexPattern = /--([\w-]+):\s*(#[0-9a-fA-F]{3,6})/g;
+    let match;
+
+    while ((match = hexPattern.exec(css)) !== null) {
+      colors.push({ name: match[1], value: match[2] });
+    }
+
+    return colors;
+  }
+
+  /**
+   * Calculate contrast ratio (WCAG formula)
+   */
+  calculateContrastRatio(color1, color2) {
+    const l1 = this.getLuminance(color1);
+    const l2 = this.getLuminance(color2);
+
+    const lighter = Math.max(l1, l2);
+    const darker = Math.min(l1, l2);
+
+    return (lighter + 0.05) / (darker + 0.05);
+  }
+
+  /**
+   * Get relative luminance
+   */
+  getLuminance(hex) {
+    const rgb = this.hexToRgb(hex);
+    if (!rgb) return 0;
+
+    const [r, g, b] = rgb.map(val => {
+      val = val / 255;
+      return val <= 0.03928 ? val / 12.92 : Math.pow((val + 0.055) / 1.055, 2.4);
+    });
+
+    return 0.2126 * r + 0.7152 * g + 0.0722 * b;
+  }
+
+  /**
+   * Convert hex to RGB
+   */
+  hexToRgb(hex) {
+    const result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
+    return result ? [
+      parseInt(result[1], 16),
+      parseInt(result[2], 16),
+      parseInt(result[3], 16)
+    ] : null;
+  }
+
+  /**
+   * Validate costs (Bicep files)
+   */
+  async validateCosts() {
+    try {
+      const bicepFiles = await glob('infra/**/*.bicep');
+
+      if (bicepFiles.length === 0) {
+        return { level: 'ok' }; // No infrastructure
+      }
+
+      // This would integrate with cost-calculator.js
+      // For now, just check if files exist
+      return { level: 'info', message: `Found ${bicepFiles.length} Bicep file(s) - run 'npx morph-spec cost' to estimate costs` };
+    } catch (error) {
+      return { level: 'ok' };
+    }
+  }
+}