@polymorphism-tech/morph-spec 4.8.19 → 4.10.0

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;
-}

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/generator/config-generator.js

@@ -1,206 +0,0 @@
-/**
- * @fileoverview ConfigGenerator - Renders templates and generates config files
- * @module morph-spec/generator/config-generator
- */
-
-import { readFile, access, copyFile } from 'fs/promises';
-import { join, dirname } from 'path';
-import Handlebars from 'handlebars';
-import { fileURLToPath } from 'url';
-import Ajv from 'ajv';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
-/**
- * @typedef {import('../types/index.js').ProjectConfig} ProjectConfig
- * @typedef {import('../types/index.js').GeneratedConfigs} GeneratedConfigs
- */
-
-/**
- * Validation Error
- */
-export class ValidationError extends Error {
-  constructor(message, field, value) {
-    super(message);
-    this.name = 'ValidationError';
-    this.field = field;
-    this.value = value;
-  }
-}
-
-/**
- * ConfigGenerator - Generates configuration files from ProjectConfig
- * @class
- */
-export class ConfigGenerator {
-  constructor() {
-    this.projectMdTemplate = null;
-    this.configJsonTemplate = null;
-    this.ajv = new Ajv({ allErrors: true });
-  }
-
-  /**
-   * Load templates from filesystem
-   * @private
-   */
-  async loadTemplates() {
-    if (this.projectMdTemplate && this.configJsonTemplate) {
-      return; // Already loaded
-    }
-
-    const templatesDir = join(__dirname, 'templates');
-
-    const [projectMdSource, configJsonSource] = await Promise.all([
-      readFile(join(templatesDir, 'project.md.template'), 'utf-8'),
-      readFile(join(templatesDir, 'config.json.template'), 'utf-8')
-    ]);
-
-    this.projectMdTemplate = Handlebars.compile(projectMdSource);
-    this.configJsonTemplate = Handlebars.compile(configJsonSource);
-  }
-
-  /**
-   * Generate configuration files from project config
-   * @param {ProjectConfig} projectConfig - Detected project config
-   * @returns {Promise<GeneratedConfigs>}
-   */
-  async generate(projectConfig) {
-    // Load templates if not already loaded
-    await this.loadTemplates();
-
-    // Add generation timestamp
-    const context = {
-      ...projectConfig,
-      generatedAt: new Date().toISOString()
-    };
-
-    // Render templates
-    const projectMd = this.renderProjectMd(context);
-    const configJson = this.renderConfigJson(context);
-
-    // Parse config.json to object
-    const configObject = JSON.parse(configJson);
-
-    // Validate config.json (optional, but good practice)
-    // Note: agent-schema.json validation would happen here if we had the schema
-    // For now, we just ensure it's valid JSON
-
-    return {
-      projectMd,
-      configJson,
-      configObject
-    };
-  }
-
-  /**
-   * Render project.md template
-   * @param {ProjectConfig} config - Project config
-   * @returns {string} Rendered markdown
-   */
-  renderProjectMd(config) {
-    if (!this.projectMdTemplate) {
-      throw new Error('Templates not loaded. Call loadTemplates() first.');
-    }
-
-    return this.projectMdTemplate(config);
-  }
-
-  /**
-   * Render config.json template
-   * @param {ProjectConfig} config - Project config
-   * @returns {string} Rendered JSON string
-   */
-  renderConfigJson(config) {
-    if (!this.configJsonTemplate) {
-      throw new Error('Templates not loaded. Call loadTemplates() first.');
-    }
-
-    const rendered = this.configJsonTemplate(config);
-
-    // Validate that rendered output is valid JSON
-    try {
-      JSON.parse(rendered);
-      return rendered;
-    } catch (error) {
-      throw new ValidationError(
-        `Rendered config.json is not valid JSON: ${error.message}`,
-        'configJson',
-        rendered
-      );
-    }
-  }
-
-  /**
-   * Validate config.json against agent schema
-   * @param {string} configJson - JSON string
-   * @returns {boolean} True if valid
-   * @throws {ValidationError} If validation fails
-   */
-  validateConfigJson(configJson) {
-    // Parse JSON
-    let parsed;
-    try {
-      parsed = JSON.parse(configJson);
-    } catch (error) {
-      throw new ValidationError(
-        `Invalid JSON: ${error.message}`,
-        'configJson',
-        configJson
-      );
-    }
-
-    // Basic validation - ensure required fields exist
-    const requiredFields = ['name', 'type', 'description', 'stack', 'architecture'];
-    for (const field of requiredFields) {
-      if (!parsed[field]) {
-        throw new ValidationError(
-          `Missing required field: ${field}`,
-          field,
-          parsed
-        );
-      }
-    }
-
-    // Validate stack.backend is required
-    if (!parsed.stack || !parsed.stack.backend) {
-      throw new ValidationError(
-        'stack.backend is required',
-        'stack.backend',
-        parsed
-      );
-    }
-
-    return true;
-  }
-
-  /**
-   * Backup existing configuration files
-   * @param {string} cwd - Current working directory
-   * @returns {Promise<void>}
-   */
-  async backupExisting(cwd) {
-    const projectMdPath = join(cwd, '.morph', 'project.md');
-    const configJsonPath = join(cwd, '.morph', 'config', 'config.json');
-
-    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
-
-    // Backup project.md if exists
-    try {
-      await access(projectMdPath);
-      const backupPath = join(cwd, '.morph', `project.md.${timestamp}.backup`);
-      await copyFile(projectMdPath, backupPath);
-    } catch (error) {
-      // File doesn't exist, no need to backup
-    }
-
-    // Backup config.json if exists
-    try {
-      await access(configJsonPath);
-      const backupPath = join(cwd, '.morph', 'config', `config.json.${timestamp}.backup`);
-      await copyFile(configJsonPath, backupPath);
-    } catch (error) {
-      // File doesn't exist, no need to backup
-    }
-  }
-}

package/src/generator/templates/config.json.template

@@ -1,40 +0,0 @@
-{
-  "$schema": "../schema/agent-schema.json",
-  "name": "{{name}}",
-  "type": "{{type}}",
-  "description": "{{description}}",
-  "stack": {
-    {{#if stack.frontend}}
-    "frontend": {
-      "tech": "{{stack.frontend.tech}}",
-      "version": "{{stack.frontend.version}}"{{#if stack.frontend.details}},
-      "details": "{{stack.frontend.details}}"{{/if}}
-    },
-    {{/if}}
-    "backend": {
-      "tech": "{{stack.backend.tech}}",
-      "version": "{{stack.backend.version}}"{{#if stack.backend.details}},
-      "details": "{{stack.backend.details}}"{{/if}}
-    }{{#if stack.database}},
-    "database": {
-      "tech": "{{stack.database.tech}}",
-      "version": "{{stack.database.version}}"{{#if stack.database.details}},
-      "details": "{{stack.database.details}}"{{/if}}
-    }{{/if}}{{#if stack.hosting}},
-    "hosting": "{{stack.hosting}}"{{/if}}
-  },
-  "architecture": "{{architecture}}",
-  "conventions": "{{conventions}}",
-  "infrastructure": {
-    "azure": {{hasAzure}},
-    "docker": {{hasDocker}},
-    "devops": {{hasDevOps}}
-  }{{#if repository}},
-  "repository": "{{repository}}"{{/if}},
-  "meta": {
-    "generatedBy": "morph-spec-cli",
-    "generatedAt": "{{generatedAt}}",
-    "llmConfidence": {{confidence}},
-    "autoDetected": true
-  }
-}

package/src/generator/templates/project.md.template

@@ -1,67 +0,0 @@
-# {{name}}
-
-> {{description}}
-
-## Stack
-
-| Component | Technology |
-|-----------|------------|
-{{#if stack.frontend}}
-| **Frontend** | {{stack.frontend.tech}} {{stack.frontend.version}}{{#if stack.frontend.details}} - {{stack.frontend.details}}{{/if}} |
-{{/if}}
-| **Backend** | {{stack.backend.tech}} {{stack.backend.version}}{{#if stack.backend.details}} - {{stack.backend.details}}{{/if}} |
-{{#if stack.database}}
-| **Database** | {{stack.database.tech}} {{stack.database.version}}{{#if stack.database.details}} - {{stack.database.details}}{{/if}} |
-{{/if}}
-{{#if stack.hosting}}
-| **Hosting** | {{stack.hosting}} |
-{{/if}}
-
-## Architecture
-
-**Pattern:** {{architecture}}
-
-{{projectStructure}}
-
-## Code Conventions
-
-{{conventions}}
-
-## Infrastructure
-
-{{#if hasAzure}}
-- ✅ **Azure** - Uses Azure infrastructure (Bicep files detected)
-{{else}}
-- ❌ **Azure** - No Azure resources detected
-{{/if}}
-
-{{#if hasDocker}}
-- ✅ **Docker** - Containerized (Dockerfile/docker-compose.yml detected)
-{{else}}
-- ❌ **Docker** - Not containerized
-{{/if}}
-
-{{#if hasDevOps}}
-- ✅ **CI/CD** - Pipelines detected
-{{else}}
-- ❌ **CI/CD** - No pipelines detected
-{{/if}}
-
-{{#if repository}}
-## Repository
-
-{{repository}}
-{{/if}}
-
-{{#if warnings.length}}
-## ⚠️ Warnings
-
-{{#each warnings}}
-- {{this}}
-{{/each}}
-{{/if}}
-
----
-
-*Auto-generated by MORPH-SPEC CLI on {{generatedAt}}*
-*LLM Confidence: {{confidence}}%*