@polymorphism-tech/morph-spec 4.9.0 → 4.10.0

package/src/core/templates/template-data-sources.js

@@ -1,325 +0,0 @@
-import { glob } from 'glob';
-import { readFileSync, existsSync } from 'fs';
-import { join } from 'path';
-import { execSync } from 'child_process';
-
-/**
- * Template Data Sources - Inject dynamic MCP data into templates
- *
- * Provides project context, compliance status, and recent activity
- * for enriching template placeholders.
- */
-
-/**
- * Get project structure statistics
- * @param {string} projectPath - Project root path
- * @returns {Promise<Object>} Project structure data
- */
-export async function getProjectStructure(projectPath = process.cwd()) {
-  try {
-    // Find all files (excluding common ignore patterns)
-    const files = await glob('**/*', {
-      cwd: projectPath,
-      ignore: [
-        'node_modules/**',
-        'bin/**',
-        'obj/**',
-        '.git/**',
-        '.morph/**',
-        'dist/**',
-        'build/**',
-        '*.log'
-      ],
-      nodir: true
-    });
-
-    // Calculate language stats
-    const languageStats = {};
-    files.forEach(file => {
-      const ext = file.split('.').pop();
-      languageStats[ext] = (languageStats[ext] || 0) + 1;
-    });
-
-    // Get test coverage if available
-    let testCoverage = null;
-    const coveragePath = join(projectPath, 'coverage/coverage-summary.json');
-    if (existsSync(coveragePath)) {
-      const coverageData = JSON.parse(readFileSync(coveragePath, 'utf8'));
-      testCoverage = coverageData.total?.lines?.pct || null;
-    }
-
-    // Get last commit info
-    let lastCommit = null;
-    try {
-      const gitLog = execSync('git log -1 --format="%H|%an|%ar|%s"', {
-        cwd: projectPath,
-        encoding: 'utf8',
-        stdio: 'pipe'
-      });
-
-      const [hash, author, time, message] = gitLog.trim().split('|');
-      lastCommit = { hash: hash.substring(0, 7), author, time, message };
-    } catch {
-      // Git not available or not a repo
-    }
-
-    return {
-      totalFiles: files.length,
-      languageStats,
-      testCoverage: testCoverage ? Math.round(testCoverage) : null,
-      lastCommit,
-      filesByExtension: {
-        cs: languageStats.cs || 0,
-        js: languageStats.js || 0,
-        ts: languageStats.ts || 0,
-        tsx: languageStats.tsx || 0,
-        razor: languageStats.razor || 0,
-        css: languageStats.css || 0,
-        md: languageStats.md || 0
-      }
-    };
-  } catch (error) {
-    return {
-      error: error.message,
-      totalFiles: 0,
-      testCoverage: null
-    };
-  }
-}
-
-/**
- * Get dependency information
- * @param {string} projectPath - Project root path
- * @returns {Promise<Object>} Dependency data
- */
-export async function getDependencyInfo(projectPath = process.cwd()) {
-  const dependencies = {
-    nuget: [],
-    npm: [],
-    outdated: []
-  };
-
-  try {
-    // Check for NuGet packages (C# projects)
-    const csprojFiles = await glob('**/*.csproj', {
-      cwd: projectPath,
-      ignore: ['**/bin/**', '**/obj/**']
-    });
-
-    if (csprojFiles.length > 0) {
-      const csprojPath = join(projectPath, csprojFiles[0]);
-      const csprojContent = readFileSync(csprojPath, 'utf8');
-
-      // Extract PackageReference elements
-      const packageRegex = /<PackageReference\s+Include="([^"]+)"\s+Version="([^"]+)"/g;
-      let match;
-
-      while ((match = packageRegex.exec(csprojContent)) !== null) {
-        dependencies.nuget.push({
-          name: match[1],
-          version: match[2]
-        });
-      }
-    }
-
-    // Check for npm packages
-    const packageJsonPath = join(projectPath, 'package.json');
-    if (existsSync(packageJsonPath)) {
-      const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf8'));
-
-      const allDeps = {
-        ...packageJson.dependencies,
-        ...packageJson.devDependencies
-      };
-
-      Object.entries(allDeps).forEach(([name, version]) => {
-        dependencies.npm.push({ name, version });
-      });
-    }
-
-  } catch (error) {
-    dependencies.error = error.message;
-  }
-
-  return dependencies;
-}
-
-/**
- * Get compliance status from validators
- * @param {string} projectPath - Project root path
- * @returns {Promise<Object>} Compliance data
- */
-export async function getComplianceStatus(projectPath = process.cwd()) {
-  const compliance = {
-    architectureViolations: 0,
-    packageConflicts: 0,
-    designSystemCompliance: 100,
-    securityIssues: 0,
-    overall: 100
-  };
-
-  try {
-    // Run validators if available
-    const validators = ['architecture', 'packages', 'design-system', 'security'];
-
-    for (const validator of validators) {
-      try {
-        const result = execSync(
-          `node bin/validate.js ${validator} --json`,
-          {
-            cwd: projectPath,
-            encoding: 'utf8',
-            stdio: 'pipe'
-          }
-        );
-
-        const parsed = JSON.parse(result);
-
-        if (validator === 'architecture') {
-          compliance.architectureViolations = parsed.errors || 0;
-        } else if (validator === 'packages') {
-          compliance.packageConflicts = parsed.errors || 0;
-        } else if (validator === 'design-system') {
-          const total = parsed.total || 100;
-          const errors = parsed.errors || 0;
-          compliance.designSystemCompliance = Math.round(((total - errors) / total) * 100);
-        } else if (validator === 'security') {
-          compliance.securityIssues = parsed.errors || 0;
-        }
-      } catch {
-        // Validator not available or failed - skip
-      }
-    }
-
-    // Calculate overall compliance score
-    const violations = compliance.architectureViolations +
-                      compliance.packageConflicts +
-                      compliance.securityIssues;
-
-    compliance.overall = Math.max(0, 100 - (violations * 5));
-
-  } catch (error) {
-    compliance.error = error.message;
-  }
-
-  return compliance;
-}
-
-/**
- * Get recent activity and history
- * @param {string} projectPath - Project root path
- * @returns {Promise<Object>} Activity data
- */
-export async function getRecentActivity(projectPath = process.cwd()) {
-  const activity = {
-    lastFeature: null,
-    recentCommits: [],
-    activeBranches: [],
-    lastDeployment: null
-  };
-
-  try {
-    // Check state.json for last feature
-    const statePath = join(projectPath, '.morph/state.json');
-    if (existsSync(statePath)) {
-      const state = JSON.parse(readFileSync(statePath, 'utf8'));
-
-      // Find most recently updated feature
-      let lastFeature = null;
-      let lastTimestamp = null;
-
-      Object.entries(state.features || {}).forEach(([name, feature]) => {
-        const updatedAt = feature.updatedAt || feature.createdAt;
-        if (updatedAt && (!lastTimestamp || updatedAt > lastTimestamp)) {
-          lastTimestamp = updatedAt;
-          lastFeature = name;
-        }
-      });
-
-      activity.lastFeature = lastFeature;
-    }
-
-    // Get recent commits
-    try {
-      const gitLog = execSync('git log -5 --format="%h|%an|%ar|%s"', {
-        cwd: projectPath,
-        encoding: 'utf8',
-        stdio: 'pipe'
-      });
-
-      activity.recentCommits = gitLog.trim().split('\n').map(line => {
-        const [hash, author, time, message] = line.split('|');
-        return { hash, author, time, message };
-      });
-    } catch {
-      // Git not available
-    }
-
-    // Get active branches
-    try {
-      const branches = execSync('git branch -a', {
-        cwd: projectPath,
-        encoding: 'utf8',
-        stdio: 'pipe'
-      });
-
-      activity.activeBranches = branches
-        .split('\n')
-        .map(b => b.trim().replace(/^\*\s+/, ''))
-        .filter(b => b && !b.includes('->'));
-    } catch {
-      // Git not available
-    }
-
-  } catch (error) {
-    activity.error = error.message;
-  }
-
-  return activity;
-}
-
-/**
- * Get all template data sources combined
- * @param {string} projectPath - Project root path
- * @returns {Promise<Object>} All data sources
- */
-export async function getAllTemplatePlaceholders(projectPath = process.cwd()) {
-  const [structure, dependencies, compliance, activity] = await Promise.all([
-    getProjectStructure(projectPath),
-    getDependencyInfo(projectPath),
-    getComplianceStatus(projectPath),
-    getRecentActivity(projectPath)
-  ]);
-
-  return {
-    MCP_PROJECT_FILES: structure.totalFiles,
-    MCP_TEST_COVERAGE: structure.testCoverage || 'N/A',
-    MCP_COMPLIANCE_SCORE: compliance.overall,
-    MCP_LAST_FEATURE: activity.lastFeature || 'None',
-    MCP_LAST_COMMIT: structure.lastCommit?.message || 'Unknown',
-    MCP_LAST_COMMIT_AUTHOR: structure.lastCommit?.author || 'Unknown',
-    MCP_LAST_COMMIT_TIME: structure.lastCommit?.time || 'Unknown',
-
-    MCP_CS_FILES: structure.filesByExtension?.cs || 0,
-    MCP_RAZOR_FILES: structure.filesByExtension?.razor || 0,
-    MCP_TS_FILES: structure.filesByExtension?.ts || 0,
-    MCP_JS_FILES: structure.filesByExtension?.js || 0,
-
-    MCP_NUGET_PACKAGES: dependencies.nuget.length,
-    MCP_NPM_PACKAGES: dependencies.npm.length,
-
-    MCP_ARCHITECTURE_VIOLATIONS: compliance.architectureViolations,
-    MCP_PACKAGE_CONFLICTS: compliance.packageConflicts,
-    MCP_SECURITY_ISSUES: compliance.securityIssues,
-
-    MCP_RECENT_BRANCHES: activity.activeBranches.slice(0, 3).join(', '),
-
-    // Full objects for advanced usage
-    _raw: {
-      structure,
-      dependencies,
-      compliance,
-      activity
-    }
-  };
-}

package/src/core/workflows/index.js

@@ -1,7 +0,0 @@
-/**
- * Core Workflow System
- *
- * Workflow detection and classification (fast-track, standard, full-morph, etc.)
- */
-
-export { WorkflowDetector, detectWorkflow } from './workflow-detector.js';

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

@@ -1,223 +0,0 @@
-/**
- * Config Detector - Reads configuration files to extract technologies, versions, and dependencies
- */
-
-import { readFileSync, existsSync } from 'fs';
-import { join } from 'path';
-import { glob } from 'glob';
-
-/**
- * Detect project configuration
- * @param {string} projectPath - Project root path
- * @returns {Promise<Object>} Configuration detection results
- */
-export async function detectConfig(projectPath) {
-  const result = {
-    language: 'unknown',
-    version: null,
-    packageManager: 'unknown',
-    dependencies: [],
-    technologies: [],
-    auth: null,
-    database: null,
-    hosting: null
-  };
-
-  // Detect .NET projects
-  const dotnetConfig = await detectDotNet(projectPath);
-  if (dotnetConfig) {
-    Object.assign(result, dotnetConfig);
-    return result;
-  }
-
-  // Detect Node.js projects
-  const nodeConfig = await detectNode(projectPath);
-  if (nodeConfig) {
-    Object.assign(result, nodeConfig);
-    return result;
-  }
-
-  return result;
-}
-
-/**
- * Detect .NET configuration
- */
-async function detectDotNet(projectPath) {
-  const programCs = join(projectPath, 'Program.cs');
-  const csprojFiles = await glob('**/*.csproj', { cwd: projectPath });
-
-  if (!existsSync(programCs) && csprojFiles.length === 0) {
-    return null;
-  }
-
-  const config = {
-    language: 'csharp',
-    version: null,
-    packageManager: 'dotnet',
-    dependencies: [],
-    technologies: [],
-    auth: null,
-    database: null,
-    hosting: null
-  };
-
-  // Read Program.cs
-  if (existsSync(programCs)) {
-    const content = readFileSync(programCs, 'utf8');
-
-    // Detect .NET version
-    if (content.includes('WebApplication.CreateBuilder') || content.includes('.NET')) {
-      config.version = detectDotNetVersion(content);
-    }
-
-    // Detect technologies from Program.cs
-    config.technologies = detectTechnologiesFromProgramCs(content);
-    config.auth = detectAuthMethod(content);
-    config.database = detectDatabase(content);
-    config.hosting = detectHosting(content);
-  }
-
-  // Read .csproj files
-  for (const csprojFile of csprojFiles.slice(0, 3)) { // Read first 3 csproj files
-    const csprojPath = join(projectPath, csprojFile);
-    const content = readFileSync(csprojPath, 'utf8');
-
-    config.dependencies.push(...extractNuGetPackages(content));
-  }
-
-  // Remove duplicates
-  config.dependencies = [...new Set(config.dependencies)];
-  config.technologies = [...new Set(config.technologies)];
-
-  return config;
-}
-
-/**
- * Detect Node.js configuration
- */
-async function detectNode(projectPath) {
-  const packageJsonPath = join(projectPath, 'package.json');
-
-  if (!existsSync(packageJsonPath)) {
-    return null;
-  }
-
-  const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf8'));
-
-  const config = {
-    language: 'javascript',
-    version: packageJson.engines?.node || null,
-    packageManager: existsSync(join(projectPath, 'yarn.lock')) ? 'yarn' :
-                    existsSync(join(projectPath, 'pnpm-lock.yaml')) ? 'pnpm' : 'npm',
-    dependencies: [],
-    technologies: [],
-    auth: null,
-    database: null,
-    hosting: null
-  };
-
-  // Extract dependencies
-  const allDeps = {
-    ...packageJson.dependencies,
-    ...packageJson.devDependencies
-  };
-
-  config.dependencies = Object.keys(allDeps);
-
-  // Detect technologies
-  if (allDeps['next']) config.technologies.push('Next.js');
-  if (allDeps['react']) config.technologies.push('React');
-  if (allDeps['@clerk/nextjs']) config.auth = 'Clerk';
-  if (allDeps['prisma']) config.database = 'Prisma';
-
-  return config;
-}
-
-/**
- * Detect .NET version from Program.cs
- */
-function detectDotNetVersion(content) {
-  if (content.includes('.NET 10') || content.includes('net10.0')) return '.NET 10';
-  if (content.includes('.NET 9') || content.includes('net9.0')) return '.NET 9';
-  if (content.includes('.NET 8') || content.includes('net8.0')) return '.NET 8';
-  return 'unknown';
-}
-
-/**
- * Detect technologies from Program.cs
- */
-function detectTechnologiesFromProgramCs(content) {
-  const techs = [];
-
-  if (content.includes('AddBlazor') || content.includes('MapBlazorHub')) {
-    techs.push('Blazor Server');
-  }
-
-  if (content.includes('AddHangfire')) {
-    techs.push('Hangfire');
-  }
-
-  if (content.includes('IChatClient') || content.includes('Microsoft.Agents')) {
-    techs.push('Microsoft Agent Framework');
-  }
-
-  if (content.includes('AddDbContext') || content.includes('UseSqlServer')) {
-    techs.push('Entity Framework Core');
-  }
-
-  if (content.includes('AddFluentUIComponents') || content.includes('FluentUI')) {
-    techs.push('Fluent UI Blazor');
-  }
-
-  if (content.includes('AddMudServices') || content.includes('MudBlazor')) {
-    techs.push('MudBlazor');
-  }
-
-  return techs;
-}
-
-/**
- * Detect authentication method
- */
-function detectAuthMethod(content) {
-  if (content.includes('AddClerk') || content.includes('Clerk')) return 'Clerk';
-  if (content.includes('AddMicrosoftIdentity') || content.includes('Entra')) return 'Microsoft Entra';
-  if (content.includes('AddAuthentication')) return 'ASP.NET Identity';
-  return null;
-}
-
-/**
- * Detect database
- */
-function detectDatabase(content) {
-  if (content.includes('UseSqlServer')) return 'SQL Server';
-  if (content.includes('UsePostgres')) return 'PostgreSQL';
-  if (content.includes('UseSqlite')) return 'SQLite';
-  if (content.includes('UseCosmos')) return 'Cosmos DB';
-  return null;
-}
-
-/**
- * Detect hosting platform
- */
-function detectHosting(content) {
-  if (content.includes('Azure') || content.includes('AddAzure')) return 'Azure';
-  if (content.includes('AWS')) return 'AWS';
-  return null;
-}
-
-/**
- * Extract NuGet packages from .csproj
- */
-function extractNuGetPackages(csprojContent) {
-  const packages = [];
-  const regex = /<PackageReference\s+Include="([^"]+)"/g;
-  let match;
-
-  while ((match = regex.exec(csprojContent)) !== null) {
-    packages.push(match[1]);
-  }
-
-  return packages;
-}