@polymorphism-tech/morph-spec 4.3.7 → 4.6.0

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

@@ -0,0 +1,359 @@
+/**
+ * MORPH-SPEC Feature Validation Command
+ *
+ * Content-aware validation of feature outputs at each phase.
+ * Checks section presence, schema consistency, and contract correctness.
+ *
+ * Usage:
+ *   morph-spec validate <feature-name> [--phase <phase>] [--json] [--verbose]
+ *
+ * Example:
+ *   morph-spec validate user-portal --phase design
+ *   morph-spec validate user-portal --json
+ */
+
+import fs from 'fs';
+import path from 'path';
+import chalk from 'chalk';
+import { getFeature } from '../../core/state/state-manager.js';
+
+/**
+ * Expected sections per output file
+ */
+const OUTPUT_SECTIONS = {
+  'proposal.md': {
+    required: ['Overview', 'Problem', 'Solution', 'Scope'],
+    optional: ['Agents', 'Stack', 'Risks']
+  },
+  'spec.md': {
+    required: [
+      'Overview', 'Functional Requirements', 'Non-Functional Requirements',
+      'Technical Architecture', 'Data Model'
+    ],
+    optional: [
+      'Infrastructure', 'Testing Strategy', 'Security',
+      'Performance', 'Edge Cases', 'Clarifications'
+    ]
+  },
+  'contracts.cs': {
+    required: ['namespace', 'record', 'interface'],
+    isCode: true
+  },
+  'schema-analysis.md': {
+    required: ['Tables Analyzed', 'Columns', 'Relationships'],
+    optional: ['CRITICAL FINDINGS', 'Recommendations', 'Indexes']
+  },
+  'decisions.md': {
+    required: ['ADR', 'Status', 'Context', 'Decision'],
+    optional: ['Consequences', 'Alternatives', 'Costs']
+  },
+  'tasks.md': {
+    required: ['T001', 'category', 'dependencies'],
+    optional: ['CHECKPOINT', 'estimatedMinutes']
+  },
+  'clarifications.md': {
+    required: ['Q1', 'Answer', 'Edge Cases'],
+    optional: ['Assumptions', 'Business Rules']
+  }
+};
+
+/**
+ * Phase-to-output mapping
+ */
+const PHASE_OUTPUTS = {
+  proposal: ['proposal.md'],
+  setup: ['proposal.md'],
+  uiux: ['ui-design-system.md', 'ui-mockups.md', 'ui-components.md', 'ui-flows.md'],
+  design: ['spec.md', 'contracts.cs', 'schema-analysis.md', 'decisions.md'],
+  clarify: ['spec.md', 'clarifications.md'],
+  tasks: ['tasks.md'],
+  implement: ['spec.md', 'contracts.cs', 'tasks.md']
+};
+
+/**
+ * Validate a single output file
+ */
+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;
+
+  // Skip section checks for files without defined sections
+  const sections = OUTPUT_SECTIONS[outputFile];
+  if (!sections) {
+    return result;
+  }
+
+  if (sections.isCode) {
+    // C# code validation
+    validateCSharpContent(content, result);
+  } else {
+    // Markdown section validation
+    validateMarkdownSections(content, sections, result);
+  }
+
+  // Size warnings
+  if (result.lineCount < 10) {
+    result.warnings.push(`File is very short (${result.lineCount} lines) — may be incomplete`);
+  }
+
+  return result;
+}
+
+/**
+ * Validate markdown sections
+ */
+function validateMarkdownSections(content, sections, result) {
+  const contentLower = content.toLowerCase();
+
+  for (const section of sections.required) {
+    if (contentLower.includes(section.toLowerCase())) {
+      result.sections.found.push(section);
+    } else {
+      result.sections.missing.push(section);
+      result.errors.push(`Missing required section: "${section}"`);
+    }
+  }
+
+  for (const section of (sections.optional || [])) {
+    if (contentLower.includes(section.toLowerCase())) {
+      result.sections.optional.push(section);
+    }
+  }
+}
+
+/**
+ * Validate C# contracts content
+ */
+function validateCSharpContent(content, result) {
+  // Check for namespace
+  if (/namespace\s+\S+/.test(content)) {
+    result.sections.found.push('namespace');
+  } else {
+    result.sections.missing.push('namespace');
+    result.errors.push('Missing namespace declaration');
+  }
+
+  // Check for records (DTOs)
+  const records = content.match(/public\s+record\s+\w+/g) || [];
+  if (records.length > 0) {
+    result.sections.found.push(`${records.length} record(s)`);
+  } else {
+    result.warnings.push('No record types found — DTOs expected');
+  }
+
+  // Check for interfaces
+  const interfaces = content.match(/public\s+interface\s+I\w+/g) || [];
+  if (interfaces.length > 0) {
+    result.sections.found.push(`${interfaces.length} interface(s)`);
+  } else {
+    result.warnings.push('No interfaces found — service contracts expected');
+  }
+
+  // Check for CancellationToken in async methods
+  const asyncMethods = content.match(/Task<.*>\s+\w+\(/g) || [];
+  const methodsWithCt = content.match(/CancellationToken\s+ct/g) || [];
+  if (asyncMethods.length > 0 && methodsWithCt.length < asyncMethods.length) {
+    result.warnings.push(
+      `${asyncMethods.length - methodsWithCt.length} async method(s) may be missing CancellationToken`
+    );
+  }
+
+  // Check for schema-analysis reference
+  if (content.includes('schema-analysis')) {
+    result.sections.found.push('schema reference');
+  } else {
+    result.warnings.push('No reference to schema-analysis.md — fields may not match database');
+  }
+}
+
+/**
+ * Cross-validate contracts against schema-analysis
+ */
+function crossValidateSchema(featurePath) {
+  const schemaPath = path.join(featurePath, 'schema-analysis.md');
+  const contractsPath = path.join(featurePath, 'contracts.cs');
+  const warnings = [];
+
+  if (!fs.existsSync(schemaPath) || !fs.existsSync(contractsPath)) {
+    return warnings;
+  }
+
+  const schema = fs.readFileSync(schemaPath, 'utf8');
+  const contracts = fs.readFileSync(contractsPath, 'utf8');
+
+  // Extract field names from schema (look for column names in tables)
+  const schemaFields = new Set();
+  const columnRegex = /\|\s*(\w+)\s*\|/g;
+  let match;
+  while ((match = columnRegex.exec(schema)) !== null) {
+    const field = match[1].toLowerCase();
+    if (!['column', 'name', 'type', 'nullable', 'default', 'notes', 'table', '---'].includes(field)) {
+      schemaFields.add(field);
+    }
+  }
+
+  // Extract field names from contracts
+  const contractFields = new Set();
+  const fieldRegex = /(?:string|int|Guid|DateTime|bool|decimal|JsonObject)\???\s+(\w+)/g;
+  while ((match = fieldRegex.exec(contracts)) !== null) {
+    contractFields.add(match[1].toLowerCase());
+  }
+
+  // Check for contract fields not in schema
+  for (const field of contractFields) {
+    if (schemaFields.size > 0 && !schemaFields.has(field) && field !== 'ct') {
+      warnings.push(`Contract field "${field}" not found in schema-analysis.md — verify correctness`);
+    }
+  }
+
+  return warnings;
+}
+
+/**
+ * Main validate command
+ */
+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);
+  }
+
+  // Determine which outputs to validate
+  const phase = options.phase || null;
+  let outputFiles;
+
+  if (phase) {
+    outputFiles = PHASE_OUTPUTS[phase];
+    if (!outputFiles) {
+      console.error(chalk.red(`Unknown phase: ${phase}`));
+      console.error(chalk.gray(`Valid phases: ${Object.keys(PHASE_OUTPUTS).join(', ')}`));
+      process.exit(1);
+    }
+  } else {
+    // Validate all existing outputs
+    outputFiles = fs.readdirSync(featurePath).filter(f => f.endsWith('.md') || f.endsWith('.cs'));
+  }
+
+  // Run validation
+  const results = outputFiles.map(file => validateOutput(featurePath, file));
+  const schemaWarnings = crossValidateSchema(featurePath);
+
+  // Aggregate results
+  const totalErrors = results.reduce((sum, r) => sum + r.errors.length, 0);
+  const totalWarnings = results.reduce((sum, r) => sum + r.warnings.length, 0) + schemaWarnings.length;
+  const totalFound = results.reduce((sum, r) => sum + r.sections.found.length, 0);
+
+  // JSON output mode
+  if (options.json) {
+    const output = {
+      feature: featureName,
+      phase: phase || 'all',
+      valid: totalErrors === 0,
+      summary: {
+        files: results.length,
+        errors: totalErrors,
+        warnings: totalWarnings,
+        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;
+  }
+
+  // Visual output
+  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('');
+
+  // File-by-file results
+  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)`) : ''}`);
+
+    // Sections found
+    if (result.sections.found.length > 0 && (options.verbose || result.errors.length > 0)) {
+      result.sections.found.forEach(s => {
+        console.log(chalk.green(`   ✓ ${s}`));
+      });
+    }
+
+    // Errors
+    result.errors.forEach(err => {
+      console.log(chalk.red(`   ✗ ${err}`));
+    });
+
+    // Warnings
+    result.warnings.forEach(warn => {
+      console.log(chalk.yellow(`   ⚠ ${warn}`));
+    });
+  }
+
+  // Schema cross-validation
+  if (schemaWarnings.length > 0) {
+    console.log(chalk.yellow('\nSchema Cross-Validation:'));
+    schemaWarnings.forEach(w => {
+      console.log(chalk.yellow(`  ⚠ ${w}`));
+    });
+  }
+
+  // Summary
+  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;

package/src/core/orchestrator.js

@@ -6,7 +6,6 @@
 import chalk from 'chalk';
 import { ProjectScanner } from '../scanner/project-scanner.js';
 import { ContextSanitizer } from '../sanitizer/context-sanitizer.js';
-import { LLMAnalyzer } from '../llm/analyzer.js';
 import { ConfigGenerator } from '../generator/config-generator.js';
 import { UserReview } from '../ui/user-review.js';
 import { InteractiveWizard } from '../ui/interactive-wizard.js';
@@ -26,7 +25,6 @@ export class AutoContextOrchestrator {
   constructor() {
     this.scanner = new ProjectScanner();
     this.sanitizer = new ContextSanitizer();
-    this.llmAnalyzer = new LLMAnalyzer();
     this.configGenerator = new ConfigGenerator();
     this.userReview = new UserReview();
     this.wizard = new InteractiveWizard();
@@ -41,15 +39,11 @@ export class AutoContextOrchestrator {
    * @param {string} cwd - Current working directory
    * @param {Object} [options] - Orchestration options
    * @param {boolean} [options.skipReview] - Skip user review (auto-approve)
-   * @param {boolean} [options.fallbackOnError] - Fallback to wizard on LLM error (default: true)
-   * @param {boolean} [options.wizardMode] - Force wizard mode (skip LLM)
    * @returns {Promise<{success: boolean, configs: GeneratedConfigs|null}>}
    */
   async execute(cwd, options = {}) {
     const {
       skipReview = false,
-      fallbackOnError = true,
-      wizardMode = false
     } = options;
 
     try {
@@ -57,38 +51,9 @@ export class AutoContextOrchestrator {
 
       let projectConfig;
 
-      // Step 1: Decide between LLM or Wizard mode
-      if (wizardMode) {
-        console.log(chalk.yellow('  Using interactive wizard mode (--wizard flag)\n'));
-        projectConfig = await this.wizard.run();
-      } else {
-        try {
-          // Step 1a: Scan project
-          console.log(chalk.dim('  [1/6] Scanning project directory...'));
-          const projectContext = await this.scanner.scan(cwd);
-
-          // Step 1b: Sanitize context
-          console.log(chalk.dim('  [2/6] Sanitizing context (removing secrets)...'));
-          const sanitizedContext = this.sanitizer.sanitize(projectContext);
-
-          // Step 1c: Analyze with LLM
-          console.log(chalk.dim('  [3/6] Analyzing with Claude Code LLM...'));
-          projectConfig = await this.llmAnalyzer.analyze(sanitizedContext);
-
-          console.log(chalk.green('  ✓ Auto-detection successful\n'));
-        } catch (error) {
-          // LLM failed
-          console.log(chalk.yellow(`\n  ⚠️  Auto-detection failed: ${error.message}\n`));
-
-          if (!fallbackOnError) {
-            throw error;
-          }
-
-          // Fallback to wizard
-          console.log(chalk.cyan('  Falling back to interactive wizard...\n'));
-          projectConfig = await this.wizard.run();
-        }
-      }
+      // 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...'));

package/src/core/paths/output-schema.js

@@ -0,0 +1,135 @@
+/**
+ * Output Schema — Single Source of Truth
+ *
+ * ALL output type definitions live here. Edit ONLY this file to add, rename,
+ * or relocate output types. Derived constants and generated files (phase-utils.js)
+ * are automatically updated by: node scripts/generate-refs.js
+ */
+
+import { join } from 'path';
+
+// ============================================================================
+// Schema Definition
+// ============================================================================
+
+/**
+ * Complete schema for all 12 output types produced by morph-spec phases.
+ *
+ * Fields:
+ *   filename     - The file's basename (e.g. 'spec.md')
+ *   phaseDir     - Subdirectory within .morph/features/{feature}/ (e.g. '1-design')
+ *   phase        - The morph-spec phase that produces this output
+ *   protected    - Whether the file requires an approval gate before editing
+ *   approvalGate - (optional) Which gate protects this file
+ */
+export const OUTPUT_SCHEMA = {
+  proposal:      { filename: 'proposal.md',        phaseDir: '0-proposal',  phase: 'proposal',  protected: false },
+  schemaAnalysis:{ filename: 'schema-analysis.md', phaseDir: '1-design',    phase: 'design',    protected: true,  approvalGate: 'design' },
+  spec:          { filename: 'spec.md',             phaseDir: '1-design',    phase: 'design',    protected: true,  approvalGate: 'design' },
+  clarifications:{ filename: 'clarifications.md',  phaseDir: '1-design',    phase: 'clarify',   protected: false },
+  contracts:     { filename: 'contracts.cs',        phaseDir: '1-design',    phase: 'design',    protected: true,  approvalGate: 'design' },
+  tasks:         { filename: 'tasks.md',            phaseDir: '3-tasks',     phase: 'tasks',     protected: true,  approvalGate: 'tasks' },
+  uiDesignSystem:{ filename: 'design-system.md',   phaseDir: '2-ui',        phase: 'uiux',      protected: true,  approvalGate: 'uiux' },
+  uiMockups:     { filename: 'mockups.md',          phaseDir: '2-ui',        phase: 'uiux',      protected: true,  approvalGate: 'uiux' },
+  uiComponents:  { filename: 'components.md',       phaseDir: '2-ui',        phase: 'uiux',      protected: true,  approvalGate: 'uiux' },
+  uiFlows:       { filename: 'flows.md',            phaseDir: '2-ui',        phase: 'uiux',      protected: true,  approvalGate: 'uiux' },
+  decisions:     { filename: 'decisions.md',        phaseDir: '1-design',    phase: 'design',    protected: false },
+  recap:         { filename: 'recap.md',            phaseDir: '4-implement', phase: 'implement', protected: false },
+};
+
+// ============================================================================
+// Builder Functions (Windows-safe via path.join)
+// ============================================================================
+
+/**
+ * Get the morph-relative path for a specific output type of a feature.
+ * Returns forward-slash paths suitable for state.json storage.
+ *
+ * @param {string} featureName - The feature name
+ * @param {string} outputType  - camelCase output type key from OUTPUT_SCHEMA
+ * @returns {string} e.g. ".morph/features/my-feature/1-design/spec.md"
+ */
+export function getOutputPath(featureName, outputType) {
+  const entry = OUTPUT_SCHEMA[outputType];
+  if (!entry) {
+    throw new Error(`Unknown output type: "${outputType}". Valid types: ${Object.keys(OUTPUT_SCHEMA).join(', ')}`);
+  }
+  // Use path.join for OS-safe construction, then normalise to forward slashes
+  return join('.morph', 'features', featureName, entry.phaseDir, entry.filename)
+    .replace(/\\/g, '/');
+}
+
+/**
+ * Get the absolute filesystem path for a specific output type.
+ *
+ * @param {string} projectRoot - Absolute project root (e.g. process.cwd())
+ * @param {string} featureName - The feature name
+ * @param {string} outputType  - camelCase output type key from OUTPUT_SCHEMA
+ * @returns {string} Absolute path using OS path separator
+ */
+export function getAbsoluteOutputPath(projectRoot, featureName, outputType) {
+  const entry = OUTPUT_SCHEMA[outputType];
+  if (!entry) {
+    throw new Error(`Unknown output type: "${outputType}". Valid types: ${Object.keys(OUTPUT_SCHEMA).join(', ')}`);
+  }
+  return join(projectRoot, '.morph', 'features', featureName, entry.phaseDir, entry.filename);
+}
+
+/**
+ * Get the feature base directory (morph-relative, forward slashes).
+ *
+ * @param {string} featureName
+ * @returns {string} e.g. ".morph/features/my-feature"
+ */
+export function getFeatureDir(featureName) {
+  return join('.morph', 'features', featureName).replace(/\\/g, '/');
+}
+
+/**
+ * Get all output paths for a feature, ready for use in state.json `outputs` block.
+ * Returns an object shaped like the state.json outputs for a single feature.
+ *
+ * @param {string} featureName
+ * @returns {Object} e.g. { proposal: { created: false, path: '...' }, ... }
+ */
+export function getAllOutputPaths(featureName) {
+  const outputs = {};
+  for (const [key] of Object.entries(OUTPUT_SCHEMA)) {
+    outputs[key] = {
+      created: false,
+      path: getOutputPath(featureName, key),
+    };
+  }
+  return outputs;
+}
+
+// ============================================================================
+// Derived Constants (for direct import without calling functions)
+// ============================================================================
+
+/**
+ * Map filename → output type (camelCase)
+ * e.g. { 'spec.md': 'spec', 'contracts.cs': 'contracts', ... }
+ */
+export const FILENAME_TO_OUTPUT = Object.fromEntries(
+  Object.entries(OUTPUT_SCHEMA).map(([key, entry]) => [entry.filename, key])
+);
+
+/**
+ * Map output type (camelCase) → phase that produces it
+ * e.g. { spec: 'design', tasks: 'tasks', ... }
+ */
+export const OUTPUT_PHASE_MAP = Object.fromEntries(
+  Object.entries(OUTPUT_SCHEMA).map(([key, entry]) => [key, entry.phase])
+);
+
+/**
+ * Protected spec files and the approval gate that locks them.
+ * Only includes files where protected === true.
+ * e.g. { 'spec.md': 'design', 'tasks.md': 'tasks', ... }
+ */
+export const PROTECTED_SPEC_FILES = Object.fromEntries(
+  Object.entries(OUTPUT_SCHEMA)
+    .filter(([, entry]) => entry.protected && entry.approvalGate)
+    .map(([, entry]) => [entry.filename, entry.approvalGate])
+);