@polymorphism-tech/morph-spec 3.0.0 → 3.1.0

package/docs/getting-started.md

@@ -15,9 +15,9 @@
 git clone https://github.com/polymorphism-tech/morph-framework.git
 
 # Copie o conteúdo para seu projeto
-cp -r morph-framework/content/.morph /seu/projeto/
-cp -r morph-framework/content/.claude /seu/projeto/
-cp morph-framework/content/CLAUDE.md /seu/projeto/
+cp -r morph-framework/stacks/blazor-azure/.morph /seu/projeto/
+cp -r morph-framework/stacks/blazor-azure/.claude /seu/projeto/
+cp morph-framework/stacks/blazor-azure/CLAUDE.md /seu/projeto/
 ```
 
 ### 2. Configurar

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@polymorphism-tech/morph-spec",
-  "version": "3.0.0",
-  "description": "MORPH-SPEC v2.0: AI-First development framework with .NET 10, Microsoft Agent Framework, and Fluent UI Blazor",
+  "version": "3.1.0",
+  "description": "MORPH-SPEC v3: AI-First development framework with validation pipeline, .NET 10, Microsoft Agent Framework, and Fluent UI Blazor",
   "keywords": [
     "claude-code",
     "claude",
@@ -27,8 +27,7 @@
     "bin/",
     "src/",
     "scripts/",
-    "detectors/",
-    "content/",
+    "stacks/",
     "docs/",
     "README.md",
     "LICENSE",

package/scripts/reorganize-skills.cjs

@@ -0,0 +1,175 @@
+const fs = require('fs');
+const path = require('path');
+
+// Define new 5-level structure with mapping
+const skillMapping = {
+  // Level 0: Meta-Skills (user-facing, high-level orchestration)
+  'level-0-meta': [
+    'checklists/morph-checklist.md',
+    'checklists/simulation-checklist.md',
+    'checklists/code-review.md'
+  ],
+
+  // Level 1: Workflows (phase orchestration)
+  'level-1-workflows': [
+    'workflows/phase-setup.md',
+    'workflows/phase-uiux.md',
+    'workflows/phase-design.md',
+    'workflows/phase-clarify.md',
+    'workflows/phase-tasks.md',
+    'workflows/morph-replicate.md'
+  ],
+
+  // Level 2: Domains (domain expertise - maps to squads)
+  'level-2-domains/backend': [
+    'specialists/dotnet-senior.md',
+    'specialists/ef-modeler.md',
+    'specialists/hangfire-orchestrator.md',
+    'specialists/ms-agent-expert.md'
+  ],
+  'level-2-domains/frontend': [
+    'specialists/ui-ux-designer.md',
+    'stacks/dotnet-blazor.md',
+    'stacks/dotnet-nextjs.md'
+  ],
+  'level-2-domains/infrastructure': [
+    'specialists/azure-architect.md',
+    'infra/bicep-architect.md',
+    'infra/devops-engineer.md',
+    'infra/container-specialist.md'
+  ],
+  'level-2-domains/quality': [
+    'specialists/testing-specialist.md',
+    'specialists/code-analyzer.md'
+  ],
+  'level-2-domains/ai-agents': [
+    'specialists/ai-system-architect.md'
+  ],
+  'level-2-domains/integrations': [
+    'integrations/asaas-financial.md',
+    'integrations/clerk-auth.md',
+    'integrations/azure-identity.md',
+    'integrations/resend-email.md'
+  ],
+  'level-2-domains/architecture': [
+    'specialists/standards-architect.md',
+    'specialists/po-pm-advisor.md'
+  ],
+
+  // Level 3: Technologies (empty for now, will populate in Phase 8/9)
+  'level-3-technologies': [],
+
+  // Level 4: Patterns (empty for now, will populate later)
+  'level-4-patterns': []
+};
+
+const baseDir = 'stacks/blazor-azure/.claude/skills';
+
+// Create new directory structure
+console.log('📁 Creating new 5-level directory structure...\n');
+Object.keys(skillMapping).forEach(dir => {
+  const fullPath = path.join(baseDir, dir);
+  if (!fs.existsSync(fullPath)) {
+    fs.mkdirSync(fullPath, { recursive: true });
+    console.log(`  ✅ Created: ${dir}`);
+  }
+});
+
+console.log('\n📦 Moving skill files...\n');
+
+// Move files to new structure
+let movedCount = 0;
+Object.entries(skillMapping).forEach(([targetDir, files]) => {
+  files.forEach(relPath => {
+    const oldPath = path.join(baseDir, relPath);
+    const fileName = path.basename(relPath);
+    const newPath = path.join(baseDir, targetDir, fileName);
+
+    if (fs.existsSync(oldPath)) {
+      fs.copyFileSync(oldPath, newPath);
+      movedCount++;
+      console.log(`  ✅ Moved: ${relPath} → ${targetDir}/${fileName}`);
+    } else {
+      console.log(`  ⚠️  Not found: ${relPath}`);
+    }
+  });
+});
+
+console.log(`\n✅ Moved ${movedCount} skill files to new structure`);
+
+// Create README files for each level
+const readmes = {
+  'level-0-meta/README.md': `# Level 0: Meta-Skills
+
+High-level orchestration skills and user-facing commands.
+
+**Purpose:** Skills that orchestrate multiple workflows or provide top-level guidance.
+
+**Examples:** morph-checklist, simulation-checklist, code-review
+`,
+
+  'level-1-workflows/README.md': `# Level 1: Workflows
+
+Phase orchestration and workflow management.
+
+**Purpose:** Skills that implement MORPH workflow phases (FASE 0-6).
+
+**Examples:** phase-setup, phase-design, phase-uiux
+`,
+
+  'level-2-domains/README.md': `# Level 2: Domains
+
+Domain expertise skills organized by squad.
+
+**Purpose:** Skills that provide deep domain knowledge (backend, frontend, infra, quality, ai-agents, integrations).
+
+**Squads:**
+- backend/ - Backend Squad (led by dotnet-senior)
+- frontend/ - Frontend Squad (led by ui-designer)
+- infrastructure/ - Infrastructure Squad (led by azure-architect)
+- quality/ - Quality Squad (coordinated by standards-architect)
+- ai-agents/ - AI/Agent specialists
+- integrations/ - External integration specialists
+- architecture/ - Architecture and planning
+`,
+
+  'level-3-technologies/README.md': `# Level 3: Technologies
+
+Technology-specific implementation patterns.
+
+**Purpose:** Skills for specific technologies (EF Core, Blazor, Hangfire, SignalR, etc.).
+
+**To be populated in Phase 8/9.**
+`,
+
+  'level-4-patterns/README.md': `# Level 4: Patterns
+
+Architectural and design patterns.
+
+**Purpose:** Skills for specific patterns (CQRS, Event Sourcing, DDD, Repository, etc.).
+
+**To be populated later.**
+`
+};
+
+console.log('\n📝 Creating README files...\n');
+Object.entries(readmes).forEach(([file, content]) => {
+  const fullPath = path.join(baseDir, file);
+  fs.writeFileSync(fullPath, content, 'utf8');
+  console.log(`  ✅ Created: ${file}`);
+});
+
+console.log('\n✅ Phase 0, Day 2: Skill reorganization COMPLETE');
+console.log('\nNew structure:');
+console.log('  level-0-meta/          (3 files)');
+console.log('  level-1-workflows/     (6 files)');
+console.log('  level-2-domains/       (7 subdirs, 20 files)');
+console.log('    ├── backend/         (4 files)');
+console.log('    ├── frontend/        (3 files)');
+console.log('    ├── infrastructure/  (4 files)');
+console.log('    ├── quality/         (2 files)');
+console.log('    ├── ai-agents/       (1 file)');
+console.log('    ├── integrations/    (4 files)');
+console.log('    └── architecture/    (2 files)');
+console.log('  level-3-technologies/  (empty - Phase 8/9)');
+console.log('  level-4-patterns/      (empty - later)');

package/scripts/validate-agents-structure.cjs

@@ -0,0 +1,52 @@
+const fs = require('fs');
+
+const agents = JSON.parse(fs.readFileSync('stacks/blazor-azure/.morph/config/agents.json', 'utf8'));
+
+console.log('✅ Version:', agents.version);
+console.log('✅ Total agents:', Object.keys(agents.agents || {}).length);
+console.log('✅ Tiers breakdown:', JSON.stringify(agents.tiers, null, 2));
+
+// Validate each agent has required fields
+const requiredFields = ['tier', 'role', 'title', 'domains', 'keywords', 'always_active', 'validators', 'relationships', 'standards'];
+const missing = [];
+
+Object.entries(agents.agents || {}).forEach(([id, agent]) => {
+  if (id.startsWith('_comment')) return; // Skip comment entries
+
+  const agentMissing = requiredFields.filter(field => !(field in agent));
+  if (agentMissing.length > 0) {
+    missing.push({ id, missing: agentMissing });
+  }
+
+  // Validate relationships object
+  if (agent.relationships) {
+    const reqRelFields = ['reports_to', 'team_role'];
+    const relMissing = reqRelFields.filter(field => !(field in agent.relationships));
+    if (relMissing.length > 0) {
+      missing.push({ id, missing: relMissing.map(f => `relationships.${f}`) });
+    }
+  }
+});
+
+if (missing.length === 0) {
+  console.log('✅ All agents have required fields');
+} else {
+  console.log('❌ Agents with missing fields:', missing.length);
+  missing.forEach(m => console.log(`  - ${m.id}: missing ${m.missing.join(', ')}`));
+}
+
+// Count agents by tier
+const tierCounts = { 1: 0, 2: 0, 3: 0, 4: 0 };
+Object.entries(agents.agents || {}).forEach(([id, agent]) => {
+  if (!id.startsWith('_comment') && agent.tier) {
+    tierCounts[agent.tier]++;
+  }
+});
+
+console.log('\n✅ Agents per tier:');
+console.log('  Tier 1 (Orchestrators):', tierCounts[1]);
+console.log('  Tier 2 (Domain Leaders):', tierCounts[2]);
+console.log('  Tier 3 (Specialists):', tierCounts[3]);
+console.log('  Tier 4 (Validators):', tierCounts[4]);
+
+console.log('\n✅ Phase 0, Day 1: COMPLETE - agents.json validated');

package/scripts/validate-skills.cjs

@@ -0,0 +1,180 @@
+const fs = require('fs');
+const path = require('path');
+
+const skillsBase = 'stacks/blazor-azure/.claude/skills';
+const agentsPath = 'stacks/blazor-azure/.morph/config/agents.json';
+
+console.log('🧪 Validating MORPH 3.0 Skills Structure\n');
+
+// Load agents.json
+const agentsConfig = JSON.parse(fs.readFileSync(agentsPath, 'utf8'));
+
+// Step 1: Verify 5-level directory structure
+console.log('📁 Step 1: Verify 5-level directory structure');
+const requiredDirs = [
+  'level-0-meta',
+  'level-1-workflows',
+  'level-2-domains',
+  'level-3-technologies',
+  'level-4-patterns'
+];
+
+const missingDirs = [];
+requiredDirs.forEach(dir => {
+  const fullPath = path.join(skillsBase, dir);
+  if (!fs.existsSync(fullPath)) {
+    missingDirs.push(dir);
+  } else {
+    console.log(`  ✅ ${dir}/`);
+  }
+});
+
+if (missingDirs.length > 0) {
+  console.log(`  ❌ Missing directories: ${missingDirs.join(', ')}`);
+}
+console.log('');
+
+// Step 2: Check level-2-domains subdirectories
+console.log('📂 Step 2: Verify level-2-domains squads');
+const requiredSquads = [
+  'backend', 'frontend', 'infrastructure', 'quality',
+  'ai-agents', 'integrations', 'architecture'
+];
+
+const level2Path = path.join(skillsBase, 'level-2-domains');
+const existingSquads = fs.readdirSync(level2Path)
+  .filter(item => {
+    const itemPath = path.join(level2Path, item);
+    return fs.statSync(itemPath).isDirectory();
+  });
+
+requiredSquads.forEach(squad => {
+  if (existingSquads.includes(squad)) {
+    const squadPath = path.join(level2Path, squad);
+    const skillCount = fs.readdirSync(squadPath).filter(f => f.endsWith('.md')).length;
+    console.log(`  ✅ ${squad}/ (${skillCount} skills)`);
+  } else {
+    console.log(`  ❌ Missing: ${squad}/`);
+  }
+});
+console.log('');
+
+// Step 3: Count all skill files
+console.log('📄 Step 3: Count skill files');
+function countSkills(dir) {
+  let count = 0;
+  const items = fs.readdirSync(dir);
+  items.forEach(item => {
+    const fullPath = path.join(dir, item);
+    const stat = fs.statSync(fullPath);
+    if (stat.isDirectory()) {
+      count += countSkills(fullPath);
+    } else if (item.endsWith('.md') && item !== 'README.md') {
+      count++;
+    }
+  });
+  return count;
+}
+
+const totalSkills = countSkills(skillsBase);
+console.log(`  ✅ Total skill files: ${totalSkills}`);
+console.log('');
+
+// Step 4: Verify no old directories remain
+console.log('🗑️  Step 4: Verify old directories removed');
+const oldDirs = ['specialists', 'stacks', 'integrations', 'infra', 'workflows', 'checklists'];
+const remainingOldDirs = oldDirs.filter(dir => {
+  return fs.existsSync(path.join(skillsBase, dir));
+});
+
+if (remainingOldDirs.length > 0) {
+  console.log(`  ❌ Old directories still exist: ${remainingOldDirs.join(', ')}`);
+} else {
+  console.log('  ✅ All old directories removed');
+}
+console.log('');
+
+// Step 5: Verify agents → skills mapping (sample of key agents)
+console.log('🎯 Step 5: Verify key agents have skills');
+const agentSkillMap = {
+  'dotnet-senior': 'level-2-domains/backend/dotnet-senior.md',
+  'ef-modeler': 'level-2-domains/backend/ef-modeler.md',
+  'hangfire-orchestrator': 'level-2-domains/backend/hangfire-orchestrator.md',
+  'ms-agent-expert': 'level-2-domains/backend/ms-agent-expert.md',
+  'blazor-builder': 'level-2-domains/frontend/blazor-builder.md',
+  'nextjs-expert': 'level-2-domains/frontend/nextjs-expert.md',
+  'ui-ux-designer': 'level-2-domains/frontend/ui-ux-designer.md',
+  'azure-architect': 'level-2-domains/infrastructure/azure-architect.md',
+  'bicep-architect': 'level-2-domains/infrastructure/bicep-architect.md',
+  'devops-engineer': 'level-2-domains/infrastructure/devops-engineer.md',
+  'container-specialist': 'level-2-domains/infrastructure/container-specialist.md',
+  'testing-specialist': 'level-2-domains/quality/testing-specialist.md',
+  'code-analyzer': 'level-2-domains/quality/code-analyzer.md',
+  'standards-architect': 'level-2-domains/architecture/standards-architect.md',
+  'po-pm-advisor': 'level-2-domains/architecture/po-pm-advisor.md',
+  'ai-system-architect': 'level-2-domains/ai-agents/ai-system-architect.md',
+  'asaas-financial': 'level-2-domains/integrations/asaas-financial.md',
+  'clerk-auth': 'level-2-domains/integrations/clerk-auth.md',
+  'azure-identity': 'level-2-domains/integrations/azure-identity.md',
+  'resend-email': 'level-2-domains/integrations/resend-email.md'
+};
+
+let missingSkills = 0;
+Object.entries(agentSkillMap).forEach(([agentId, skillPath]) => {
+  const fullPath = path.join(skillsBase, skillPath);
+  if (fs.existsSync(fullPath)) {
+    console.log(`  ✅ ${agentId} → ${skillPath}`);
+  } else {
+    console.log(`  ❌ ${agentId} → ${skillPath} (NOT FOUND)`);
+    missingSkills++;
+  }
+});
+console.log('');
+
+// Step 6: Check skill file quality (headers, structure)
+console.log('📋 Step 6: Check skill file structure');
+let malformedSkills = 0;
+Object.entries(agentSkillMap).forEach(([agentId, skillPath]) => {
+  const fullPath = path.join(skillsBase, skillPath);
+  if (fs.existsSync(fullPath)) {
+    const content = fs.readFileSync(fullPath, 'utf8');
+    const lines = content.split('\n');
+
+    // Check has markdown header (# Title)
+    if (!lines[0].startsWith('#')) {
+      console.log(`  ⚠️  ${agentId}: Missing markdown header`);
+      malformedSkills++;
+    }
+  }
+});
+
+if (malformedSkills === 0) {
+  console.log('  ✅ All skills have proper structure');
+} else {
+  console.log(`  ⚠️  ${malformedSkills} skills have structure issues`);
+}
+console.log('');
+
+// Final summary
+console.log('='.repeat(60));
+console.log('📊 VALIDATION SUMMARY');
+console.log('='.repeat(60));
+console.log(`✅ 5-level structure: ${missingDirs.length === 0 ? 'PASS' : 'FAIL'}`);
+console.log(`✅ Squad directories: ${requiredSquads.every(s => existingSquads.includes(s)) ? 'PASS' : 'FAIL'}`);
+console.log(`✅ Total skills: ${totalSkills} files`);
+console.log(`✅ Old dirs removed: ${remainingOldDirs.length === 0 ? 'PASS' : 'FAIL'}`);
+console.log(`✅ Agent→skill map: ${missingSkills === 0 ? 'PASS' : 'FAIL'}`);
+console.log(`✅ Skill structure: ${malformedSkills === 0 ? 'PASS' : 'WARN'}`);
+
+const allPassed = missingDirs.length === 0 &&
+                  requiredSquads.every(s => existingSquads.includes(s)) &&
+                  remainingOldDirs.length === 0 &&
+                  missingSkills === 0;
+
+if (allPassed) {
+  console.log('\n🎉 ALL CHECKS PASSED - Skills structure is valid!');
+  process.exit(0);
+} else {
+  console.log('\n⚠️  SOME CHECKS FAILED - Review issues above');
+  process.exit(1);
+}