@polymorphism-tech/morph-spec 4.3.0 → 4.3.1

package/src/lib/detectors/standards-generator.js

@@ -129,12 +129,15 @@ Based on detected patterns in your codebase:
   }
 
   if (config?.language === 'javascript') {
+    const techLine = config.technologies?.length > 0
+      ? `\n- **Framework**: ${config.technologies.join(', ')}`
+      : '';
+
     return `### JavaScript / TypeScript Conventions
 
 Based on detected patterns in your codebase:
 
-- **Package Manager**: ${config.packageManager}
-- **Framework**: ${config.technologies.join(', ')}
+- **Package Manager**: ${config.packageManager}${techLine}
 
 **Recommendation**: Refer to framework standards for JavaScript best practices.`;
   }
@@ -149,6 +152,37 @@ function generateArchitectureSection(structure) {
   const { architecture } = structure;
 
   const descriptions = {
+    'cli-library': `### CLI / Library Architecture
+
+Your project follows a CLI/Library pattern:
+
+- ✅ **bin/** entry points detected
+- ✅ **src/** source directory detected
+- ✅ **package.json** present
+
+**Key principles**:
+- Commands exposed via bin/
+- Core logic in src/commands/ and src/lib/
+- Public API exported from src/index.js`,
+
+    'nextjs-app-router': `### Next.js App Router Architecture
+
+Your project uses the Next.js App Router pattern:
+
+- ✅ **app/** directory detected (React Server Components)
+
+**Key principles**:
+- Server Components by default
+- Client Components with 'use client' directive
+- Route handlers in app/api/`,
+
+    'express-mvc': `### Express MVC Architecture
+
+Your project uses Express with MVC pattern:
+
+- ✅ **routes/** detected
+- ✅ **controllers/** detected`,
+
     'clean-architecture': `### Clean Architecture
 
 Your project follows Clean Architecture pattern:
@@ -203,19 +237,29 @@ function generateRecommendations(structure, config, conversation) {
     }
   }
 
-  // Recommend tests
-  if (!structure?.patterns?.includes('Unit Tests')) {
-    recommendations.push('No unit tests detected - consider adding test project');
-  }
+  if (structure?.stack === 'nodejs' || config?.language === 'javascript') {
+    if (!structure?.patterns?.includes('Unit Tests')) {
+      recommendations.push('No unit tests detected - consider adding test coverage with Jest or Vitest');
+    }
 
-  // Recommend DI
-  if (!structure?.patterns?.includes('Dependency Injection')) {
-    recommendations.push('Consider implementing Dependency Injection pattern');
-  }
+    if (structure?.architecture === 'unknown') {
+      recommendations.push('No clear architecture detected - consider organizing code into src/commands/, src/lib/, src/core/');
+    }
+  } else {
+    // Recommend tests (generic / .NET)
+    if (!structure?.patterns?.includes('Unit Tests')) {
+      recommendations.push('No unit tests detected - consider adding test project');
+    }
 
-  // Architecture recommendations
-  if (structure?.architecture === 'unknown' && structure?.folders?.hasServices) {
-    recommendations.push('Service layer detected but no clear architecture - consider Clean Architecture or CQRS');
+    // Recommend DI (only meaningful for C# / .NET)
+    if (config?.language === 'csharp' && !structure?.patterns?.includes('Dependency Injection')) {
+      recommendations.push('Consider implementing Dependency Injection pattern');
+    }
+
+    // Architecture recommendations (.NET)
+    if (structure?.architecture === 'unknown' && structure?.folders?.hasServices) {
+      recommendations.push('Service layer detected but no clear architecture - consider Clean Architecture or CQRS');
+    }
   }
 
   return recommendations;
@@ -250,14 +294,30 @@ function identifyGaps(structure, config) {
  */
 function filterImportantDependencies(deps) {
   const important = deps.filter(dep => {
-    // Framework packages
+    // .NET Framework packages
     if (dep.includes('Microsoft.') || dep.includes('System.')) return true;
-    // UI libraries
+    // Blazor UI libraries
     if (dep.includes('Blazor') || dep.includes('FluentUI') || dep.includes('Mud')) return true;
-    // Common tools
+    // .NET common tools
     if (dep.includes('Hangfire') || dep.includes('Serilog') || dep.includes('AutoMapper')) return true;
-    // AI/ML
+    // AI/ML (.NET)
     if (dep.includes('Agents') || dep.includes('AI') || dep.includes('OpenAI')) return true;
+    // JS: frontend frameworks
+    if (['next', 'react', 'react-dom', 'vue', 'nuxt', 'svelte', 'astro'].includes(dep)) return true;
+    // JS: backend frameworks
+    if (['express', 'fastify', 'hono', 'koa', 'nestjs', '@nestjs/core'].includes(dep)) return true;
+    // JS: databases / ORMs
+    if (['prisma', '@prisma/client', 'supabase', '@supabase/supabase-js', 'drizzle-orm', 'mongoose', 'typeorm'].includes(dep)) return true;
+    // JS: auth
+    if (['next-auth', 'clerk', '@clerk/nextjs', 'lucia', 'better-auth'].includes(dep)) return true;
+    // JS: validation / schema
+    if (['zod', 'yup', 'joi', 'valibot'].includes(dep)) return true;
+    // JS: testing
+    if (['vitest', 'jest', '@jest/core', 'mocha', 'cypress', 'playwright'].includes(dep)) return true;
+    // JS: UI / styling
+    if (['tailwindcss', '@mui/material', 'shadcn-ui', 'radix-ui', 'chakra-ui'].includes(dep)) return true;
+    // JS: AI
+    if (dep.includes('openai') || dep.includes('anthropic') || dep.includes('langchain') || dep.includes('ai')) return true;
     return false;
   });
 

package/src/lib/detectors/structure-detector.js

@@ -97,9 +97,11 @@ async function detectStack(projectPath) {
     ]
   };
 
+  const globIgnore = ['stacks/**', 'framework/**', 'test/**', 'node_modules/**', '.morph/**'];
+
   for (const [stack, globs] of Object.entries(patterns)) {
     for (const pattern of globs) {
-      const files = await glob(pattern, { cwd: projectPath, nodir: true });
+      const files = await glob(pattern, { cwd: projectPath, nodir: true, ignore: globIgnore });
       if (files.length > 0) {
         return stack;
       }
@@ -113,7 +115,10 @@ async function detectStack(projectPath) {
  * Detect architecture pattern
  */
 async function detectArchitecture(projectPath) {
+  const globIgnore = ['stacks/**', 'framework/**', 'test/**', 'node_modules/**', '.morph/**'];
+
   const checks = [
+    // .NET: Clean Architecture
     {
       pattern: 'clean-architecture',
       indicators: [
@@ -122,13 +127,15 @@ async function detectArchitecture(projectPath) {
         existsSync(join(projectPath, 'src', 'Infrastructure'))
       ]
     },
+    // .NET: CQRS
     {
       pattern: 'cqrs',
       indicators: [
-        await glob('**/Commands/**/*.cs', { cwd: projectPath }).then(f => f.length > 0),
-        await glob('**/Queries/**/*.cs', { cwd: projectPath }).then(f => f.length > 0)
+        await glob('**/Commands/**/*.cs', { cwd: projectPath, ignore: globIgnore }).then(f => f.length > 0),
+        await glob('**/Queries/**/*.cs', { cwd: projectPath, ignore: globIgnore }).then(f => f.length > 0)
       ]
     },
+    // .NET: MVC
     {
       pattern: 'mvc',
       indicators: [
@@ -136,6 +143,31 @@ async function detectArchitecture(projectPath) {
         existsSync(join(projectPath, 'Models')),
         existsSync(join(projectPath, 'Views'))
       ]
+    },
+    // JS: CLI / Library (bin + src + lib)
+    {
+      pattern: 'cli-library',
+      indicators: [
+        existsSync(join(projectPath, 'bin')),
+        existsSync(join(projectPath, 'src')),
+        existsSync(join(projectPath, 'package.json'))
+      ]
+    },
+    // JS: Next.js App Router
+    {
+      pattern: 'nextjs-app-router',
+      indicators: [
+        existsSync(join(projectPath, 'app')),
+        await glob('app/**/*.{js,ts,jsx,tsx}', { cwd: projectPath, ignore: globIgnore }).then(f => f.length > 0)
+      ]
+    },
+    // JS: Express MVC
+    {
+      pattern: 'express-mvc',
+      indicators: [
+        existsSync(join(projectPath, 'src', 'routes')) || existsSync(join(projectPath, 'routes')),
+        existsSync(join(projectPath, 'src', 'controllers')) || existsSync(join(projectPath, 'controllers'))
+      ]
     }
   ];
 
@@ -176,47 +208,43 @@ async function detectUILibrary(projectPath) {
  */
 async function detectPatterns(projectPath) {
   const patterns = [];
+  // Ignore template/vendor directories; keep test/ accessible for JS test detection
+  const globIgnore = ['stacks/**', 'framework/**', 'test/fixtures/**', 'node_modules/**', '.morph/**'];
 
-  // Check for specific patterns
-  const checks = [
-    {
-      name: 'Repository Pattern',
-      glob: '**/*Repository.cs'
-    },
-    {
-      name: 'Service Layer',
-      glob: '**/*Service.cs'
-    },
-    {
-      name: 'DTOs',
-      glob: '**/*Dto.cs'
-    },
-    {
-      name: 'Entity Framework',
-      glob: '**/Migrations/**/*.cs'
-    },
-    {
-      name: 'Dependency Injection',
-      glob: '**/DependencyInjection.cs'
-    },
-    {
-      name: 'Hangfire Jobs',
-      glob: '**/*Job.cs'
-    },
-    {
-      name: 'AI Agents',
-      glob: '**/*Agent.cs'
-    },
-    {
-      name: 'Unit Tests',
-      glob: '**/*.Tests/**/*.cs'
-    }
+  // C# / .NET patterns
+  const dotnetChecks = [
+    { name: 'Repository Pattern', glob: '**/*Repository.cs' },
+    { name: 'Service Layer', glob: '**/*Service.cs' },
+    { name: 'DTOs', glob: '**/*Dto.cs' },
+    { name: 'Entity Framework', glob: '**/Migrations/**/*.cs' },
+    { name: 'Dependency Injection', glob: '**/DependencyInjection.cs' },
+    { name: 'Hangfire Jobs', glob: '**/*Job.cs' },
+    { name: 'AI Agents', glob: '**/*Agent.cs' },
+    { name: 'Unit Tests', glob: '**/*.Tests/**/*.cs' }
+  ];
+
+  // JavaScript / TypeScript patterns
+  const jsChecks = [
+    { name: 'Service Layer', glob: 'src/**/*Service.js' },
+    { name: 'Service Layer', glob: 'src/**/*Service.ts' },
+    { name: 'Repository Pattern', glob: 'src/**/*Repository.js' },
+    { name: 'Repository Pattern', glob: 'src/**/*Repository.ts' },
+    { name: 'API Routes', glob: 'src/**/routes/**/*.{js,ts}' },
+    { name: 'API Routes', glob: 'src/commands/**/*.{js,ts}' },
+    { name: 'Unit Tests', glob: 'test/**/*.test.{js,ts}' },
+    { name: 'Unit Tests', glob: 'src/**/*.test.{js,ts}' },
+    { name: 'Unit Tests', glob: 'src/**/*.spec.{js,ts}' }
   ];
 
-  for (const { name, glob: pattern } of checks) {
-    const files = await glob(pattern, { cwd: projectPath, nodir: true });
+  const allChecks = [...dotnetChecks, ...jsChecks];
+  const seen = new Set();
+
+  for (const { name, glob: pattern } of allChecks) {
+    if (seen.has(name)) continue;
+    const files = await glob(pattern, { cwd: projectPath, nodir: true, ignore: globIgnore });
     if (files.length > 0) {
       patterns.push(name);
+      seen.add(name);
     }
   }
 

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

@@ -75,18 +75,38 @@ export async function generateRecap(projectPath, featureName, options = {}) {
 }
 
 function getTasksSummary(feature) {
-  const tasks = Array.isArray(feature.tasks) ? feature.tasks : [];
-  const completed = tasks.filter(t => t.status === 'completed');
-  const pending = tasks.filter(t => t.status === 'pending');
-  const inProgress = tasks.filter(t => t.status === 'in_progress');
+  // v2: feature.tasks is an array of task objects
+  if (Array.isArray(feature.tasks)) {
+    const tasks = feature.tasks;
+    const completed = tasks.filter(t => t.status === 'completed');
+    const pending = tasks.filter(t => t.status === 'pending');
+    const inProgress = tasks.filter(t => t.status === 'in_progress');
+    return {
+      total: tasks.length,
+      completed: completed.length,
+      pending: pending.length,
+      inProgress: inProgress.length,
+      percentage: tasks.length > 0 ? Math.round((completed.length / tasks.length) * 100) : 0,
+      items: tasks
+    };
+  }
+
+  // v3: feature.tasks is a counter object {total, completed, inProgress, pending}
+  // Use feature.taskList for individual items if available
+  const counters = feature.tasks || {};
+  const items = feature.taskList || [];
+  const total = counters.total || items.length || 0;
+  const completedCount = counters.completed ?? items.filter(t => t.status === 'completed').length;
+  const pendingCount = counters.pending ?? items.filter(t => t.status === 'pending').length;
+  const inProgressCount = counters.inProgress ?? items.filter(t => t.status === 'in_progress').length;
 
   return {
-    total: tasks.length,
-    completed: completed.length,
-    pending: pending.length,
-    inProgress: inProgress.length,
-    percentage: tasks.length > 0 ? Math.round((completed.length / tasks.length) * 100) : 0,
-    items: tasks
+    total,
+    completed: completedCount,
+    pending: pendingCount,
+    inProgress: inProgressCount,
+    percentage: total > 0 ? Math.round((completedCount / total) * 100) : 0,
+    items
   };
 }
 

package/src/lib/validators/validation-runner.js

@@ -187,39 +187,23 @@ async function runSingleValidator(validatorId, projectPath, featureName, options
     }
 
     case 'blazor': {
-      try {
-        const { validateBlazorPatterns } = await import('./blazor-validator.js');
-        return await validateBlazorPatterns(projectPath, options);
-      } catch {
-        return null; // Validator may not exist or have different export
-      }
+      const { validateBlazorPatterns } = await import('./blazor/blazor-validator.js');
+      return await validateBlazorPatterns(projectPath, options);
     }
 
     case 'blazor-concurrency': {
-      try {
-        const { analyzeConcurrency } = await import('./blazor-concurrency-analyzer.js');
-        return await analyzeConcurrency(projectPath, options);
-      } catch {
-        return null;
-      }
+      const { analyzeConcurrency } = await import('./blazor/blazor-concurrency-analyzer.js');
+      return await analyzeConcurrency(projectPath, options);
     }
 
     case 'blazor-state': {
-      try {
-        const { validateState } = await import('./blazor-state-validator.js');
-        return await validateState(projectPath, options);
-      } catch {
-        return null;
-      }
+      const { validateState } = await import('./blazor/blazor-state-validator.js');
+      return await validateState(projectPath, options);
     }
 
     case 'css': {
-      try {
-        const { validateCss } = await import('./css-validator.js');
-        return await validateCss(projectPath, options);
-      } catch {
-        return null;
-      }
+      const { validateCss } = await import('./css/css-validator.js');
+      return await validateCss(projectPath, options);
     }
 
     case 'contract-compliance': {

package/src/utils/hooks-installer.js

@@ -0,0 +1,69 @@
+/**
+ * Claude Code Hooks Installer
+ *
+ * Merges the MORPH-SPEC agent-teams PostToolUse hook into
+ * .claude/settings.local.json without overwriting existing config.
+ *
+ * Called by `morph-spec init` and `morph-spec update`.
+ */
+
+import { join } from 'path';
+import { readFile, writeFile, mkdir } from 'fs/promises';
+import { existsSync } from 'fs';
+
+const DISPATCH_COMMAND = 'node framework/hooks/agent-teams/dispatch.js';
+
+/**
+ * Install or update the MORPH-SPEC PostToolUse hook in .claude/settings.local.json.
+ *
+ * @param {string} targetPath - Project root directory
+ * @returns {boolean} true if the hook was newly added, false if it was already present
+ */
+export async function installClaudeHooks(targetPath) {
+  const claudeDir = join(targetPath, '.claude');
+  const settingsPath = join(claudeDir, 'settings.local.json');
+
+  // Read existing settings or start empty
+  let settings = {};
+  if (existsSync(settingsPath)) {
+    try {
+      settings = JSON.parse(await readFile(settingsPath, 'utf-8'));
+    } catch {
+      // Malformed JSON — start fresh to avoid corrupting the file
+      settings = {};
+    }
+  }
+
+  // Ensure hooks.PostToolUse array exists
+  settings.hooks = settings.hooks || {};
+  settings.hooks.PostToolUse = settings.hooks.PostToolUse || [];
+
+  // Check if dispatch.js is already registered (avoid duplicate entries)
+  const alreadyRegistered = settings.hooks.PostToolUse.some(entry =>
+    Array.isArray(entry.hooks) &&
+    entry.hooks.some(h => h.command === DISPATCH_COMMAND)
+  );
+
+  if (alreadyRegistered) {
+    return false;
+  }
+
+  // Add the agent-teams dispatch hook
+  settings.hooks.PostToolUse.push({
+    matcher: 'Bash',
+    hooks: [
+      {
+        type: 'command',
+        command: DISPATCH_COMMAND
+      }
+    ]
+  });
+
+  // Ensure .claude directory exists
+  if (!existsSync(claudeDir)) {
+    await mkdir(claudeDir, { recursive: true });
+  }
+
+  await writeFile(settingsPath, JSON.stringify(settings, null, 2) + '\n', 'utf-8');
+  return true;
+}