@polymorphism-tech/morph-spec 4.2.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/execution/fusion-executor.js

@@ -0,0 +1,304 @@
+/**
+ * Fusion Executor — F-Thread best-of-N aggregation
+ *
+ * Runs N parallel agents on the same prompt, collects results,
+ * then aggregates using one of three strategies:
+ *   - best-of-n: score each result, pick highest (automated)
+ *   - consensus: merge common elements from all results
+ *   - manual-select: present all N to user for selection
+ *
+ * Returns: { winner, allResults, scores }
+ */
+
+import { createThread, startThread, completeThread, failThread, THREAD_TYPES } from '../threads/thread-manager.js';
+import { recordEvent, generateAsciiChart } from '../analytics/analytics-engine.js';
+
+// ============================================================================
+// Scoring
+// ============================================================================
+
+/**
+ * Score a fusion result based on completeness, compliance, and quality
+ * @param {Object} result - Agent result object
+ * @param {Object} [rubric] - Scoring rubric
+ * @returns {number} Score 0-100
+ */
+export function scoreResult(result, rubric = {}) {
+  let score = 0;
+  const weights = {
+    completeness: rubric.completenessWeight || 40,
+    checkpointCompliance: rubric.complianceWeight || 30,
+    codeQuality: rubric.qualityWeight || 30
+  };
+
+  // Completeness: does it have all required deliverables?
+  if (result.deliverables) {
+    const required = rubric.requiredDeliverables?.length || 1;
+    const provided = Object.keys(result.deliverables).length;
+    score += weights.completeness * Math.min(provided / required, 1.0);
+  } else if (result.content) {
+    // Estimate completeness from content length
+    const targetLength = rubric.targetLength || 1000;
+    score += weights.completeness * Math.min(result.content.length / targetLength, 1.0);
+  } else {
+    score += weights.completeness * 0.5; // Partial credit
+  }
+
+  // Checkpoint compliance: did it follow patterns?
+  if (result.checkpointsPassed !== undefined) {
+    const total = (result.checkpointsPassed || 0) + (result.checkpointsFailed || 0);
+    const passRate = total > 0 ? result.checkpointsPassed / total : 0.8; // Assume 80% if unknown
+    score += weights.checkpointCompliance * passRate;
+  } else {
+    score += weights.checkpointCompliance * 0.8; // Default: assume compliant
+  }
+
+  // Code quality: based on error count and warnings
+  const errors = result.errors || 0;
+  const warnings = result.warnings || 0;
+  const qualityScore = Math.max(0, 1.0 - (errors * 0.2) - (warnings * 0.05));
+  score += weights.codeQuality * qualityScore;
+
+  return Math.round(score);
+}
+
+// ============================================================================
+// Aggregation Strategies
+// ============================================================================
+
+/**
+ * Best-of-N aggregation: score each result, return highest scorer
+ * @param {Array} results - Array of agent results
+ * @param {Object} rubric - Scoring rubric
+ * @returns {Object} { winner, scores }
+ */
+export function aggregateBestOfN(results, rubric = {}) {
+  const scored = results.map((result, idx) => ({
+    index: idx,
+    agentId: result.agentId || `agent-${idx}`,
+    result,
+    score: scoreResult(result, rubric)
+  }));
+
+  scored.sort((a, b) => b.score - a.score);
+  const winner = scored[0];
+
+  return {
+    winner: winner.result,
+    winnerId: winner.agentId,
+    winnerScore: winner.score,
+    scores: scored.map(s => ({
+      agentId: s.agentId,
+      score: s.score,
+      rank: scored.indexOf(s) + 1
+    }))
+  };
+}
+
+/**
+ * Consensus aggregation: merge common elements from all results
+ * @param {Array} results - Array of agent results
+ * @returns {Object} { merged, commonElements }
+ */
+export function aggregateConsensus(results) {
+  if (results.length === 0) return { merged: {}, commonElements: [] };
+  if (results.length === 1) return { merged: results[0], commonElements: [] };
+
+  // Find common keys across all results
+  const allKeys = results.map(r => Object.keys(r));
+  const commonKeys = allKeys[0].filter(key =>
+    allKeys.every(keys => keys.includes(key))
+  );
+
+  const merged = {};
+  const commonElements = [];
+
+  for (const key of commonKeys) {
+    const values = results.map(r => r[key]);
+
+    // For strings: use longest (most complete) version
+    if (values.every(v => typeof v === 'string')) {
+      merged[key] = values.reduce((longest, v) =>
+        v.length > longest.length ? v : longest, ''
+      );
+      commonElements.push(key);
+    }
+    // For arrays: union of all arrays
+    else if (values.every(v => Array.isArray(v))) {
+      merged[key] = [...new Set(values.flat())];
+      commonElements.push(key);
+    }
+    // For objects: merge recursively (simple one level)
+    else if (values.every(v => v && typeof v === 'object')) {
+      merged[key] = Object.assign({}, ...values);
+      commonElements.push(key);
+    }
+    // For primitives: use majority value
+    else {
+      const valueCounts = values.reduce((acc, v) => {
+        const key2 = String(v);
+        acc[key2] = (acc[key2] || 0) + 1;
+        return acc;
+      }, {});
+      const [majority] = Object.entries(valueCounts).sort(([, a], [, b]) => b - a);
+      merged[key] = majority ? JSON.parse(majority[0]) : values[0];
+      commonElements.push(key);
+    }
+  }
+
+  return { merged, commonElements };
+}
+
+// ============================================================================
+// Main Fusion Runner
+// ============================================================================
+
+/**
+ * Run fusion execution: spawn N agents in parallel, collect and aggregate results
+ * @param {Object} opts
+ * @param {string} opts.feature - Feature name
+ * @param {string} opts.prompt - Prompt/mission for all agents
+ * @param {number} [opts.count=3] - Number of agents to run
+ * @param {string} [opts.strategy='best-of-n'] - Aggregation strategy
+ * @param {string[]} [opts.agents] - Agent IDs to use (will use thread types if not specified)
+ * @param {Object} [opts.rubric] - Scoring rubric for best-of-n
+ * @returns {Promise<Object>} { winner, allResults, scores, strategy, threads }
+ */
+export async function runFusion(prompt, {
+  feature,
+  count = 3,
+  strategy = 'best-of-n',
+  agents = null,
+  rubric = {}
+} = {}) {
+  const { randomUUID } = await import('crypto');
+  const sessionId = randomUUID();
+  const agentList = agents || Array.from({ length: count }, (_, i) => `fusion-agent-${i + 1}`);
+  const threads = [];
+  const results = [];
+
+  recordEvent({
+    type: 'fusion_started',
+    feature,
+    data: { count, strategy, agents: agentList }
+  });
+
+  // Create and start all fusion threads simultaneously
+  for (let i = 0; i < agentList.length; i++) {
+    const thread = createThread({
+      feature,
+      type: THREAD_TYPES.FUSION,
+      agent: agentList[i],
+      mission: prompt,
+      meta: { fusionIndex: i, strategy }
+    });
+    startThread(thread.id);
+    threads.push(thread);
+  }
+
+  console.log(`  [fusion] ${threads.length} agents spawned. Collecting results...`);
+
+  // In a real system, results would come from actual sub-agent execution.
+  // Here we return thread configs for the calling code to use with Task tool.
+  // The aggregation is designed to be called after results are collected.
+
+  return {
+    id: sessionId,
+    threads,
+    strategy,
+    feature,
+    prompt,
+    agentConfigs: agentList.map((agentId, i) => ({
+      agentId,
+      threadId: threads[i].id,
+      mission: prompt
+    })),
+    aggregate: (collectedResults) => aggregateResults(collectedResults, strategy, rubric)
+  };
+}
+
+/**
+ * Aggregate collected results from N agents
+ * @param {Array} results - Array of result objects from agents
+ * @param {string} strategy - Aggregation strategy
+ * @param {Object} [rubric] - Scoring rubric for best-of-n
+ * @returns {Object} Aggregated result
+ */
+export function aggregateResults(results, strategy = 'best-of-n', rubric = {}) {
+  if (!results || results.length === 0) {
+    throw new Error('No results to aggregate');
+  }
+
+  let aggregated;
+
+  switch (strategy) {
+    case 'best-of-n':
+      aggregated = aggregateBestOfN(results, rubric);
+      break;
+
+    case 'consensus':
+      const { merged, commonElements } = aggregateConsensus(results);
+      aggregated = {
+        winner: merged,
+        winnerId: 'consensus',
+        scores: results.map((_, i) => ({
+          agentId: `agent-${i}`,
+          score: 0,
+          rank: i + 1
+        })),
+        commonElements
+      };
+      break;
+
+    case 'manual-select':
+      aggregated = {
+        winner: null,
+        winnerId: null,
+        allResults: results,
+        requiresUserSelection: true,
+        scores: results.map((r, i) => ({
+          agentId: r.agentId || `agent-${i}`,
+          score: scoreResult(r, rubric),
+          rank: i + 1
+        }))
+      };
+      break;
+
+    default:
+      throw new Error(`Unknown aggregation strategy: ${strategy}`);
+  }
+
+  return {
+    ...aggregated,
+    strategy,
+    totalAgents: results.length,
+    allResults: results
+  };
+}
+
+/**
+ * Display fusion results summary
+ * @param {Object} fusionResult - Result from aggregateResults
+ */
+export function displayFusionSummary(fusionResult) {
+  const { strategy, totalAgents, scores, winner, requiresUserSelection } = fusionResult;
+
+  console.log(`\n  Fusion Results — ${strategy} (${totalAgents} agents)\n`);
+  console.log('  ' + '─'.repeat(50));
+
+  if (scores) {
+    const scoreData = {};
+    scores.forEach(s => { scoreData[s.agentId] = s.score; });
+    console.log(generateAsciiChart(scoreData, { title: 'Agent Scores' }));
+  }
+
+  if (requiresUserSelection) {
+    console.log('\n  Manual selection required — review results above');
+  } else if (winner) {
+    console.log(`\n  Winner: ${fusionResult.winnerId || 'consensus'}`);
+    if (fusionResult.winnerScore !== undefined) {
+      console.log(`  Score: ${fusionResult.winnerScore}/100`);
+    }
+  }
+  console.log('');
+}