@polymorphism-tech/morph-spec 4.12.0 → 4.14.0

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

@@ -182,14 +182,14 @@ function buildRecapMarkdown(data) {
   // Suggested Quality Verification
   const agents = agentsSummary;
   const hasNextjs = agents.some(a => ['nextjs-expert', 'css-specialist', 'ui-designer'].includes(a));
-  const hasBlazor = agents.some(a => ['blazor-builder', 'blazor-specialist', 'dotnet-senior'].includes(a));
-  if (hasNextjs || hasBlazor) {
+  const hasDotnet = agents.some(a => ['dotnet-senior', 'ef-modeler'].includes(a));
+  if (hasNextjs || hasDotnet) {
     md += `## Suggested Quality Verification\n\n`;
     if (hasNextjs) {
       md += `**Next.js / TypeScript:**\n\`\`\`bash\nnpx tsc --noEmit\nnpx eslint . --max-warnings 0\n\`\`\`\n\n`;
     }
-    if (hasBlazor) {
-      md += `**Blazor / .NET:**\n\`\`\`bash\ndotnet build\ndotnet test\n\`\`\`\n\n`;
+    if (hasDotnet) {
+      md += `**.NET:**\n\`\`\`bash\ndotnet build\ndotnet test\n\`\`\`\n\n`;
     }
   }
 

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

@@ -0,0 +1,317 @@
+/**
+ * Scaffold Generator - Generates VSA feature slice (.NET) and feature page (Next.js) files.
+ *
+ * Uses existing Handlebars templates from framework/templates/ to generate
+ * complete feature structures with one command.
+ *
+ * @module scaffold-generator
+ */
+
+import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync } from 'fs';
+import { join, dirname, basename } from 'path';
+import { fileURLToPath } from 'url';
+import { renderTemplate } from '../../core/templates/template-renderer.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+/** Framework templates root (relative to this file) */
+const FRAMEWORK_TEMPLATES_DIR = join(__dirname, '../../../framework/templates');
+
+/**
+ * Convert kebab-case to PascalCase.
+ * @param {string} str
+ * @returns {string}
+ */
+function toPascalCase(str) {
+  return str
+    .split('-')
+    .map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+    .join('');
+}
+
+/**
+ * Convert kebab-case to camelCase.
+ * @param {string} str
+ * @returns {string}
+ */
+function toCamelCase(str) {
+  return str
+    .split('-')
+    .map((word, i) => i === 0 ? word.toLowerCase() : word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+    .join('');
+}
+
+/**
+ * Normalize a namespace to kebab-case so Handlebars {{pascalCase}} reconstructs it correctly.
+ * Handles: PascalCase ("MyBookStore" → "my-book-store"), dot-separated ("My.App" → "my-app"),
+ * and already kebab-case pass-through.
+ * @param {string} ns
+ * @returns {string}
+ */
+export function normalizeNamespaceToKebab(ns) {
+  // Split on dots first (My.BookStore → ["My", "BookStore"])
+  // Then split PascalCase on uppercase boundaries (BookStore → Book-Store)
+  return ns
+    .split('.')
+    .map(segment =>
+      segment
+        .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
+        .replace(/([A-Z]+)([A-Z][a-z])/g, '$1-$2')
+        .toLowerCase()
+    )
+    .join('-');
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// .NET VSA Scaffold
+// ─────────────────────────────────────────────────────────────────────────────
+
+/** Template IDs for .NET slice-level files */
+const DOTNET_SLICE_TEMPLATES = [
+  { id: 'endpoint', file: 'endpoint.cs.hbs', suffix: 'Endpoint' },
+  { id: 'handler', file: 'handler.cs.hbs', suffix: 'Handler' },
+  { id: 'request', file: 'request.cs.hbs', suffix: 'Request' },
+  { id: 'response', file: 'response.cs.hbs', suffix: 'Response' },
+  { id: 'validator', file: 'validator.cs.hbs', suffix: 'Validator' },
+];
+
+/** Template IDs for .NET feature-level files */
+const DOTNET_FEATURE_TEMPLATES = [
+  { id: 'entity', file: 'entity.cs.hbs', suffix: '', dir: 'entities' },
+  { id: 'errors', file: 'errors.cs.hbs', suffix: 'Errors', dir: 'feature' },
+];
+
+/**
+ * Scaffold a .NET VSA feature slice.
+ *
+ * @param {Object} options
+ * @param {string} options.feature - Entity/feature name in kebab-case (e.g., "book")
+ * @param {string} options.sliceName - Slice name in kebab-case (e.g., "create-book")
+ * @param {string} options.namespace - Root namespace (e.g., "MyApp")
+ * @param {string} [options.outputDir] - Base output directory (default: cwd)
+ * @param {boolean} [options.dryRun] - Preview without writing
+ * @returns {{ files: Array<{path: string, content: string, skipped: boolean}> }}
+ */
+export function scaffoldDotnetSlice(options) {
+  const { feature, sliceName, namespace, outputDir = process.cwd(), dryRun = false } = options;
+
+  const pascalFeature = toPascalCase(feature);
+  const pascalSlice = toPascalCase(sliceName);
+  const templateDir = join(FRAMEWORK_TEMPLATES_DIR, 'code/dotnet/feature');
+
+  const variables = {
+    PROJECT_NAME: normalizeNamespaceToKebab(namespace),
+    FEATURE_NAME: feature,
+    SLICE_NAME: sliceName,
+    DATE: new Date().toISOString().split('T')[0],
+    YEAR: new Date().getFullYear().toString(),
+  };
+
+  const files = [];
+
+  // 1. Render slice-level templates
+  for (const tmpl of DOTNET_SLICE_TEMPLATES) {
+    const templatePath = join(templateDir, tmpl.file);
+    const outputPath = join(
+      outputDir,
+      'Features',
+      `${pascalFeature}Feature`,
+      pascalSlice,
+      `${pascalSlice}${tmpl.suffix}.cs`
+    );
+
+    const content = renderTemplate(templatePath, variables);
+
+    if (!dryRun) {
+      mkdirSync(dirname(outputPath), { recursive: true });
+      writeFileSync(outputPath, content, 'utf-8');
+    }
+
+    files.push({ path: outputPath, content, skipped: false });
+  }
+
+  // 2. Render feature-level templates (skip if already exist)
+  for (const tmpl of DOTNET_FEATURE_TEMPLATES) {
+    const templatePath = join(templateDir, tmpl.file);
+    let outputPath;
+
+    if (tmpl.dir === 'entities') {
+      outputPath = join(outputDir, 'Entities', `${pascalFeature}${tmpl.suffix}.cs`);
+    } else {
+      outputPath = join(outputDir, 'Features', `${pascalFeature}Feature`, `${pascalFeature}${tmpl.suffix}.cs`);
+    }
+
+    if (existsSync(outputPath)) {
+      files.push({ path: outputPath, content: '', skipped: true });
+      continue;
+    }
+
+    const content = renderTemplate(templatePath, variables);
+
+    if (!dryRun) {
+      mkdirSync(dirname(outputPath), { recursive: true });
+      writeFileSync(outputPath, content, 'utf-8');
+    }
+
+    files.push({ path: outputPath, content, skipped: false });
+  }
+
+  return { files };
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Next.js Scaffold
+// ─────────────────────────────────────────────────────────────────────────────
+
+/** Template mappings for Next.js feature */
+const NEXTJS_TEMPLATES = [
+  {
+    file: 'page.tsx.hbs',
+    outputFn: (kebab) => join('app', '(dashboard)', kebab, 'page.tsx'),
+  },
+  {
+    file: 'client-component.tsx.hbs',
+    outputFn: (kebab) => join('features', kebab, 'components', `${kebab}-list.tsx`),
+  },
+  {
+    file: 'feature-form.tsx.hbs',
+    outputFn: (kebab) => join('features', kebab, 'components', `create-${kebab}-form.tsx`),
+  },
+  {
+    file: 'use-feature.ts.hbs',
+    outputFn: (kebab) => join('features', kebab, 'hooks', `use-${kebab}s.ts`),
+  },
+];
+
+/**
+ * Scaffold a Next.js feature page with components and hooks.
+ *
+ * @param {Object} options
+ * @param {string} options.featureName - Feature name in kebab-case (e.g., "book")
+ * @param {string} [options.outputDir] - Base output directory (default: cwd)
+ * @param {boolean} [options.dryRun] - Preview without writing
+ * @returns {{ files: Array<{path: string, content: string, skipped: boolean}> }}
+ */
+export function scaffoldNextjsFeature(options) {
+  const { featureName, outputDir = process.cwd(), dryRun = false } = options;
+
+  const kebab = featureName.toLowerCase();
+  const templateDir = join(FRAMEWORK_TEMPLATES_DIR, 'frontend/nextjs');
+
+  // Next.js templates use camelCase variable name `featureName`
+  const variables = {
+    featureName: featureName,
+  };
+
+  const files = [];
+
+  for (const tmpl of NEXTJS_TEMPLATES) {
+    const templatePath = join(templateDir, tmpl.file);
+    const relativePath = tmpl.outputFn(kebab);
+    const outputPath = join(outputDir, relativePath);
+
+    if (existsSync(outputPath)) {
+      files.push({ path: outputPath, content: '', skipped: true });
+      continue;
+    }
+
+    const content = renderTemplate(templatePath, variables);
+
+    if (!dryRun) {
+      mkdirSync(dirname(outputPath), { recursive: true });
+      writeFileSync(outputPath, content, 'utf-8');
+    }
+
+    files.push({ path: outputPath, content, skipped: false });
+  }
+
+  return { files };
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Namespace Detection
+// ─────────────────────────────────────────────────────────────────────────────
+
+/**
+ * Detect the .NET root namespace from .csproj or config.json.
+ *
+ * Search order:
+ * 1. *.csproj in dir (extract <RootNamespace>)
+ * 2. *.csproj in dir (use filename without extension)
+ * 3. *.csproj one level deep
+ * 4. .morph/config.json → project.name
+ *
+ * @param {string} dir - Directory to search in
+ * @returns {string|null} Detected namespace or null
+ */
+export function detectNamespace(dir) {
+  // 1. Search for .csproj in current dir
+  const csprojInDir = findCsproj(dir);
+  if (csprojInDir) {
+    const ns = extractNamespaceFromCsproj(csprojInDir);
+    if (ns) return ns;
+    // Fallback: use filename
+    return basename(csprojInDir, '.csproj');
+  }
+
+  // 2. Search one level deep
+  try {
+    const entries = readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        const subCsproj = findCsproj(join(dir, entry.name));
+        if (subCsproj) {
+          const ns = extractNamespaceFromCsproj(subCsproj);
+          if (ns) return ns;
+          return basename(subCsproj, '.csproj');
+        }
+      }
+    }
+  } catch {
+    // ignore read errors
+  }
+
+  // 3. Fall back to config.json
+  const configPath = join(dir, '.morph', 'config.json');
+  if (existsSync(configPath)) {
+    try {
+      const config = JSON.parse(readFileSync(configPath, 'utf-8'));
+      if (config.project?.name) return config.project.name;
+    } catch {
+      // ignore parse errors
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Find the first .csproj file in a directory.
+ * @param {string} dir
+ * @returns {string|null}
+ */
+function findCsproj(dir) {
+  try {
+    const entries = readdirSync(dir);
+    const csproj = entries.find(f => f.endsWith('.csproj'));
+    return csproj ? join(dir, csproj) : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Extract <RootNamespace> from a .csproj file.
+ * @param {string} csprojPath
+ * @returns {string|null}
+ */
+function extractNamespaceFromCsproj(csprojPath) {
+  try {
+    const content = readFileSync(csprojPath, 'utf-8');
+    const match = content.match(/<RootNamespace>([^<]+)<\/RootNamespace>/);
+    return match ? match[1] : null;
+  } catch {
+    return null;
+  }
+}

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

@@ -80,7 +80,6 @@ export function buildPermissions(stack, detectedConfig = {}) {
     react: ['Bash(node:*)', 'Bash(npm:*)', 'Bash(npx:*)'],
     vue: ['Bash(node:*)', 'Bash(npm:*)', 'Bash(npx:*)'],
     dotnet: ['Bash(dotnet:*)', 'Bash(nuget:*)'],
-    blazor: ['Bash(dotnet:*)', 'Bash(nuget:*)'],
     python: ['Bash(python:*)', 'Bash(pip:*)', 'Bash(pytest:*)'],
     go: ['Bash(go:*)']
   };

package/src/lib/phase-chain/phase-validator.js

@@ -26,53 +26,41 @@ export const PHASES = {
     requiredOutputs: [],
     description: 'Initial proposal and agent detection'
   },
-  'setup': {
-    order: 1,
-    name: 'FASE 1: SETUP',
-    requiredOutputs: ['proposal.md'],
-    description: 'Load context and standards'
-  },
   'uiux': {
-    order: 2,
-    name: 'FASE 1.5: UI/UX DESIGN',
+    order: 1,
+    name: 'FASE 1: UI/UX DESIGN',
     requiredOutputs: ['proposal.md'],
-    optionalOutputs: ['ui-design-system.md', 'ui-mockups.md', 'ui-components.md', 'ui-flows.md'],
+    optionalOutputs: ['design-system.md', 'mockups.md', 'components.md', 'flows.md'],
     description: 'UI/UX design (conditional - only if frontend)',
     optional: true
   },
   'design': {
-    order: 3,
+    order: 2,
     name: 'FASE 2: DESIGN',
     requiredOutputs: ['proposal.md'],
-    description: 'Technical specification and contracts'
-  },
-  'clarify': {
-    order: 4,
-    name: 'FASE 3: CLARIFY',
-    requiredOutputs: ['proposal.md', 'spec.md'],
-    description: 'Clarify ambiguities and edge cases'
+    description: 'Technical specification, contracts, and clarification'
   },
   'plan': {
-    order: 5,
-    name: 'FASE 4: PLAN',
+    order: 3,
+    name: 'FASE 3: PLAN',
     requiredOutputs: ['proposal.md', 'spec.md'],
     description: 'Planning phase before task breakdown'
   },
   'tasks': {
-    order: 6,
-    name: 'FASE 5: TASKS',
+    order: 4,
+    name: 'FASE 4: TASKS',
     requiredOutputs: ['proposal.md', 'spec.md', 'plan.md'],
     description: 'Break down into executable tasks'
   },
   'implement': {
-    order: 7,
-    name: 'FASE 6: IMPLEMENT',
+    order: 5,
+    name: 'FASE 5: IMPLEMENT',
     requiredOutputs: ['proposal.md', 'spec.md', 'tasks.md'],
     description: 'Execute tasks and implement code'
   },
   'sync': {
-    order: 8,
-    name: 'FASE 7: SYNC',
+    order: 6,
+    name: 'FASE 6: SYNC',
     requiredOutputs: ['proposal.md', 'spec.md', 'decisions.md', 'recap.md'],
     description: 'Sync decisions to project standards',
     optional: true
@@ -82,15 +70,14 @@ export const PHASES = {
 // Map output filenames to their phase subfolders
 const OUTPUT_PHASE_MAP = {
   'proposal.md': '0-proposal',
-  'schema-analysis.md': '1-design',
-  'spec.md': '1-design',
-  'clarifications.md': '1-design',
-  'contracts.cs': '1-design',
-  'decisions.md': '1-design',
-  'ui-design-system.md': '2-ui',
-  'ui-mockups.md': '2-ui',
-  'ui-components.md': '2-ui',
-  'ui-flows.md': '2-ui',
+  'schema-analysis.md': '2-design',
+  'spec.md': '2-design',
+  'contracts.cs': '2-design',
+  'decisions.md': '2-design',
+  'design-system.md': '1-ui',
+  'mockups.md': '1-ui',
+  'components.md': '1-ui',
+  'flows.md': '1-ui',
   'plan.md': '3-plan',
   'tasks.md': '4-tasks',
   'recap.md': '5-implement'
@@ -135,8 +122,24 @@ export function validatePhase(featureName, targetPhase) {
     };
   }
 
+  // Workflow-aware: only require outputs that the workflow declares as required.
+  // Fast-track skips design/plan, so spec.md and plan.md won't exist.
+  let requiredOutputs = phaseDefinition.requiredOutputs;
+  try {
+    const feature = getFeature(featureName);
+    if (feature?.workflow && feature.workflow !== 'auto') {
+      const wfConfig = getWorkflowConfig(feature.workflow);
+      if (wfConfig?.outputs?.required) {
+        const workflowRequired = new Set(wfConfig.outputs.required);
+        requiredOutputs = requiredOutputs.filter(o => workflowRequired.has(o));
+      }
+    }
+  } catch {
+    // Fall through to default requiredOutputs
+  }
+
   const missingOutputs = [];
-  for (const output of phaseDefinition.requiredOutputs) {
+  for (const output of requiredOutputs) {
     if (!checkOutput(featurePath, output)) {
       missingOutputs.push(output);
     }
@@ -183,12 +186,31 @@ export function validatePhase(featureName, targetPhase) {
 // Phase eligibility
 // ─────────────────────────────────────────────────────────────────────────────
 
-const PHASE_ORDER = ['proposal', 'setup', 'uiux', 'design', 'clarify', 'plan', 'tasks', 'implement', 'sync'];
+const PHASE_ORDER = ['proposal', 'uiux', 'design', 'plan', 'tasks', 'implement', 'sync'];
 
-function getNextPhase(currentPhase) {
+function getNextPhase(currentPhase, featureName) {
   const idx = PHASE_ORDER.indexOf(currentPhase);
   if (idx === -1 || idx >= PHASE_ORDER.length - 1) return null;
-  return PHASE_ORDER[idx + 1];
+
+  // Workflow-aware: skip phases not in the workflow's run list
+  let workflowConfig = null;
+  if (featureName) {
+    try {
+      const feature = getFeature(featureName);
+      if (feature?.workflow && feature.workflow !== 'auto') {
+        workflowConfig = getWorkflowConfig(feature.workflow);
+      }
+    } catch { /* fall through */ }
+  }
+
+  for (let i = idx + 1; i < PHASE_ORDER.length; i++) {
+    const candidate = PHASE_ORDER[i];
+    if (workflowConfig?.phases?.run && !workflowConfig.phases.run.includes(candidate)) {
+      continue;
+    }
+    return candidate;
+  }
+  return null;
 }
 
 /**
@@ -205,10 +227,10 @@ export function computePassRate(validationHistory) {
 // Map output type names to file paths for eligibility checks
 const OUTPUT_PATH_MAP = {
   'proposal': '0-proposal/proposal.md',
-  'spec': '1-design/spec.md',
-  'contracts': '1-design/contracts.cs',
+  'spec': '2-design/spec.md',
+  'contracts': '2-design/contracts.cs',
   'tasks': '4-tasks/tasks.md',
-  'schemaAnalysis': '1-design/schema-analysis.md',
+  'schemaAnalysis': '2-design/schema-analysis.md',
 };
 
 function getMissingRequiredOutputs(featureName, phase, projectPath) {
@@ -266,7 +288,7 @@ export function checkPhaseEligibility(featureName, opts = {}) {
 
   const featureFolderPath = join(projectPath, '.morph', 'features', featureName);
   const currentPhase = feature.phase || derivePhase(featureFolderPath);
-  const nextPhase = getNextPhase(currentPhase);
+  const nextPhase = getNextPhase(currentPhase, featureName);
 
   if (!nextPhase) {
     return {

package/src/lib/stack/stack-profile.js

@@ -1,7 +1,7 @@
 import { readFileSync, existsSync } from 'fs';
 import { join } from 'path';
 
-/** @typedef {'nextjs'|'blazor'|'dotnet'|'nodejs-cli'|'unknown'} StackName */
+/** @typedef {'nextjs'|'dotnet'|'nodejs-cli'|'unknown'} StackName */
 
 /**
  * @typedef {Object} StackProfile
@@ -15,7 +15,7 @@ import { join } from 'path';
  * @property {'csharp'|'typescript'} contractsLanguage
  */
 
-const DOTNET_STACKS = new Set(['dotnet', 'blazor', 'aspnet', 'dotnet-blazor']);
+const DOTNET_STACKS = new Set(['dotnet', 'aspnet']);
 const NEXTJS_STACKS = new Set(['nextjs', 'next', 'next.js']);
 const NO_VALIDATOR_STACKS = new Set(['nodejs-cli', 'node-cli', 'cli']);