@polymorphism-tech/morph-spec 4.9.0 → 4.10.1

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

@@ -1,335 +0,0 @@
-/**
- * Standards Generator - Generates inferred-standards.md from detection results
- */
-
-/**
- * Generate inferred standards
- * @param {Object} detectionResults - Results from all detectors
- * @returns {Promise<Object>} Generated standards
- */
-export async function generateStandards(detectionResults) {
-  const { structure, config, conversation } = detectionResults;
-
-  const standards = {
-    markdown: generateMarkdown(structure, config, conversation),
-    recommendations: generateRecommendations(structure, config, conversation),
-    gaps: identifyGaps(structure, config)
-  };
-
-  return standards;
-}
-
-/**
- * Generate markdown content for inferred-standards.md
- */
-function generateMarkdown(structure, config, conversation) {
-  const sections = [];
-
-  // Header
-  sections.push(`# Inferred Standards (Auto-generated)`);
-  sections.push(``);
-  sections.push(`> ⚠️ This file is auto-generated by MORPH-SPEC detection system.`);
-  sections.push(`> Manual edits will be overwritten. Create custom standards in \`overrides.md\`.`);
-  sections.push(``);
-  sections.push(`**Generated:** ${new Date().toISOString()}`);
-  sections.push(``);
-  sections.push(`---`);
-  sections.push(``);
-
-  // Stack Summary
-  sections.push(`## 🎯 Project Stack`);
-  sections.push(``);
-  sections.push(`- **Type**: ${structure?.stack || 'unknown'}`);
-  sections.push(`- **Language**: ${config?.language || 'unknown'}`);
-  sections.push(`- **Version**: ${config?.version || 'unknown'}`);
-  sections.push(`- **Architecture**: ${structure?.architecture || 'unknown'}`);
-  if (structure?.uiLibrary) {
-    sections.push(`- **UI Library**: ${structure.uiLibrary}`);
-  }
-  sections.push(``);
-
-  // Technologies
-  if (config?.technologies?.length > 0) {
-    sections.push(`## 🛠️ Technologies Detected`);
-    sections.push(``);
-    config.technologies.forEach(tech => {
-      sections.push(`- ${tech}`);
-    });
-    sections.push(``);
-  }
-
-  // Patterns
-  if (structure?.patterns?.length > 0) {
-    sections.push(`## 📐 Patterns in Use`);
-    sections.push(``);
-    structure.patterns.forEach(pattern => {
-      sections.push(`- ${pattern}`);
-    });
-    sections.push(``);
-  }
-
-  // Coding Standards (inferred)
-  sections.push(`## 💻 Inferred Coding Standards`);
-  sections.push(``);
-  sections.push(generateCodingStandards(structure, config));
-  sections.push(``);
-
-  // Architecture Patterns
-  if (structure?.architecture !== 'unknown') {
-    sections.push(`## 🏗️ Architecture Pattern`);
-    sections.push(``);
-    sections.push(generateArchitectureSection(structure));
-    sections.push(``);
-  }
-
-  // Dependencies
-  if (config?.dependencies?.length > 0) {
-    sections.push(`## 📦 Key Dependencies`);
-    sections.push(``);
-    const importantDeps = filterImportantDependencies(config.dependencies);
-    importantDeps.slice(0, 10).forEach(dep => {
-      sections.push(`- ${dep}`);
-    });
-    if (config.dependencies.length > 10) {
-      sections.push(`- ... and ${config.dependencies.length - 10} more`);
-    }
-    sections.push(``);
-  }
-
-  // User Preferences (from conversation)
-  if (conversation?.preferences && Object.keys(conversation.preferences).some(k => conversation.preferences[k])) {
-    sections.push(`## 🎨 User Preferences (from past decisions)`);
-    sections.push(``);
-    Object.entries(conversation.preferences).forEach(([key, value]) => {
-      if (value) {
-        sections.push(`- **${formatKey(key)}**: ${value}`);
-      }
-    });
-    sections.push(``);
-  }
-
-  return sections.join('\n');
-}
-
-/**
- * Generate coding standards section
- */
-function generateCodingStandards(structure, config) {
-  if (config?.language === 'csharp') {
-    return `### C# / .NET Conventions
-
-Based on detected patterns in your codebase:
-
-- **Naming**: PascalCase for classes, camelCase for variables
-- **Async**: Methods with \`Async\` suffix
-- **DI**: Constructor injection (${structure.patterns.includes('Dependency Injection') ? '✅ detected' : '⚠️ not detected'})
-- **Tests**: ${structure.patterns.includes('Unit Tests') ? '✅ Present' : '⚠️ Not detected'}
-
-**Recommendation**: Refer to \`.morph/framework/standards/coding.md\` for complete .NET standards.`;
-  }
-
-  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}${techLine}
-
-**Recommendation**: Refer to framework standards for JavaScript best practices.`;
-  }
-
-  return 'No specific coding standards inferred. Check framework standards for guidance.';
-}
-
-/**
- * Generate architecture section
- */
-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:
-
-- ✅ **Domain** layer detected (core business logic)
-- ✅ **Application** layer detected (use cases)
-- ✅ **Infrastructure** layer detected (implementations)
-
-**Key principles**:
-- Domain has no dependencies
-- Application depends on Domain
-- Infrastructure implements Application interfaces`,
-
-    'cqrs': `### CQRS Pattern
-
-Your project uses Command Query Responsibility Segregation:
-
-- ✅ **Commands** detected (write operations)
-- ✅ **Queries** detected (read operations)
-
-**Key principles**:
-- Separate read and write models
-- Commands return void or Task
-- Queries return data`,
-
-    'mvc': `### MVC Pattern
-
-Your project uses Model-View-Controller pattern:
-
-- ✅ **Controllers** detected
-- ✅ **Models** detected
-- ✅ **Views** detected`
-  };
-
-  return descriptions[architecture] || `Architecture: ${architecture}`;
-}
-
-/**
- * Generate recommendations
- */
-function generateRecommendations(structure, config, conversation) {
-  const recommendations = [];
-
-  // Recommend based on stack
-  if (structure?.stack === 'blazor') {
-    if (!structure.uiLibrary) {
-      recommendations.push('Consider adding Fluent UI Blazor or MudBlazor for consistent UI components');
-    }
-
-    if (!structure.patterns.includes('AI Agents') && config?.technologies?.includes('Microsoft Agent Framework')) {
-      recommendations.push('Setup detected Agent Framework but no agents found - check .morph/framework/standards/agent-framework-setup.md');
-    }
-  }
-
-  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');
-    }
-
-    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');
-    }
-
-    // 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;
-}
-
-/**
- * Identify gaps between framework and project
- */
-function identifyGaps(structure, config) {
-  const gaps = [];
-
-  // Check for missing patterns
-  const expectedPatterns = {
-    blazor: ['Service Layer', 'Repository Pattern', 'Dependency Injection'],
-    nextjs: ['API Routes', 'Components'],
-  };
-
-  const expected = expectedPatterns[structure?.stack];
-  if (expected) {
-    expected.forEach(pattern => {
-      if (!structure?.patterns?.includes(pattern)) {
-        gaps.push(`Missing: ${pattern}`);
-      }
-    });
-  }
-
-  return gaps;
-}
-
-/**
- * Filter important dependencies
- */
-function filterImportantDependencies(deps) {
-  const important = deps.filter(dep => {
-    // .NET Framework packages
-    if (dep.includes('Microsoft.') || dep.includes('System.')) return true;
-    // Blazor UI libraries
-    if (dep.includes('Blazor') || dep.includes('FluentUI') || dep.includes('Mud')) return true;
-    // .NET common tools
-    if (dep.includes('Hangfire') || dep.includes('Serilog') || dep.includes('AutoMapper')) return true;
-    // 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;
-  });
-
-  return important.length > 0 ? important : deps;
-}
-
-/**
- * Format key for display
- */
-function formatKey(key) {
-  return key
-    .replace(/([A-Z])/g, ' $1')
-    .replace(/^./, str => str.toUpperCase())
-    .trim();
-}

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

@@ -1,275 +0,0 @@
-/**
- * Structure Detector - Analyzes folder structure to infer stack and architecture
- */
-
-import { glob } from 'glob';
-import { join } from 'path';
-import { existsSync } from 'fs';
-
-/**
- * Detect project structure
- * @param {string} projectPath - Project root path
- * @returns {Promise<Object>} Structure detection results
- */
-export async function detectStructure(projectPath) {
-  const result = {
-    stack: 'unknown',
-    architecture: 'unknown',
-    uiLibrary: null,
-    patterns: [],
-    folders: {
-      hasPages: false,
-      hasComponents: false,
-      hasServices: false,
-      hasRepositories: false,
-      hasAgents: false
-    }
-  };
-
-  // Detect stack
-  result.stack = await detectStack(projectPath);
-
-  // Detect architecture pattern
-  result.architecture = await detectArchitecture(projectPath);
-
-  // Detect UI library
-  if (result.stack === 'blazor') {
-    result.uiLibrary = await detectUILibrary(projectPath);
-  }
-
-  // Detect patterns
-  result.patterns = await detectPatterns(projectPath);
-
-  // Analyze folders
-  result.folders = await analyzeFolders(projectPath);
-
-  return result;
-}
-
-/**
- * Detect stack type
- */
-async function detectStack(projectPath) {
-  // Order matters: more specific patterns first
-  const patterns = {
-    blazor: [
-      '**/*.razor',
-      '**/Pages/**/*.razor',
-      '**/Components/**/*.razor'
-    ],
-    nextjs: [
-      '**/next.config.js',
-      '**/next.config.mjs',
-      '**/next.config.ts',
-      'pages/**/*.tsx',
-      'app/**/*.tsx',
-      '**/pages/**/*.tsx',
-      '**/app/**/*.tsx'
-    ],
-    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'
-    ]
-  };
-
-  const globIgnore = ['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, ignore: globIgnore });
-      if (files.length > 0) {
-        return stack;
-      }
-    }
-  }
-
-  return 'unknown';
-}
-
-/**
- * Detect architecture pattern
- */
-async function detectArchitecture(projectPath) {
-  const globIgnore = ['framework/**', 'test/**', 'node_modules/**', '.morph/**'];
-
-  const checks = [
-    // .NET: Clean Architecture
-    {
-      pattern: 'clean-architecture',
-      indicators: [
-        existsSync(join(projectPath, 'src', 'Application')),
-        existsSync(join(projectPath, 'src', 'Domain')),
-        existsSync(join(projectPath, 'src', 'Infrastructure'))
-      ]
-    },
-    // .NET: CQRS
-    {
-      pattern: 'cqrs',
-      indicators: [
-        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: [
-        existsSync(join(projectPath, 'Controllers')),
-        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'))
-      ]
-    }
-  ];
-
-  for (const { pattern, indicators } of checks) {
-    if (indicators.every(Boolean)) {
-      return pattern;
-    }
-  }
-
-  return 'unknown';
-}
-
-/**
- * Detect UI library (Blazor projects)
- */
-async function detectUILibrary(projectPath) {
-  const csprojFiles = await glob('**/*.csproj', { cwd: projectPath });
-
-  for (const csprojFile of csprojFiles) {
-    const content = await import('fs').then(fs =>
-      fs.promises.readFile(join(projectPath, csprojFile), 'utf8')
-    );
-
-    if (content.includes('FluentUI.Blazor') || content.includes('Microsoft.FluentUI.AspNetCore.Components')) {
-      return 'fluent-ui';
-    }
-
-    if (content.includes('MudBlazor')) {
-      return 'mudblazor';
-    }
-  }
-
-  return null;
-}
-
-/**
- * Detect common patterns
- */
-async function detectPatterns(projectPath) {
-  const patterns = [];
-  // Ignore template/vendor directories; keep test/ accessible for JS test detection
-  const globIgnore = ['framework/**', 'test/fixtures/**', 'node_modules/**', '.morph/**'];
-
-  // 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}' }
-  ];
-
-  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);
-    }
-  }
-
-  return patterns;
-}
-
-/**
- * Analyze folder structure
- */
-async function analyzeFolders(projectPath) {
-  const folders = {
-    hasPages: false,
-    hasComponents: false,
-    hasServices: false,
-    hasRepositories: false,
-    hasAgents: false
-  };
-
-  folders.hasPages = await glob('**/Pages/**/*', { cwd: projectPath }).then(f => f.length > 0);
-  folders.hasComponents = await glob('**/Components/**/*', { cwd: projectPath }).then(f => f.length > 0);
-  folders.hasServices = await glob('**/Services/**/*', { cwd: projectPath }).then(f => f.length > 0);
-  folders.hasRepositories = await glob('**/Repositories/**/*', { cwd: projectPath }).then(f => f.length > 0);
-  folders.hasAgents = await glob('**/Agents/**/*', { cwd: projectPath }).then(f => f.length > 0);
-
-  return folders;
-}