@polymorphism-tech/morph-spec 3.0.1 → 3.2.0

package/src/commands/validate-phase.js

@@ -1,221 +1,221 @@
-/**
- * MORPH-SPEC Phase Validator Command
- *
- * Validates that required previous phases have been completed before advancing.
- * Prevents skipping phases accidentally.
- *
- * Usage:
- *   morph-spec validate-phase <feature-name> <target-phase>
- *
- * Example:
- *   morph-spec validate-phase scheduled-reports implement
- */
-
-import fs from 'fs';
-import path from 'path';
-import chalk from 'chalk';
-import { loadState, getFeature } from '../lib/state-manager.js';
-
-// Phase definitions with requirements
-const PHASES = {
-  'proposal': {
-    order: 0,
-    name: 'FASE 0: PROPOSAL',
-    requiredOutputs: [],
-    description: 'Initial proposal and agent detection'
-  },
-  'setup': {
-    order: 1,
-    name: 'FASE 1: SETUP',
-    requiredOutputs: ['proposal.md'],
-    description: 'Load context and standards'
-  },
-  'uiux': {
-    order: 2,
-    name: 'FASE 1.5: UI/UX DESIGN',
-    requiredOutputs: ['proposal.md'],
-    optionalOutputs: ['ui-design-system.md', 'ui-mockups.md', 'ui-components.md', 'ui-flows.md'],
-    description: 'UI/UX design (conditional - only if frontend)',
-    optional: true
-  },
-  'design': {
-    order: 3,
-    name: 'FASE 2: DESIGN',
-    requiredOutputs: ['proposal.md'],
-    description: 'Technical specification and contracts'
-  },
-  'clarify': {
-    order: 4,
-    name: 'FASE 3: CLARIFY',
-    requiredOutputs: ['proposal.md', 'spec.md'],
-    description: 'Clarify ambiguities and edge cases'
-  },
-  'tasks': {
-    order: 5,
-    name: 'FASE 4: TASKS',
-    requiredOutputs: ['proposal.md', 'spec.md'],
-    description: 'Break down into executable tasks'
-  },
-  'implement': {
-    order: 6,
-    name: 'FASE 5: IMPLEMENT',
-    requiredOutputs: ['proposal.md', 'spec.md'],
-    description: 'Execute tasks and implement code'
-  },
-  'sync': {
-    order: 7,
-    name: 'FASE 6: SYNC',
-    requiredOutputs: ['proposal.md', 'spec.md', 'decisions.md'],
-    description: 'Sync decisions to project standards',
-    optional: true
-  }
-};
-
-/**
- * Check if output file exists
- */
-function checkOutput(featurePath, outputFile) {
-  const filePath = path.join(featurePath, outputFile);
-  return fs.existsSync(filePath);
-}
-
-/**
- * Validate phase requirements
- */
-function validatePhase(featureName, targetPhase) {
-  const featurePath = path.join(process.cwd(), '.morph/project/outputs', featureName);
-
-  // Check if feature directory exists
-  if (!fs.existsSync(featurePath)) {
-    return {
-      valid: false,
-      error: `Feature directory not found: ${featurePath}`,
-      suggestion: `Run 'morph-spec state set ${featureName} phase proposal' to start`,
-      missingOutputs: [],
-      phase: null
-    };
-  }
-
-  // Get target phase definition
-  const phaseDefinition = PHASES[targetPhase];
-  if (!phaseDefinition) {
-    return {
-      valid: false,
-      error: `Unknown phase: ${targetPhase}`,
-      validPhases: Object.keys(PHASES),
-      missingOutputs: [],
-      phase: null
-    };
-  }
-
-  // Check required outputs
-  const missingOutputs = [];
-  for (const output of phaseDefinition.requiredOutputs) {
-    if (!checkOutput(featurePath, output)) {
-      missingOutputs.push(output);
-    }
-  }
-
-  // Check state.json for current phase
-  let stateWarning = null;
-  try {
-    const feature = getFeature(featureName);
-    if (feature) {
-      const currentPhaseOrder = PHASES[feature.phase]?.order ?? -1;
-      const targetPhaseOrder = phaseDefinition.order;
-
-      if (targetPhaseOrder > currentPhaseOrder + 1) {
-        stateWarning = `Skipping phases: current is '${feature.phase}' (order ${currentPhaseOrder}), target is '${targetPhase}' (order ${targetPhaseOrder})`;
-      }
-    }
-  } catch {
-    // State file may not exist, that's OK
-  }
-
-  // Special validation: if target is 'implement', check tasks exist in state
-  if (targetPhase === 'implement') {
-    try {
-      const feature = getFeature(featureName);
-      if (feature && (!feature.tasks || feature.tasks.total === 0)) {
-        missingOutputs.push('tasks in state.json (run morph-spec task to add tasks)');
-      }
-    } catch {
-      // State file may not exist
-    }
-  }
-
-  return {
-    valid: missingOutputs.length === 0,
-    error: null,
-    missingOutputs,
-    phase: phaseDefinition,
-    featurePath,
-    stateWarning
-  };
-}
-
-/**
- * Main command handler
- */
-export async function validatePhaseCommand(feature, phase, options = {}) {
-  console.log(chalk.cyan('\n╔════════════════════════════════════════════════╗'));
-  console.log(chalk.cyan('║     MORPH-SPEC PHASE VALIDATOR                 ║'));
-  console.log(chalk.cyan('╚════════════════════════════════════════════════╝\n'));
-
-  const result = validatePhase(feature, phase);
-
-  console.log(chalk.gray('Feature:'), feature);
-  console.log(chalk.gray('Target Phase:'), result.phase ? result.phase.name : phase);
-
-  if (result.phase) {
-    console.log(chalk.gray('Description:'), result.phase.description);
-  }
-
-  if (result.stateWarning) {
-    console.log(chalk.yellow(`\n⚠️  Warning: ${result.stateWarning}`));
-  }
-
-  if (result.valid) {
-    console.log(chalk.green('\n✓ VALIDATION PASSED'));
-    console.log(chalk.green('  All required outputs are present.'));
-    console.log(chalk.green(`  Safe to proceed to ${result.phase.name}\n`));
-
-    if (options.verbose) {
-      console.log(chalk.gray('Required outputs found:'));
-      result.phase.requiredOutputs.forEach(output => {
-        console.log(chalk.gray(`  ✓ ${output}`));
-      });
-      console.log('');
-    }
-  } else {
-    console.log(chalk.red('\n✗ VALIDATION FAILED'));
-
-    if (result.error) {
-      console.log(chalk.red(`  Error: ${result.error}\n`));
-
-      if (result.suggestion) {
-        console.log(chalk.yellow(`  Suggestion: ${result.suggestion}\n`));
-      }
-
-      if (result.validPhases) {
-        console.log(chalk.yellow('Valid phases:'));
-        result.validPhases.forEach(p => {
-          const def = PHASES[p];
-          console.log(chalk.gray(`  - ${p}: ${def.name}${def.optional ? ' (optional)' : ''}`));
-        });
-      }
-    } else {
-      console.log(chalk.red('  Missing required outputs:'));
-      result.missingOutputs.forEach(output => {
-        console.log(chalk.gray(`  - ${output}`));
-      });
-
-      console.log(chalk.yellow(`\n  Action required:`));
-      console.log(chalk.yellow(`  Complete the missing outputs before advancing to ${result.phase.name}`));
-    }
-    console.log('');
-    process.exit(1);
-  }
-}
-
-export { PHASES, validatePhase };
+/**
+ * MORPH-SPEC Phase Validator Command
+ *
+ * Validates that required previous phases have been completed before advancing.
+ * Prevents skipping phases accidentally.
+ *
+ * Usage:
+ *   morph-spec validate-phase <feature-name> <target-phase>
+ *
+ * Example:
+ *   morph-spec validate-phase scheduled-reports implement
+ */
+
+import fs from 'fs';
+import path from 'path';
+import chalk from 'chalk';
+import { loadState, getFeature } from '../lib/state-manager.js';
+
+// Phase definitions with requirements
+const PHASES = {
+  'proposal': {
+    order: 0,
+    name: 'FASE 0: PROPOSAL',
+    requiredOutputs: [],
+    description: 'Initial proposal and agent detection'
+  },
+  'setup': {
+    order: 1,
+    name: 'FASE 1: SETUP',
+    requiredOutputs: ['proposal.md'],
+    description: 'Load context and standards'
+  },
+  'uiux': {
+    order: 2,
+    name: 'FASE 1.5: UI/UX DESIGN',
+    requiredOutputs: ['proposal.md'],
+    optionalOutputs: ['ui-design-system.md', 'ui-mockups.md', 'ui-components.md', 'ui-flows.md'],
+    description: 'UI/UX design (conditional - only if frontend)',
+    optional: true
+  },
+  'design': {
+    order: 3,
+    name: 'FASE 2: DESIGN',
+    requiredOutputs: ['proposal.md'],
+    description: 'Technical specification and contracts'
+  },
+  'clarify': {
+    order: 4,
+    name: 'FASE 3: CLARIFY',
+    requiredOutputs: ['proposal.md', 'spec.md'],
+    description: 'Clarify ambiguities and edge cases'
+  },
+  'tasks': {
+    order: 5,
+    name: 'FASE 4: TASKS',
+    requiredOutputs: ['proposal.md', 'spec.md'],
+    description: 'Break down into executable tasks'
+  },
+  'implement': {
+    order: 6,
+    name: 'FASE 5: IMPLEMENT',
+    requiredOutputs: ['proposal.md', 'spec.md'],
+    description: 'Execute tasks and implement code'
+  },
+  'sync': {
+    order: 7,
+    name: 'FASE 6: SYNC',
+    requiredOutputs: ['proposal.md', 'spec.md', 'decisions.md'],
+    description: 'Sync decisions to project standards',
+    optional: true
+  }
+};
+
+/**
+ * Check if output file exists
+ */
+function checkOutput(featurePath, outputFile) {
+  const filePath = path.join(featurePath, outputFile);
+  return fs.existsSync(filePath);
+}
+
+/**
+ * Validate phase requirements
+ */
+function validatePhase(featureName, targetPhase) {
+  const featurePath = path.join(process.cwd(), '.morph/project/outputs', featureName);
+
+  // Check if feature directory exists
+  if (!fs.existsSync(featurePath)) {
+    return {
+      valid: false,
+      error: `Feature directory not found: ${featurePath}`,
+      suggestion: `Run 'morph-spec state set ${featureName} phase proposal' to start`,
+      missingOutputs: [],
+      phase: null
+    };
+  }
+
+  // Get target phase definition
+  const phaseDefinition = PHASES[targetPhase];
+  if (!phaseDefinition) {
+    return {
+      valid: false,
+      error: `Unknown phase: ${targetPhase}`,
+      validPhases: Object.keys(PHASES),
+      missingOutputs: [],
+      phase: null
+    };
+  }
+
+  // Check required outputs
+  const missingOutputs = [];
+  for (const output of phaseDefinition.requiredOutputs) {
+    if (!checkOutput(featurePath, output)) {
+      missingOutputs.push(output);
+    }
+  }
+
+  // Check state.json for current phase
+  let stateWarning = null;
+  try {
+    const feature = getFeature(featureName);
+    if (feature) {
+      const currentPhaseOrder = PHASES[feature.phase]?.order ?? -1;
+      const targetPhaseOrder = phaseDefinition.order;
+
+      if (targetPhaseOrder > currentPhaseOrder + 1) {
+        stateWarning = `Skipping phases: current is '${feature.phase}' (order ${currentPhaseOrder}), target is '${targetPhase}' (order ${targetPhaseOrder})`;
+      }
+    }
+  } catch {
+    // State file may not exist, that's OK
+  }
+
+  // Special validation: if target is 'implement', check tasks exist in state
+  if (targetPhase === 'implement') {
+    try {
+      const feature = getFeature(featureName);
+      if (feature && (!feature.tasks || feature.tasks.total === 0)) {
+        missingOutputs.push('tasks in state.json (run morph-spec task to add tasks)');
+      }
+    } catch {
+      // State file may not exist
+    }
+  }
+
+  return {
+    valid: missingOutputs.length === 0,
+    error: null,
+    missingOutputs,
+    phase: phaseDefinition,
+    featurePath,
+    stateWarning
+  };
+}
+
+/**
+ * Main command handler
+ */
+export async function validatePhaseCommand(feature, phase, options = {}) {
+  console.log(chalk.cyan('\n╔════════════════════════════════════════════════╗'));
+  console.log(chalk.cyan('║     MORPH-SPEC PHASE VALIDATOR                 ║'));
+  console.log(chalk.cyan('╚════════════════════════════════════════════════╝\n'));
+
+  const result = validatePhase(feature, phase);
+
+  console.log(chalk.gray('Feature:'), feature);
+  console.log(chalk.gray('Target Phase:'), result.phase ? result.phase.name : phase);
+
+  if (result.phase) {
+    console.log(chalk.gray('Description:'), result.phase.description);
+  }
+
+  if (result.stateWarning) {
+    console.log(chalk.yellow(`\n⚠️  Warning: ${result.stateWarning}`));
+  }
+
+  if (result.valid) {
+    console.log(chalk.green('\n✓ VALIDATION PASSED'));
+    console.log(chalk.green('  All required outputs are present.'));
+    console.log(chalk.green(`  Safe to proceed to ${result.phase.name}\n`));
+
+    if (options.verbose) {
+      console.log(chalk.gray('Required outputs found:'));
+      result.phase.requiredOutputs.forEach(output => {
+        console.log(chalk.gray(`  ✓ ${output}`));
+      });
+      console.log('');
+    }
+  } else {
+    console.log(chalk.red('\n✗ VALIDATION FAILED'));
+
+    if (result.error) {
+      console.log(chalk.red(`  Error: ${result.error}\n`));
+
+      if (result.suggestion) {
+        console.log(chalk.yellow(`  Suggestion: ${result.suggestion}\n`));
+      }
+
+      if (result.validPhases) {
+        console.log(chalk.yellow('Valid phases:'));
+        result.validPhases.forEach(p => {
+          const def = PHASES[p];
+          console.log(chalk.gray(`  - ${p}: ${def.name}${def.optional ? ' (optional)' : ''}`));
+        });
+      }
+    } else {
+      console.log(chalk.red('  Missing required outputs:'));
+      result.missingOutputs.forEach(output => {
+        console.log(chalk.gray(`  - ${output}`));
+      });
+
+      console.log(chalk.yellow(`\n  Action required:`));
+      console.log(chalk.yellow(`  Complete the missing outputs before advancing to ${result.phase.name}`));
+    }
+    console.log('');
+    process.exit(1);
+  }
+}
+
+export { PHASES, validatePhase };

package/src/generator/config-generator.js

@@ -0,0 +1,206 @@
+/**
+ * @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

@@ -0,0 +1,40 @@
+{
+  "$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
+  }
+}