@polymorphism-tech/morph-spec 2.1.2 → 2.3.0

package/bin/validate.js

@@ -0,0 +1,268 @@
+#!/usr/bin/env node
+
+/**
+ * Validation CLI
+ *
+ * Runs all validators (package, architecture, contrast) on the project.
+ * Part of Sprint 4: Continuous Validation + Learning System
+ *
+ * Usage:
+ *   morph-spec validate [options]
+ *   morph-spec validate packages
+ *   morph-spec validate architecture
+ *   morph-spec validate contrast
+ *   morph-spec validate all
+ *
+ * MORPH-SPEC 3.0
+ */
+
+import chalk from 'chalk';
+import { validatePackages } from '../src/lib/validators/package-validator.js';
+import { validateArchitecture } from '../src/lib/validators/architecture-validator.js';
+import { validateContrast } from '../src/lib/validators/ui-contrast-validator.js';
+import { LearningSystem } from '../src/lib/learning-system.js';
+
+const VALIDATORS = {
+  packages: {
+    name: 'Package Compatibility',
+    description: 'Validates NuGet package versions against .NET compatibility matrix',
+    run: validatePackages
+  },
+  architecture: {
+    name: 'Architecture Patterns',
+    description: 'Detects DI anti-patterns and lifecycle issues in Blazor',
+    run: validateArchitecture
+  },
+  contrast: {
+    name: 'UI Contrast (WCAG)',
+    description: 'Validates color contrast ratios for accessibility',
+    run: validateContrast
+  }
+};
+
+/**
+ * Main validation command
+ */
+export async function validateCommand(args = []) {
+  const validatorName = args[0] || 'all';
+  const options = parseOptions(args);
+
+  console.log(chalk.bold.cyan('\n🔍 MORPH-SPEC Validator\n'));
+
+  if (validatorName === 'all') {
+    await runAllValidators(options);
+  } else if (VALIDATORS[validatorName]) {
+    await runValidator(validatorName, options);
+  } else {
+    console.error(chalk.red(`❌ Unknown validator: ${validatorName}`));
+    console.log(chalk.gray('\nAvailable validators:'));
+    for (const [name, validator] of Object.entries(VALIDATORS)) {
+      console.log(chalk.gray(`  - ${name}: ${validator.description}`));
+    }
+    console.log(chalk.gray('  - all: Run all validators'));
+    process.exit(1);
+  }
+
+  // Show learning insights if --insights flag
+  if (options.insights) {
+    await showLearningInsights(options);
+  }
+}
+
+/**
+ * Run all validators
+ */
+async function runAllValidators(options) {
+  const results = {};
+  let totalErrors = 0;
+  let totalWarnings = 0;
+
+  console.log(chalk.gray('Running all validators...\n'));
+
+  for (const [name, validator] of Object.entries(VALIDATORS)) {
+    console.log(chalk.cyan(`\n▸ ${validator.name}`));
+    console.log(chalk.gray(`  ${validator.description}\n`));
+
+    try {
+      const result = await validator.run('.', {
+        verbose: options.verbose,
+        autoFix: options.autoFix
+      });
+
+      results[name] = result;
+
+      // Count errors/warnings
+      if (result.errors !== undefined) {
+        totalErrors += result.errors;
+        totalWarnings += result.warnings || 0;
+      } else if (result.results) {
+        // Count issues in results array
+        const issues = result.results.flatMap(r => r.issues || []);
+        totalErrors += issues.filter(i => i.level === 'error').length;
+        totalWarnings += issues.filter(i => i.level === 'warning').length;
+      }
+
+    } catch (error) {
+      console.error(chalk.red(`  ❌ Failed: ${error.message}`));
+      results[name] = { status: 'error', error: error.message };
+    }
+  }
+
+  // Summary
+  console.log(chalk.bold.cyan('\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n'));
+  console.log(chalk.bold('📊 Validation Summary\n'));
+
+  if (totalErrors === 0 && totalWarnings === 0) {
+    console.log(chalk.green('✅ All validations passed!'));
+  } else {
+    if (totalErrors > 0) {
+      console.log(chalk.red(`❌ ${totalErrors} error(s) found`));
+    }
+    if (totalWarnings > 0) {
+      console.log(chalk.yellow(`⚠️  ${totalWarnings} warning(s) found`));
+    }
+  }
+
+  console.log('');
+
+  // Exit with error code if errors found
+  if (totalErrors > 0 && !options.noFail) {
+    process.exit(1);
+  }
+}
+
+/**
+ * Run single validator
+ */
+async function runValidator(name, options) {
+  const validator = VALIDATORS[name];
+
+  console.log(chalk.cyan(`▸ ${validator.name}`));
+  console.log(chalk.gray(`  ${validator.description}\n`));
+
+  try {
+    const result = await validator.run('.', {
+      verbose: true, // Always verbose for single validator
+      autoFix: options.autoFix,
+      wcagLevel: options.wcagLevel
+    });
+
+    if (result.status === 'ok') {
+      console.log(chalk.green('\n✅ Validation passed!\n'));
+    } else {
+      console.log(chalk.yellow('\n⚠️  Validation completed with issues\n'));
+
+      if (result.errors > 0 && !options.noFail) {
+        process.exit(1);
+      }
+    }
+
+  } catch (error) {
+    console.error(chalk.red(`\n❌ Validation failed: ${error.message}\n`));
+    if (!options.noFail) {
+      process.exit(1);
+    }
+  }
+}
+
+/**
+ * Show learning insights
+ */
+async function showLearningInsights(options) {
+  console.log(chalk.bold.cyan('\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n'));
+
+  const learner = new LearningSystem('.');
+  learner.formatInsights();
+
+  if (options.verbose) {
+    const suggestions = learner.getAllSuggestions();
+    learner.formatSuggestions(suggestions);
+  }
+}
+
+/**
+ * Parse command-line options
+ */
+function parseOptions(args) {
+  const options = {
+    verbose: false,
+    autoFix: false,
+    noFail: false,
+    insights: false,
+    wcagLevel: 'AA'
+  };
+
+  for (const arg of args) {
+    if (arg === '--verbose' || arg === '-v') {
+      options.verbose = true;
+    } else if (arg === '--auto-fix' || arg === '--fix') {
+      options.autoFix = true;
+    } else if (arg === '--no-fail') {
+      options.noFail = true;
+    } else if (arg === '--insights' || arg === '-i') {
+      options.insights = true;
+    } else if (arg === '--wcag-aaa') {
+      options.wcagLevel = 'AAA';
+    }
+  }
+
+  return options;
+}
+
+/**
+ * Show help
+ */
+export function showValidateHelp() {
+  console.log(`
+${chalk.bold.cyan('morph-spec validate')} - Run project validations
+
+${chalk.bold('USAGE')}
+  morph-spec validate [validator] [options]
+
+${chalk.bold('VALIDATORS')}
+  all             Run all validators (default)
+  packages        Validate NuGet package compatibility (.NET 10)
+  architecture    Validate architecture patterns (DI, lifecycle)
+  contrast        Validate UI contrast ratios (WCAG 2.1)
+
+${chalk.bold('OPTIONS')}
+  --verbose, -v        Show detailed output
+  --auto-fix, --fix    Auto-fix issues where possible
+  --no-fail            Don't exit with error code
+  --insights, -i       Show learning insights
+  --wcag-aaa           Use WCAG AAA standard (stricter)
+
+${chalk.bold('EXAMPLES')}
+  morph-spec validate                    # Run all validators
+  morph-spec validate packages --fix     # Validate packages and auto-fix
+  morph-spec validate architecture -v    # Verbose architecture validation
+  morph-spec validate contrast --wcag-aaa # Stricter contrast validation
+  morph-spec validate all --insights     # All validators + AI insights
+
+${chalk.bold('EXIT CODES')}
+  0    All validations passed
+  1    Validation errors found (unless --no-fail)
+
+${chalk.bold('INTEGRATION')}
+  Add to pre-commit hook:
+    morph-spec validate --no-fail
+
+  CI/CD pipeline:
+    morph-spec validate || exit 1
+`);
+}
+
+// Run if called directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+  const args = process.argv.slice(2);
+
+  if (args.includes('--help') || args.includes('-h')) {
+    showValidateHelp();
+    process.exit(0);
+  }
+
+  validateCommand(args).catch(error => {
+    console.error(chalk.red(`\n❌ Error: ${error.message}\n`));
+    process.exit(1);
+  });
+}

package/content/.claude/skills/specialists/ef-modeler.md

@@ -13,6 +13,17 @@ Especialista em Entity Framework Core para modelagem de dados e banco de dados.
 
 Keywords: `entity`, `database`, `migration`, `ef core`, `dbcontext`, `table`, `column`, `relationship`, `query`
 
+---
+
+## ⚠️ .NET 10 Compatibility
+
+**ALWAYS check package version:**
+- Entity Framework Core: **≥ 10.0.0** (required for .NET 10)
+- New features: Vector search, primitive collections
+- Breaking changes: Required navigation properties, query splitting
+
+**Consult:** `framework/standards/dotnet10-compatibility.md`
+
 ## Estrutura de Entidades
 
 ```csharp

package/content/.claude/skills/specialists/hangfire-orchestrator.md

@@ -13,6 +13,16 @@ Especialista em background jobs, tarefas agendadas e processamento assíncrono c
 
 Keywords: `scheduled`, `job`, `background`, `cron`, `recurring`, `batch`, `queue`, `hangfire`, `task`
 
+---
+
+## ⚠️ .NET 10 Compatibility
+
+**ALWAYS check package version:**
+- Hangfire.AspNetCore: **≥ 1.8.22** (required for .NET 10)
+- No breaking changes from .NET 9
+
+**Consult:** `framework/standards/dotnet10-compatibility.md`
+
 ## Por que Hangfire (não Azure Functions)
 
 | Aspecto | Hangfire | Azure Functions |

package/content/.claude/skills/specialists/ui-ux-designer.md

@@ -19,6 +19,46 @@ Especialista em design de interfaces, experiência do usuário e componentes Bla
 - `blazor`, `component`, `page`, `razor`, `ui`, `ux`, `design`, `layout`
 - `wizard`, `dashboard`, `form`, `chart`, `table`, `dialog`, `modal`
 
+---
+
+## 🎨 Design Moderno (2025+)
+
+**SEMPRE aim for modern, beautiful UI:**
+
+### Visual Trends
+- **Glassmorphism**: `backdrop-filter: blur(10px)`, semi-transparent backgrounds
+- **Gradients**: Purple (#667eea → #764ba2), Blue-Purple (#4facfe → #00f2fe)
+- **Soft Shadows**: `box-shadow: 0 4px 6px rgba(0,0,0,0.1)`
+- **Rounded Corners**: `border-radius: 12px-16px` (não 4px!)
+- **Micro-interactions**: Hover effects, transitions (transform, scale, opacity)
+
+### Component Patterns
+- **Cards with elevation**: Subtle shadow + hover lift effect
+- **Skeleton loaders**: Durante loading, não apenas spinner
+- **Toast notifications**: Bottom-right, auto-dismiss
+- **Empty states**: Ilustração + CTA, nunca apenas texto
+- **Dark mode support**: ALWAYS design for both light/dark
+
+### Layout Principles
+- **Whitespace**: Generous padding (32px-48px containers, não 16px)
+- **Grid systems**: 12-column grid, gap 24px-32px
+- **Typography hierarchy**: Clear sizes (xs: 12px, sm: 14px, base: 16px, lg: 18px, xl: 20px, 2xl: 24px)
+- **Contrast**: WCAG AA minimum (4.5:1 text, 3:1 UI components)
+
+### Referências Modernas
+- **Linear** (linear.app): Clean, purple gradients, minimal
+- **Vercel** (vercel.com): Black & white, subtle animations
+- **Stripe** (stripe.com): Professional, blue accent, great forms
+- **Dribbble** (dribbble.com/tags/dashboard): Modern dashboard designs
+- **Awwwards** (awwwards.com): Award-winning UI patterns
+
+**Framework integration:**
+- Use `src/lib/mockup-generator.js` for wireframes
+- Use `framework/templates/ui-components/` for component scaffolding
+- Consult `framework/standards/blazor-pitfalls.md` for Blazor-specific patterns
+
+---
+
 ## Deliverables da FASE 1.5
 
 | Arquivo | Conteúdo |

package/content/.claude/skills/stacks/dotnet-blazor.md

@@ -17,6 +17,24 @@ Stack principal para desenvolvimento de aplicações web com .NET e Blazor Serve
 
 Keywords: `blazor`, `razor`, `server-side`, `.net`, `csharp`, `dotnet`
 
+---
+
+## ⚠️ CRITICAL PITFALLS (Read FIRST!)
+
+**ALWAYS consult framework standards before implementing:**
+- `framework/standards/blazor-pitfalls.md` - Common issues & solutions
+- `framework/standards/blazor-lifecycle.md` - Lifecycle patterns
+- `framework/standards/program-cs-checklist.md` - Required Program.cs setup
+- `framework/standards/dotnet10-compatibility.md` - Package compatibility
+
+**Quick Checklist:**
+- [ ] DI Pattern: Use HttpClient, NOT direct Application layer injection
+- [ ] Lifecycle: JSRuntime ONLY in OnAfterRenderAsync(firstRender)
+- [ ] Program.cs: app.UseStaticFiles() BEFORE app.UseAntiforgery()
+- [ ] File Upload: Specify maxAllowedSize in OpenReadStream()
+- [ ] RenderMode: NO @rendermode on MainLayout
+- [ ] Package Versions: MudBlazor ≥ 8.15.0 for .NET 10
+
 ## Estrutura de Projeto
 
 ```

package/content/.morph/examples/state-v3.json

@@ -0,0 +1,188 @@
+{
+  "version": "3.0.0",
+  "project": {
+    "name": "FishArt",
+    "type": "blazor-server",
+    "createdAt": "2024-01-15T10:00:00Z",
+    "updatedAt": "2024-01-15T14:30:00Z"
+  },
+  "features": {
+    "scheduled-reports": {
+      "status": "in_progress",
+      "phase": "implement",
+      "activeAgents": [
+        "standards-architect",
+        "blazor-builder",
+        "ef-modeler",
+        "hangfire-orchestrator"
+      ],
+      "tasks": [
+        {
+          "id": "T001",
+          "title": "Create ScheduledReport entity",
+          "status": "completed",
+          "completedAt": "2024-01-15T10:30:00Z",
+          "completedBy": "claude",
+          "dependencies": [],
+          "files": [
+            "Domain/Entities/ScheduledReport.cs",
+            "Infrastructure/Persistence/Config/ScheduledReportConfig.cs"
+          ],
+          "checkpoint": "CHECKPOINT_001"
+        },
+        {
+          "id": "T002",
+          "title": "Create CreateReportCommand + Handler",
+          "status": "completed",
+          "completedAt": "2024-01-15T11:15:00Z",
+          "completedBy": "claude",
+          "dependencies": ["T001"],
+          "files": [
+            "Application/Commands/CreateReport/CreateReportCommand.cs",
+            "Application/Commands/CreateReport/CreateReportHandler.cs"
+          ]
+        },
+        {
+          "id": "T003",
+          "title": "Create Hangfire job for report generation",
+          "status": "completed",
+          "completedAt": "2024-01-15T12:00:00Z",
+          "completedBy": "claude",
+          "dependencies": ["T002"],
+          "files": [
+            "Infrastructure/Jobs/GenerateReportJob.cs"
+          ],
+          "checkpoint": "CHECKPOINT_002"
+        },
+        {
+          "id": "T004",
+          "title": "Create ReportList component (Blazor)",
+          "status": "in_progress",
+          "startedAt": "2024-01-15T13:00:00Z",
+          "dependencies": ["T001"],
+          "files": [
+            "Components/Reports/ReportList.razor",
+            "Components/Reports/ReportList.razor.cs",
+            "Components/Reports/ReportList.razor.css"
+          ]
+        },
+        {
+          "id": "T005",
+          "title": "Create CreateReportForm component (Blazor)",
+          "status": "pending",
+          "dependencies": ["T002"],
+          "files": [
+            "Components/Reports/CreateReportForm.razor",
+            "Components/Reports/CreateReportForm.razor.cs",
+            "Components/Reports/CreateReportForm.razor.css"
+          ]
+        },
+        {
+          "id": "T006",
+          "title": "Create API controller for reports",
+          "status": "pending",
+          "dependencies": ["T002"],
+          "files": [
+            "API/Controllers/ReportsController.cs"
+          ]
+        },
+        {
+          "id": "T007",
+          "title": "Add Hangfire dashboard configuration",
+          "status": "pending",
+          "dependencies": ["T003"],
+          "files": [
+            "Program.cs"
+          ]
+        },
+        {
+          "id": "T008",
+          "title": "Create unit tests for CreateReportCommand",
+          "status": "pending",
+          "dependencies": ["T002"],
+          "files": [
+            "Tests/Application/Commands/CreateReportCommandTests.cs"
+          ]
+        },
+        {
+          "id": "T009",
+          "title": "Create integration tests for report generation",
+          "status": "pending",
+          "dependencies": ["T003", "T006"],
+          "files": [
+            "Tests/Integration/ReportGenerationTests.cs"
+          ],
+          "checkpoint": "CHECKPOINT_003"
+        }
+      ],
+      "progress": {
+        "total": 9,
+        "completed": 3,
+        "inProgress": 1,
+        "pending": 5,
+        "percentage": 33
+      },
+      "checkpoints": [
+        {
+          "id": "CHECKPOINT_001",
+          "timestamp": "2024-01-15T10:30:00Z",
+          "tasksCompleted": ["T001"],
+          "note": "Checkpoint: Create ScheduledReport entity"
+        },
+        {
+          "id": "CHECKPOINT_002",
+          "timestamp": "2024-01-15T12:00:00Z",
+          "tasksCompleted": ["T003"],
+          "note": "Checkpoint: Create Hangfire job for report generation"
+        },
+        {
+          "id": "CHECKPOINT_AUTO_1705326000000",
+          "timestamp": "2024-01-15T12:00:00Z",
+          "tasksCompleted": ["T001", "T002", "T003"],
+          "note": "Auto-checkpoint: 3 tasks completed"
+        }
+      ],
+      "outputs": {
+        "proposal": {
+          "created": true,
+          "path": ".morph/project/outputs/scheduled-reports/proposal.md"
+        },
+        "spec": {
+          "created": true,
+          "path": ".morph/project/outputs/scheduled-reports/spec.md"
+        },
+        "contracts": {
+          "created": true,
+          "path": ".morph/project/outputs/scheduled-reports/contracts.cs"
+        },
+        "ui-spec": {
+          "created": true,
+          "path": ".morph/project/outputs/scheduled-reports/ui-spec.md"
+        },
+        "tasks": {
+          "created": true,
+          "note": "Tasks are now inline in state.json (schema 3.0.0)"
+        },
+        "decisions": {
+          "created": true,
+          "path": ".morph/project/outputs/scheduled-reports/decisions.md"
+        }
+      },
+      "costs": {
+        "estimated": 5.50,
+        "approved": true,
+        "breakdown": {
+          "hangfire": 0,
+          "storage": 0.02,
+          "sql": 4.99,
+          "containerApp": 0.49
+        }
+      }
+    }
+  },
+  "metadata": {
+    "totalFeatures": 1,
+    "completedFeatures": 0,
+    "totalCostEstimated": 5.50
+  }
+}

package/detectors/structure-detector.js

@@ -50,6 +50,7 @@ export async function detectStructure(projectPath) {
  * Detect stack type
  */
 async function detectStack(projectPath) {
+  // Order matters: more specific patterns first
   const patterns = {
     blazor: [
       '**/*.razor',
@@ -57,19 +58,47 @@ async function detectStack(projectPath) {
       '**/Components/**/*.razor'
     ],
     nextjs: [
-      'pages/**/*.tsx',
-      'app/**/*.tsx',
       'next.config.js',
-      'next.config.mjs'
+      'next.config.mjs',
+      'next.config.ts',
+      'pages/**/*.tsx',
+      'app/**/*.tsx'
     ],
     shopify: [
       '**/*.liquid',
       'sections/**/*.liquid',
       'templates/**/*.liquid'
     ],
+    react: [
+      'src/App.jsx',
+      'src/App.tsx',
+      'vite.config.js',
+      'craco.config.js'
+    ],
+    vue: [
+      'vite.config.js', // Vue 3 + Vite
+      'vue.config.js',  // Vue 2
+      'src/App.vue'
+    ],
     dotnet: [
       '**/*.csproj',
       '**/Program.cs'
+    ],
+    typescript: [
+      'tsconfig.json',
+      'src/**/*.ts'
+    ],
+    nodejs: [
+      'package.json'  // Fallback: generic Node.js
+    ],
+    python: [
+      'requirements.txt',
+      'pyproject.toml',
+      'setup.py'
+    ],
+    go: [
+      'go.mod',
+      'main.go'
     ]
   };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polymorphism-tech/morph-spec",
-  "version": "2.1.2",
+  "version": "2.3.0",
   "description": "MORPH-SPEC v2.0: AI-First development framework with .NET 10, Microsoft Agent Framework, and Fluent UI Blazor",
   "keywords": [
     "claude-code",