@polymorphism-tech/morph-spec 10.0.0 → 10.2.0

package/src/commands/validation/validate-feature.js

@@ -1,337 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-import chalk from 'chalk';
-import { parsePlan } from '../../lib/plan/plan-parser.js';
-import { planHash, planRuleOptions, validatePlan } from '../../lib/plan/checks.js';
-
-// Matched against section markers (headings and line-start bold labels), never whole-file
-// substrings. required → ERROR, recommended → WARNING, optional → never penalized; an array is any-of.
-const OUTPUT_SECTIONS = {
-  'verifier.md': {
-    required: [
-      ['Verdict', 'Veredito'],
-    ],
-    recommended: [
-      ['Bloqueadores', 'Bloqueantes', 'Blockers'],
-      'Checks',
-    ],
-    optional: [],
-  },
-  'reviewer.md': {
-    required: [
-      ['Verdict', 'Veredito'],
-    ],
-    recommended: [
-      ['Bloqueadores', 'Bloqueantes', 'Blockers'],
-    ],
-    optional: [],
-  },
-  'security.md': {
-    required: [
-      ['Verdict', 'Veredito'],
-    ],
-    recommended: [
-      ['Bloqueadores', 'Bloqueantes', 'Blockers'],
-    ],
-    optional: [],
-  },
-};
-
-const PHASE_OUTPUTS = {
-  plan: ['plan.md', 'checks.json'],
-  uiux: ['design-system.md', 'mockups.md', 'components.md', 'flows.md'],
-  implement: [],
-  review: ['verifier.md', 'reviewer.md'],
-};
-
-const PHASE_FOLDERS = {
-  plan: '2-plan',
-  uiux: '1-design',
-  implement: '3-implement',
-  review: '4-review',
-};
-
-// Line-start bold labels count: reports write `**Verdict:**` as a label, not a heading.
-function extractSectionMarkers(content) {
-  const markers = [];
-  for (const rawLine of content.split('\n')) {
-    const line = rawLine.trim();
-    const heading = /^#{1,6}\s+(.+)$/.exec(line);
-    if (heading) {
-      markers.push(heading[1].toLowerCase());
-      continue;
-    }
-    const bold = /^\*\*(.+?)\*\*/.exec(line);
-    if (bold) {
-      markers.push(bold[1].toLowerCase());
-    }
-  }
-  return markers;
-}
-
-function validateOutput(featurePath, outputFile) {
-  const filePath = path.join(featurePath, outputFile);
-  const result = {
-    file: outputFile,
-    exists: false,
-    sections: { found: [], missing: [], optional: [] },
-    warnings: [],
-    errors: [],
-    lineCount: 0,
-  };
-
-  if (!fs.existsSync(filePath)) {
-    result.errors.push(`File not found: ${outputFile}`);
-    return result;
-  }
-
-  result.exists = true;
-  const content = fs.readFileSync(filePath, 'utf8');
-  result.lineCount = content.split('\n').length;
-
-  if (outputFile === 'plan.md') {
-    validatePlanOutput(content, featurePath, result);
-    return result;
-  }
-  if (outputFile === 'checks.json') {
-    validateChecksOutput(content, featurePath, result);
-    return result;
-  }
-
-  const sections = OUTPUT_SECTIONS[outputFile];
-  if (!sections) {
-    return result;
-  }
-
-  validateMarkdownSections(content, sections, result);
-
-  if (result.lineCount < 10) {
-    result.warnings.push(`File is very short (${result.lineCount} lines) — may be incomplete`);
-  }
-
-  return result;
-}
-
-// `planDir` is `.morph/features/{f}/2-plan`, so the project is four levels up.
-function validatePlanOutput(content, planDir, result) {
-  const plan = parsePlan(content);
-  const root = path.resolve(planDir, '..', '..', '..', '..');
-  const feature = path.basename(path.resolve(planDir, '..'));
-  const { errors, warnings } = validatePlan(plan, { ...planRuleOptions(root, feature), text: content });
-  result.errors.push(...errors);
-  result.warnings.push(...warnings);
-  result.sections.found.push(...plan.sections.filter((x) => x.key).map((x) => x.name));
-}
-
-function validateChecksOutput(content, planDir, result) {
-  let doc;
-  try {
-    doc = JSON.parse(content);
-  } catch (err) {
-    result.errors.push(`checks.json is not valid JSON: ${err.message}`);
-    return;
-  }
-  const planPath = path.join(planDir, 'plan.md');
-  if (!fs.existsSync(planPath)) return;
-  if (doc?.planHash !== planHash(fs.readFileSync(planPath, 'utf8'))) {
-    result.errors.push('checks.json is stale — plan.md changed after it was generated; run `morph-spec plan-check`');
-    return;
-  }
-  result.sections.found.push(`${doc.checks?.length ?? 0} check(s)`);
-}
-
-function validateMarkdownSections(content, sections, result) {
-  const markers = extractSectionMarkers(content);
-  const match = (entry) => {
-    const candidates = Array.isArray(entry) ? entry : [entry];
-    const hit = candidates.find(c => markers.some(m => m.includes(c.toLowerCase())));
-    return { hit, label: candidates[0] };
-  };
-  const describe = (entry) =>
-    Array.isArray(entry) ? entry.map(s => `"${s}"`).join(' or ') : `"${entry}"`;
-
-  for (const entry of (sections.required || [])) {
-    const { hit, label } = match(entry);
-    if (hit) {
-      result.sections.found.push(hit);
-    } else {
-      result.sections.missing.push(label);
-      result.errors.push(`Missing required section: ${describe(entry)}`);
-    }
-  }
-
-  for (const entry of (sections.recommended || [])) {
-    const { hit } = match(entry);
-    if (hit) {
-      result.sections.found.push(hit);
-    } else {
-      result.warnings.push(`Missing recommended section: ${describe(entry)}`);
-    }
-  }
-
-  for (const entry of (sections.optional || [])) {
-    const { hit } = match(entry);
-    if (hit) result.sections.optional.push(hit);
-  }
-}
-
-function resolveOutputFiles(featurePath, phase) {
-  if (phase) {
-    const files = PHASE_OUTPUTS[phase];
-    if (!files) return { error: `Unknown phase: ${phase}` };
-    const phaseFolder = PHASE_FOLDERS[phase];
-    const searchPath = phaseFolder ? path.join(featurePath, phaseFolder) : featurePath;
-    return { outputFiles: files.map(file => ({ file, dir: searchPath })) };
-  }
-
-  const outputFiles = [];
-  const isOutput = name => name.endsWith('.md') || name.endsWith('.cs') || name === 'checks.json';
-  const entries = fs.readdirSync(featurePath, { withFileTypes: true });
-  for (const entry of entries) {
-    if (entry.isDirectory()) {
-      const subDir = path.join(featurePath, entry.name);
-      for (const f of fs.readdirSync(subDir).filter(isOutput)) {
-        outputFiles.push({ file: f, dir: subDir });
-      }
-    } else if (isOutput(entry.name)) {
-      outputFiles.push({ file: entry.name, dir: featurePath });
-    }
-  }
-  return { outputFiles };
-}
-
-/** Pure core: no console output, no process.exit. */
-export function runFeatureValidation(featurePath, options = {}) {
-  const phase = options.phase || null;
-  const feature = path.basename(featurePath);
-
-  const { outputFiles, error } = resolveOutputFiles(featurePath, phase);
-  if (error) {
-    return {
-      feature,
-      phase: phase || 'all',
-      valid: false,
-      error,
-      totalErrors: 1,
-      totalWarnings: 0,
-      totalFound: 0,
-      results: [],
-    };
-  }
-
-  const results = outputFiles.map(({ file, dir }) => validateOutput(dir, file));
-  const totalErrors = results.reduce((sum, r) => sum + r.errors.length, 0);
-  const totalWarnings = results.reduce((sum, r) => sum + r.warnings.length, 0);
-  const totalFound = results.reduce((sum, r) => sum + r.sections.found.length, 0);
-
-  return {
-    feature,
-    phase: phase || 'all',
-    valid: totalErrors === 0,
-    totalErrors,
-    totalWarnings,
-    totalFound,
-    results,
-  };
-}
-
-export async function validateFeatureCommand(featureName, options = {}) {
-  if (!featureName) {
-    console.error(chalk.red('Error: Feature name required'));
-    console.error(chalk.gray('Usage: morph-spec validate <feature-name> [--phase <phase>]'));
-    process.exit(1);
-  }
-
-  const featurePath = path.join(process.cwd(), '.morph/features', featureName);
-
-  if (!fs.existsSync(featurePath)) {
-    console.error(chalk.red(`Error: Feature directory not found: ${featurePath}`));
-    process.exit(1);
-  }
-
-  const phase = options.phase || null;
-  if (phase && !PHASE_OUTPUTS[phase]) {
-    console.error(chalk.red(`Unknown phase: ${phase}`));
-    console.error(chalk.gray(`Valid phases: ${Object.keys(PHASE_OUTPUTS).join(', ')}`));
-    process.exit(1);
-  }
-
-  const validation = runFeatureValidation(featurePath, { phase });
-  const { results, totalErrors, totalWarnings, totalFound } = validation;
-  const schemaWarnings = [];
-
-  if (options.json) {
-    const output = {
-      feature: featureName,
-      phase: validation.phase,
-      valid: validation.valid,
-      summary: {
-        files: results.length,
-        errors: totalErrors,
-        warnings: totalWarnings + schemaWarnings.length,
-        sectionsFound: totalFound,
-      },
-      results: results.map(r => ({
-        file: r.file,
-        exists: r.exists,
-        lineCount: r.lineCount,
-        errors: r.errors,
-        warnings: r.warnings,
-        sectionsFound: r.sections.found,
-        sectionsMissing: r.sections.missing,
-      })),
-      schemaWarnings,
-    };
-    console.log(JSON.stringify(output, null, 2));
-    return;
-  }
-
-  console.log(chalk.cyan('\n┌────────────────────────────────────────────────────────────┐'));
-  console.log(chalk.cyan('│                MORPH-SPEC FEATURE VALIDATOR                │'));
-  console.log(chalk.cyan('└────────────────────────────────────────────────────────────┘\n'));
-
-  console.log(chalk.white.bold(`Feature: ${featureName}`));
-  if (phase) console.log(chalk.gray(`Phase: ${phase}`));
-  console.log('');
-
-  for (const result of results) {
-    const symbol = result.exists
-      ? (result.errors.length === 0 ? '✅' : '❌')
-      : '⬜';
-    const name = result.exists
-      ? (result.errors.length === 0 ? chalk.green(result.file) : chalk.red(result.file))
-      : chalk.gray(result.file);
-
-    console.log(`${symbol} ${name}${result.exists ? chalk.gray(` (${result.lineCount} lines)`) : ''}`);
-
-    if (result.sections.found.length > 0 && (options.verbose || result.errors.length > 0)) {
-      result.sections.found.forEach(s => {
-        console.log(chalk.green(`   ✓ ${s}`));
-      });
-    }
-
-    result.errors.forEach(err => {
-      console.log(chalk.red(`   ✗ ${err}`));
-    });
-
-    result.warnings.forEach(warn => {
-      console.log(chalk.yellow(`   ⚠ ${warn}`));
-    });
-  }
-
-  console.log('');
-  console.log(chalk.gray('─'.repeat(60)));
-
-  if (totalErrors === 0) {
-    console.log(chalk.green(`\n✓ VALIDATION PASSED — ${results.filter(r => r.exists).length} files validated`));
-    if (totalWarnings > 0) {
-      console.log(chalk.yellow(`  ${totalWarnings} warning(s) — review recommended`));
-    }
-  } else {
-    console.log(chalk.red(`\n✗ VALIDATION FAILED — ${totalErrors} error(s), ${totalWarnings} warning(s)`));
-    console.log(chalk.yellow('  Fix errors before advancing to the next phase'));
-  }
-  console.log('');
-}
-
-export default validateFeatureCommand;