@polymorphism-tech/morph-spec 4.8.19 → 4.9.0

package/src/core/orchestrator.js

@@ -1,171 +0,0 @@
-/**
- * @fileoverview AutoContextOrchestrator - Main orchestrator for CLI auto-detection
- * @module morph-spec/orchestrator
- */
-
-import chalk from 'chalk';
-import { ProjectScanner } from '../scanner/project-scanner.js';
-import { ContextSanitizer } from '../sanitizer/context-sanitizer.js';
-import { ConfigGenerator } from '../generator/config-generator.js';
-import { UserReview } from '../ui/user-review.js';
-import { InteractiveWizard } from '../ui/interactive-wizard.js';
-import { FileWriter } from '../writer/file-writer.js';
-import { readFile, access } from 'fs/promises';
-import { join } from 'path';
-
-/**
- * @typedef {import('../types/index.js').GeneratedConfigs} GeneratedConfigs
- */
-
-/**
- * AutoContextOrchestrator - Orchestrates the complete auto-detection flow
- * @class
- */
-export class AutoContextOrchestrator {
-  constructor() {
-    this.scanner = new ProjectScanner();
-    this.sanitizer = new ContextSanitizer();
-    this.configGenerator = new ConfigGenerator();
-    this.userReview = new UserReview();
-    this.wizard = new InteractiveWizard();
-    this.fileWriter = new FileWriter();
-
-    // Handle Ctrl+C gracefully
-    this.setupSignalHandlers();
-  }
-
-  /**
-   * Execute the complete auto-detection flow
-   * @param {string} cwd - Current working directory
-   * @param {Object} [options] - Orchestration options
-   * @param {boolean} [options.skipReview] - Skip user review (auto-approve)
-   * @returns {Promise<{success: boolean, configs: GeneratedConfigs|null}>}
-   */
-  async execute(cwd, options = {}) {
-    const {
-      skipReview = false,
-    } = options;
-
-    try {
-      console.log(chalk.bold.cyan('\n🔍 MORPH-SPEC Auto Context Detection\n'));
-
-      let projectConfig;
-
-      // Use interactive wizard (LLM invocation not implemented; wizard provides all context)
-      console.log(chalk.yellow('  Using interactive wizard mode\n'));
-      projectConfig = await this.wizard.run();
-
-      // Step 2: Generate configs
-      console.log(chalk.dim('  [4/6] Generating configuration files...'));
-      const configs = await this.configGenerator.generate(projectConfig);
-
-      // Step 3: User review (unless skipped)
-      let finalConfigs = configs;
-
-      if (!skipReview) {
-        console.log(chalk.dim('  [5/6] Requesting user approval...'));
-
-        // Check if updating existing configs
-        const existingConfigs = await this.readExistingConfigs(cwd);
-
-        const approvalResponse = await this.userReview.promptForApproval(
-          configs,
-          projectConfig,
-          existingConfigs
-        );
-
-        if (approvalResponse.action === 'cancel') {
-          console.log(chalk.yellow('\n❌ Operation canceled by user\n'));
-          console.log(chalk.dim(`   Reason: ${approvalResponse.cancelReason || 'User canceled'}\n`));
-          return { success: false, configs: null };
-        }
-
-        if (approvalResponse.editedConfigs) {
-          finalConfigs = approvalResponse.editedConfigs;
-        }
-      } else {
-        console.log(chalk.dim('  [5/6] Skipping user review (auto-approve)'));
-      }
-
-      // Step 4: Save configs
-      console.log(chalk.dim('  [6/6] Saving configuration files...'));
-
-      // Backup existing configs if they exist
-      await this.configGenerator.backupExisting(cwd);
-
-      // Write new configs
-      await this.fileWriter.save(cwd, finalConfigs);
-
-      console.log(chalk.bold.green('🎉 Auto-detection complete!\n'));
-
-      return { success: true, configs: finalConfigs };
-    } catch (error) {
-      console.log(chalk.bold.red('\n❌ Auto-detection failed\n'));
-      console.log(chalk.red(`   Error: ${error.message}\n`));
-
-      if (error.stack && process.env.DEBUG) {
-        console.log(chalk.dim(error.stack));
-      }
-
-      return { success: false, configs: null };
-    }
-  }
-
-  /**
-   * Read existing configs (if they exist)
-   * @param {string} cwd - Current working directory
-   * @returns {Promise<Object|null>} Existing configs or null
-   */
-  async readExistingConfigs(cwd) {
-    try {
-      const projectMdPath = join(cwd, '.morph', 'project.md');
-      const configJsonPath = join(cwd, '.morph', 'config', 'config.json');
-
-      const [projectMdExists, configJsonExists] = await Promise.all([
-        this.fileExists(projectMdPath),
-        this.fileExists(configJsonPath)
-      ]);
-
-      if (!projectMdExists && !configJsonExists) {
-        return null; // No existing configs
-      }
-
-      const [projectMd, configJson] = await Promise.all([
-        projectMdExists ? readFile(projectMdPath, 'utf-8') : null,
-        configJsonExists ? readFile(configJsonPath, 'utf-8') : null
-      ]);
-
-      return { projectMd, configJson };
-    } catch (error) {
-      return null; // Error reading configs, treat as non-existent
-    }
-  }
-
-  /**
-   * Check if file exists
-   * @param {string} filepath - File path
-   * @returns {Promise<boolean>}
-   */
-  async fileExists(filepath) {
-    try {
-      await access(filepath);
-      return true;
-    } catch {
-      return false;
-    }
-  }
-
-  /**
-   * Setup signal handlers for graceful shutdown
-   */
-  setupSignalHandlers() {
-    const handleExit = () => {
-      console.log(chalk.yellow('\n\n⚠️  Operation interrupted by user (Ctrl+C)\n'));
-      console.log(chalk.dim('   No files were modified\n'));
-      process.exit(0);
-    };
-
-    process.on('SIGINT', handleExit);
-    process.on('SIGTERM', handleExit);
-  }
-}

package/src/core/registry/command-registry.js

@@ -1,28 +0,0 @@
-/**
- * Command Registry — DEPRECATED
- *
- * This module is no longer used. CLI commands are registered directly
- * in bin/morph-spec.js via Commander.js. This file is kept as an empty
- * stub to prevent import errors from any remaining references.
- *
- * @module command-registry
- * @deprecated
- */
-
-export const commandMetadata = {};
-
-export async function loadCommand(commandName) {
-  throw new Error(`Command registry is deprecated. Use bin/morph-spec.js directly.`);
-}
-
-export function getAllCommandNames() {
-  return [];
-}
-
-export function getCommandsByCategory() {
-  return [];
-}
-
-export function getAllCategories() {
-  return [];
-}

package/src/core/registry/index.js

@@ -1,8 +0,0 @@
-/**
- * Core Registry System
- *
- * Auto-discovery for commands and validators.
- */
-
-export * from './command-registry.js';
-export * from './validator-registry.js';

package/src/core/registry/validator-registry.js

@@ -1,204 +0,0 @@
-/**
- * Validator Registry - Technology-Based Auto-Discovery
- *
- * Maps validator types to their modules for dynamic loading.
- * Organized by technology (blazor, css, architecture, etc.)
- *
- * @module validator-registry
- */
-
-/**
- * Validator Metadata Registry
- *
- * Technology-scoped validator discovery.
- */
-export const validatorMetadata = {
-  // Blazor Validators
-  'blazor': {
-    technology: 'blazor',
-    validators: [
-      {
-        id: 'blazor-validator',
-        name: 'Blazor Patterns Validator',
-        description: 'Validates Fluent UI Blazor patterns and components',
-        module: () => import('../../lib/validators/blazor/blazor-validator.js'),
-      },
-      {
-        id: 'blazor-state',
-        name: 'Blazor State Validator',
-        description: 'Validates Blazor state management patterns',
-        module: () => import('../../lib/validators/blazor/blazor-state-validator.js'),
-      },
-      {
-        id: 'blazor-concurrency',
-        name: 'Blazor Concurrency Analyzer',
-        description: 'Analyzes Blazor concurrency and DbContext issues',
-        module: () => import('../../lib/validators/blazor/blazor-concurrency-analyzer.js'),
-      },
-    ],
-  },
-
-  // CSS Validators
-  'css': {
-    technology: 'css',
-    validators: [
-      {
-        id: 'css-validator',
-        name: 'CSS Validator',
-        description: 'Validates CSS classes and design system compliance',
-        module: () => import('../../lib/validators/css/css-validator.js'),
-      },
-    ],
-  },
-
-  // Architecture Validators
-  'architecture': {
-    technology: 'architecture',
-    validators: [
-      {
-        id: 'architecture-validator',
-        name: 'Architecture Validator',
-        description: 'Validates architectural patterns (DI, CQRS, etc.)',
-        module: () => import('../../lib/validators/architecture/architecture-validator.js'),
-      },
-    ],
-  },
-
-  // Design System Validators
-  'design-system': {
-    technology: 'design-system',
-    validators: [
-      {
-        id: 'design-system-validator',
-        name: 'Design System Validator',
-        description: 'Validates design system compliance',
-        module: () => import('../../lib/validators/design-system/design-system-validator.js'),
-      },
-    ],
-  },
-
-  // Content Validators
-  'content': {
-    technology: 'content',
-    validators: [
-      {
-        id: 'content-validator',
-        name: 'Content Validator',
-        description: 'Validates content and specification format',
-        module: () => import('../../lib/validators/content/content-validator.js'),
-      },
-    ],
-  },
-
-  // Contract Validators
-  'contracts': {
-    technology: 'contracts',
-    validators: [
-      {
-        id: 'contract-compliance-validator',
-        name: 'Contract Compliance Validator',
-        description: 'Validates API contract compliance',
-        module: () => import('../../lib/validators/contracts/contract-compliance-validator.js'),
-      },
-    ],
-  },
-
-  // Package Validators
-  'packages': {
-    technology: 'packages',
-    validators: [
-      {
-        id: 'package-validator',
-        name: 'Package Validator',
-        description: 'Validates package dependencies and versions',
-        module: () => import('../../lib/validators/packages/package-validator.js'),
-      },
-    ],
-  },
-
-  // UI Validators
-  'ui': {
-    technology: 'ui',
-    validators: [
-      {
-        id: 'ui-contrast-validator',
-        name: 'UI Contrast Validator',
-        description: 'Validates UI contrast and accessibility',
-        module: () => import('../../lib/validators/ui/ui-contrast-validator.js'),
-      },
-    ],
-  },
-};
-
-/**
- * Load validator by ID
- *
- * @param {string} validatorId - Validator ID (e.g., 'blazor-validator')
- * @returns {Promise<Object>} Validator module
- */
-export async function loadValidator(validatorId) {
-  for (const techMeta of Object.values(validatorMetadata)) {
-    const validator = techMeta.validators.find(v => v.id === validatorId);
-    if (validator) {
-      return await validator.module();
-    }
-  }
-
-  throw new Error(`Validator not found: ${validatorId}`);
-}
-
-/**
- * Load all validators for a technology
- *
- * @param {string} technology - Technology name (e.g., 'blazor', 'css')
- * @returns {Promise<Object[]>} Array of validator modules
- */
-export async function loadValidatorsForTechnology(technology) {
-  const techMeta = validatorMetadata[technology];
-
-  if (!techMeta) {
-    throw new Error(`No validators found for technology: ${technology}`);
-  }
-
-  return await Promise.all(
-    techMeta.validators.map(v => v.module())
-  );
-}
-
-/**
- * Get all validator IDs
- *
- * @returns {string[]} Array of validator IDs
- */
-export function getAllValidatorIds() {
-  const ids = [];
-  for (const techMeta of Object.values(validatorMetadata)) {
-    ids.push(...techMeta.validators.map(v => v.id));
-  }
-  return ids;
-}
-
-/**
- * Get all technologies
- *
- * @returns {string[]} Array of technology names
- */
-export function getAllTechnologies() {
-  return Object.keys(validatorMetadata);
-}
-
-/**
- * Get validator metadata by ID
- *
- * @param {string} validatorId - Validator ID
- * @returns {Object|null} Validator metadata or null
- */
-export function getValidatorMetadata(validatorId) {
-  for (const techMeta of Object.values(validatorMetadata)) {
-    const validator = techMeta.validators.find(v => v.id === validatorId);
-    if (validator) {
-      return { ...validator, technology: techMeta.technology };
-    }
-  }
-  return null;
-}

package/src/core/templates/template-validator.js

@@ -1,296 +0,0 @@
-/**
- * Template Validator - Validates Handlebars templates
- * Checks for:
- * - Required placeholders are present
- * - No deprecated pre-computed variables ({FEATURE_NAME_PASCAL})
- * - Valid Handlebars syntax
- * - Proper helper usage
- */
-
-import { readFileSync } from 'fs';
-import { getTemplateById, getAllTemplates } from './template-registry.js';
-
-/**
- * Deprecated placeholder patterns (v1.0 pre-computed variables)
- */
-const DEPRECATED_PATTERNS = [
-  { pattern: /\{\{FEATURE_NAME_PASCAL\}\}/g, replacement: '{{pascalCase FEATURE_NAME}}' },
-  { pattern: /\{\{FEATURE_NAME_CAMEL\}\}/g, replacement: '{{camelCase FEATURE_NAME}}' },
-  { pattern: /\{\{FEATURE_NAME_SNAKE\}\}/g, replacement: '{{snakeCase FEATURE_NAME}}' },
-  { pattern: /\{\{FEATURE_NAME_UPPER_SNAKE\}\}/g, replacement: '{{upperSnakeCase FEATURE_NAME}}' },
-  { pattern: /\{\{FEATURE_NAME_TITLE\}\}/g, replacement: '{{titleCase FEATURE_NAME}}' },
-  { pattern: /\{\{FEATURE_NAME_KEBAB\}\}/g, replacement: '{{kebabCase FEATURE_NAME}}' },
-];
-
-/**
- * Old template syntax (non-Handlebars)
- */
-const OLD_SYNTAX_PATTERNS = [
-  { pattern: /\{Feature\}/g, description: 'Old {Feature} syntax (use {{pascalCase FEATURE_NAME}})' },
-  { pattern: /\{feature\}/g, description: 'Old {feature} syntax (use {{kebabCase FEATURE_NAME}})' },
-];
-
-/**
- * Validation result
- */
-class ValidationResult {
-  constructor(templateId, templatePath) {
-    this.templateId = templateId;
-    this.templatePath = templatePath;
-    this.valid = true;
-    this.errors = [];
-    this.warnings = [];
-    this.info = [];
-  }
-
-  addError(message) {
-    this.errors.push(message);
-    this.valid = false;
-  }
-
-  addWarning(message) {
-    this.warnings.push(message);
-  }
-
-  addInfo(message) {
-    this.info.push(message);
-  }
-
-  get hasIssues() {
-    return this.errors.length > 0 || this.warnings.length > 0;
-  }
-}
-
-/**
- * Validates a single template
- * @param {string} templateId - Template ID
- * @param {string} projectPath - Project root path
- * @returns {ValidationResult}
- */
-export function validateTemplate(templateId, projectPath = process.cwd()) {
-  const template = getTemplateById(templateId, projectPath);
-
-  if (!template) {
-    const result = new ValidationResult(templateId, null);
-    result.addError(`Template not found: ${templateId}`);
-    return result;
-  }
-
-  const result = new ValidationResult(templateId, template.path);
-
-  // Read template content
-  let content;
-  try {
-    const fullPath = `${projectPath}/framework/templates/${template.path}`;
-    content = readFileSync(fullPath, 'utf-8');
-  } catch (error) {
-    result.addError(`Failed to read template: ${error.message}`);
-    return result;
-  }
-
-  // Check for deprecated pre-computed variables
-  for (const { pattern, replacement } of DEPRECATED_PATTERNS) {
-    const matches = content.match(pattern);
-    if (matches) {
-      result.addError(
-        `Deprecated placeholder found: ${matches[0]} (use ${replacement} instead)`
-      );
-    }
-  }
-
-  // Check for old non-Handlebars syntax
-  for (const { pattern, description } of OLD_SYNTAX_PATTERNS) {
-    const matches = content.match(pattern);
-    if (matches) {
-      const count = matches.length;
-      result.addWarning(
-        `${count} occurrence(s) of old syntax: ${description}`
-      );
-    }
-  }
-
-  // Check for required placeholders if specified
-  if (template.placeholders && template.placeholders.length > 0) {
-    const missingPlaceholders = [];
-
-    for (const placeholder of template.placeholders) {
-      // Check for exact placeholder or helper usage
-      const exactMatch = new RegExp(`\\{\\{${placeholder}\\}\\}`, 'g');
-      const helperMatch = new RegExp(`\\{\\{\\w+\\s+${placeholder}\\}\\}`, 'g');
-
-      if (!exactMatch.test(content) && !helperMatch.test(content)) {
-        missingPlaceholders.push(placeholder);
-      }
-    }
-
-    if (missingPlaceholders.length > 0) {
-      result.addWarning(
-        `Template declares placeholders but they're not used: ${missingPlaceholders.join(', ')}`
-      );
-    }
-  }
-
-  // Check for balanced Handlebars blocks
-  const openBlocks = (content.match(/\{\{#\w+/g) || []).length;
-  const closeBlocks = (content.match(/\{\{\/\w+/g) || []).length;
-
-  if (openBlocks !== closeBlocks) {
-    result.addError(
-      `Unbalanced Handlebars blocks: ${openBlocks} opening, ${closeBlocks} closing`
-    );
-  }
-
-  // Info: Count Handlebars placeholders
-  const placeholderMatches = content.match(/\{\{[^}]+\}\}/g) || [];
-  const uniquePlaceholders = [...new Set(placeholderMatches)];
-  result.addInfo(`Found ${uniquePlaceholders.length} unique Handlebars expressions`);
-
-  // Info: Check if template uses helpers
-  const helperMatches = content.match(/\{\{(pascalCase|camelCase|snakeCase|titleCase|kebabCase|upperSnakeCase|pluralize|singularize|formatDate|uppercase|lowercase|capitalize|trim|replace|concat|substr|startsWith|endsWith|contains|length|add|subtract|multiply|divide|mod|round|join|first|last|slice|now|year|default|json)/g) || [];
-  if (helperMatches.length > 0) {
-    const uniqueHelpers = [...new Set(helperMatches.map(m => m.replace('{{', '')))];
-    result.addInfo(`Uses helpers: ${uniqueHelpers.join(', ')}`);
-  }
-
-  return result;
-}
-
-/**
- * Validates all templates
- * @param {string} projectPath - Project root path
- * @param {Object} options - Validation options
- * @returns {Array<ValidationResult>}
- */
-export function validateAllTemplates(projectPath = process.cwd(), options = {}) {
-  const {
-    skipDeprecated = true,
-    category = null,
-    technology = null,
-  } = options;
-
-  const templates = getAllTemplates(projectPath);
-  const results = [];
-
-  for (const template of templates) {
-    // Skip deprecated if requested
-    if (skipDeprecated && template.deprecated) {
-      continue;
-    }
-
-    // Filter by category if specified
-    if (category && template.category !== category) {
-      continue;
-    }
-
-    // Filter by technology if specified
-    if (technology && template.technology !== technology) {
-      continue;
-    }
-
-    const result = validateTemplate(template.id, projectPath);
-    results.push(result);
-  }
-
-  return results;
-}
-
-/**
- * Generates a validation summary
- * @param {Array<ValidationResult>} results - Validation results
- * @returns {Object}
- */
-export function summarizeValidation(results) {
-  const summary = {
-    total: results.length,
-    valid: 0,
-    hasErrors: 0,
-    hasWarnings: 0,
-    errors: [],
-    warnings: [],
-  };
-
-  for (const result of results) {
-    if (result.valid && result.warnings.length === 0) {
-      summary.valid++;
-    }
-
-    if (result.errors.length > 0) {
-      summary.hasErrors++;
-      summary.errors.push({
-        templateId: result.templateId,
-        errors: result.errors,
-      });
-    }
-
-    if (result.warnings.length > 0) {
-      summary.hasWarnings++;
-      summary.warnings.push({
-        templateId: result.templateId,
-        warnings: result.warnings,
-      });
-    }
-  }
-
-  return summary;
-}
-
-/**
- * Formats validation results for display
- * @param {Array<ValidationResult>} results - Validation results
- * @param {Object} options - Display options
- * @returns {string}
- */
-export function formatValidationResults(results, options = {}) {
-  const { showInfo = false, showValid = false } = options;
-
-  let output = '';
-  let validCount = 0;
-  let errorCount = 0;
-  let warningCount = 0;
-
-  for (const result of results) {
-    if (result.valid && result.warnings.length === 0) {
-      validCount++;
-      if (showValid) {
-        output += `✅ ${result.templateId}\n`;
-      }
-      continue;
-    }
-
-    if (result.errors.length > 0) {
-      errorCount++;
-      output += `\n❌ ${result.templateId}\n`;
-      output += `   Path: ${result.templatePath}\n`;
-      for (const error of result.errors) {
-        output += `   ERROR: ${error}\n`;
-      }
-    }
-
-    if (result.warnings.length > 0) {
-      warningCount++;
-      if (result.errors.length === 0) {
-        output += `\n⚠️  ${result.templateId}\n`;
-        output += `   Path: ${result.templatePath}\n`;
-      }
-      for (const warning of result.warnings) {
-        output += `   WARNING: ${warning}\n`;
-      }
-    }
-
-    if (showInfo && result.info.length > 0) {
-      for (const info of result.info) {
-        output += `   INFO: ${info}\n`;
-      }
-    }
-  }
-
-  // Summary
-  output += `\n${'='.repeat(60)}\n`;
-  output += `SUMMARY:\n`;
-  output += `  Total templates: ${results.length}\n`;
-  output += `  ✅ Valid: ${validCount}\n`;
-  output += `  ❌ Errors: ${errorCount}\n`;
-  output += `  ⚠️  Warnings: ${warningCount}\n`;
-
-  return output;
-}