@polymorphism-tech/morph-spec 4.7.2 → 4.8.1

package/src/commands/project/diff.js

@@ -1,278 +0,0 @@
-/**
- * MORPH-SPEC Diff Command
- *
- * Track changes to specifications since last approval.
- * Shows added/removed functional requirements, entity changes, and new decisions.
- *
- * Usage:
- *   morph-spec diff <feature-name> [output-file]
- *   morph-spec diff <feature-name> spec.md
- *   morph-spec diff <feature-name> --json
- */
-
-import fs from 'fs';
-import path from 'path';
-import chalk from 'chalk';
-import { getFeature } from '../../core/state/state-manager.js';
-
-/**
- * Load snapshot from checkpoints directory
- */
-function loadSnapshot(featureName, outputFile) {
-  const snapshotDir = path.join(process.cwd(), '.morph/checkpoints', featureName);
-  const snapshotPath = path.join(snapshotDir, outputFile);
-
-  if (!fs.existsSync(snapshotPath)) {
-    return null;
-  }
-
-  return fs.readFileSync(snapshotPath, 'utf8');
-}
-
-/**
- * Load current version of output file
- */
-function loadCurrent(featureName, outputFile) {
-  const currentPath = path.join(process.cwd(), '.morph/features', featureName, outputFile);
-
-  if (!fs.existsSync(currentPath)) {
-    return null;
-  }
-
-  return fs.readFileSync(currentPath, 'utf8');
-}
-
-/**
- * Extract functional requirements from spec content
- */
-function extractRequirements(content) {
-  const requirements = [];
-  const regex = /###\s+(FR[-_]?\d+):?\s*(.+)/gi;
-  let match;
-  while ((match = regex.exec(content)) !== null) {
-    requirements.push({ id: match[1], title: match[2].trim() });
-  }
-  return requirements;
-}
-
-/**
- * Extract entities from spec or contracts
- */
-function extractEntities(content) {
-  const entities = [];
-  // Markdown entities
-  const mdRegex = /###\s+(?:Entity|Table):?\s*(.+)/gi;
-  let match;
-  while ((match = mdRegex.exec(content)) !== null) {
-    entities.push(match[1].trim());
-  }
-  // C# records
-  const csRegex = /public\s+record\s+(\w+)/g;
-  while ((match = csRegex.exec(content)) !== null) {
-    entities.push(match[1]);
-  }
-  return entities;
-}
-
-/**
- * Extract ADRs from decisions
- */
-function extractDecisions(content) {
-  const decisions = [];
-  const regex = /###\s+ADR[-_]?\d*:?\s*(.+)/gi;
-  let match;
-  while ((match = regex.exec(content)) !== null) {
-    decisions.push(match[1].trim());
-  }
-  return decisions;
-}
-
-/**
- * Compute diff between two content versions
- */
-function computeDiff(oldContent, newContent, outputFile) {
-  const diff = {
-    file: outputFile,
-    added: [],
-    removed: [],
-    modified: []
-  };
-
-  if (!oldContent) {
-    diff.added.push('(entire file is new)');
-    return diff;
-  }
-
-  if (!newContent) {
-    diff.removed.push('(file was deleted)');
-    return diff;
-  }
-
-  // Compare requirements
-  if (outputFile.endsWith('spec.md')) {
-    const oldReqs = extractRequirements(oldContent);
-    const newReqs = extractRequirements(newContent);
-
-    const oldIds = new Set(oldReqs.map(r => r.id));
-    const newIds = new Set(newReqs.map(r => r.id));
-
-    for (const req of newReqs) {
-      if (!oldIds.has(req.id)) {
-        diff.added.push(`${req.id}: ${req.title}`);
-      }
-    }
-    for (const req of oldReqs) {
-      if (!newIds.has(req.id)) {
-        diff.removed.push(`${req.id}: ${req.title}`);
-      }
-    }
-
-    // Compare entities
-    const oldEntities = new Set(extractEntities(oldContent));
-    const newEntities = new Set(extractEntities(newContent));
-
-    for (const entity of newEntities) {
-      if (!oldEntities.has(entity)) {
-        diff.added.push(`Entity: ${entity}`);
-      }
-    }
-    for (const entity of oldEntities) {
-      if (!newEntities.has(entity)) {
-        diff.removed.push(`Entity: ${entity}`);
-      }
-    }
-  }
-
-  // Compare decisions
-  if (outputFile.endsWith('decisions.md')) {
-    const oldDecisions = new Set(extractDecisions(oldContent));
-    const newDecisions = new Set(extractDecisions(newContent));
-
-    for (const decision of newDecisions) {
-      if (!oldDecisions.has(decision)) {
-        diff.added.push(`ADR: ${decision}`);
-      }
-    }
-    for (const decision of oldDecisions) {
-      if (!newDecisions.has(decision)) {
-        diff.removed.push(`ADR: ${decision}`);
-      }
-    }
-  }
-
-  // Line count change
-  const oldLines = oldContent.split('\n').length;
-  const newLines = newContent.split('\n').length;
-  if (oldLines !== newLines) {
-    const delta = newLines - oldLines;
-    diff.modified.push(`${delta > 0 ? '+' : ''}${delta} lines (${oldLines} → ${newLines})`);
-  }
-
-  return diff;
-}
-
-/**
- * Save current version as snapshot for future diffs
- */
-export function saveSnapshot(featureName) {
-  const outputDir = path.join(process.cwd(), '.morph/features', featureName);
-  const snapshotDir = path.join(process.cwd(), '.morph/checkpoints', featureName);
-
-  if (!fs.existsSync(outputDir)) return;
-
-  fs.mkdirSync(snapshotDir, { recursive: true });
-
-  const files = fs.readdirSync(outputDir).filter(f => f.endsWith('.md') || f.endsWith('.cs') || f.endsWith('.json'));
-  for (const file of files) {
-    const src = path.join(outputDir, file);
-    const dest = path.join(snapshotDir, file);
-    fs.copyFileSync(src, dest);
-  }
-}
-
-/**
- * Main diff command
- */
-export async function diffCommand(featureName, outputFile, options = {}) {
-  if (!featureName) {
-    console.error(chalk.red('Error: Feature name required'));
-    console.error(chalk.gray('Usage: morph-spec diff <feature-name> [output-file]'));
-    process.exit(1);
-  }
-
-  const outputDir = path.join(process.cwd(), '.morph/features', featureName);
-  if (!fs.existsSync(outputDir)) {
-    console.error(chalk.red(`Error: Feature directory not found: ${outputDir}`));
-    process.exit(1);
-  }
-
-  // Determine which files to diff
-  let files;
-  if (outputFile) {
-    files = [outputFile];
-  } else {
-    files = fs.readdirSync(outputDir).filter(f => f.endsWith('.md') || f.endsWith('.cs'));
-  }
-
-  const diffs = files.map(file => {
-    const oldContent = loadSnapshot(featureName, file);
-    const newContent = loadCurrent(featureName, file);
-    return computeDiff(oldContent, newContent, file);
-  }).filter(d => d.added.length > 0 || d.removed.length > 0 || d.modified.length > 0);
-
-  // JSON output
-  if (options.json) {
-    console.log(JSON.stringify({ feature: featureName, diffs }, null, 2));
-    return;
-  }
-
-  // Visual output
-  console.log(chalk.cyan('\n┌────────────────────────────────────────────────────────────┐'));
-  console.log(chalk.cyan('│                    MORPH-SPEC DIFF                         │'));
-  console.log(chalk.cyan('└────────────────────────────────────────────────────────────┘\n'));
-
-  console.log(chalk.white.bold(`Feature: ${featureName}`));
-  console.log(chalk.gray('Changes since last snapshot:\n'));
-
-  if (diffs.length === 0) {
-    console.log(chalk.green('  No changes detected since last snapshot.'));
-    console.log(chalk.gray('  Run "morph-spec diff-save <feature>" to create a snapshot.\n'));
-    return;
-  }
-
-  for (const diff of diffs) {
-    console.log(chalk.white.bold(`  ${diff.file}:`));
-
-    for (const item of diff.added) {
-      console.log(chalk.green(`    + ${item}`));
-    }
-    for (const item of diff.removed) {
-      console.log(chalk.red(`    - ${item}`));
-    }
-    for (const item of diff.modified) {
-      console.log(chalk.yellow(`    ~ ${item}`));
-    }
-    console.log('');
-  }
-
-  const totalAdded = diffs.reduce((sum, d) => sum + d.added.length, 0);
-  const totalRemoved = diffs.reduce((sum, d) => sum + d.removed.length, 0);
-  console.log(chalk.gray('─'.repeat(60)));
-  console.log(chalk.gray(`${totalAdded} addition(s), ${totalRemoved} removal(s) across ${diffs.length} file(s)\n`));
-}
-
-/**
- * Save snapshot command
- */
-export async function diffSaveCommand(featureName) {
-  if (!featureName) {
-    console.error(chalk.red('Error: Feature name required'));
-    process.exit(1);
-  }
-
-  saveSnapshot(featureName);
-  console.log(chalk.green(`✓ Snapshot saved for '${featureName}'`));
-  console.log(chalk.gray('  Future "morph-spec diff" will compare against this snapshot.\n'));
-}
-
-export default diffCommand;

package/src/commands/project/revert.js

@@ -1,173 +0,0 @@
-/**
- * MORPH-SPEC Revert Command
- *
- * Revert a feature to a previous phase, optionally deleting later-phase outputs.
- *
- * Usage:
- *   morph-spec revert <feature-name> --to <phase>
- *   morph-spec revert <feature-name> --to design
- *   morph-spec revert <feature-name> --to design --delete-outputs
- */
-
-import fs from 'fs';
-import path from 'path';
-import chalk from 'chalk';
-import { loadState, saveState, getFeature } from '../../core/state/state-manager.js';
-
-/**
- * Phase order for revert logic
- */
-const PHASE_ORDER = [
-  { key: 'proposal', order: 0, outputs: ['proposal.md'] },
-  { key: 'setup', order: 1, outputs: [] },
-  { key: 'uiux', order: 2, outputs: ['ui-design-system.md', 'ui-mockups.md', 'ui-components.md', 'ui-flows.md'] },
-  { key: 'design', order: 3, outputs: ['spec.md', 'schema-analysis.md', 'contracts.cs', 'decisions.md'] },
-  { key: 'clarify', order: 4, outputs: ['clarifications.md'] },
-  { key: 'tasks', order: 5, outputs: ['tasks.md', 'tasks.json'] },
-  { key: 'implement', order: 6, outputs: ['recap.md'] },
-  { key: 'sync', order: 7, outputs: [] }
-];
-
-/**
- * Get outputs that would be affected by reverting to a phase
- */
-function getAffectedOutputs(targetPhase) {
-  const targetOrder = PHASE_ORDER.find(p => p.key === targetPhase)?.order ?? -1;
-  const affected = [];
-
-  for (const phase of PHASE_ORDER) {
-    if (phase.order > targetOrder) {
-      affected.push(...phase.outputs.map(o => ({ phase: phase.key, file: o })));
-    }
-  }
-
-  return affected;
-}
-
-/**
- * Main revert command
- */
-export async function revertCommand(featureName, options = {}) {
-  if (!featureName) {
-    console.error(chalk.red('Error: Feature name required'));
-    console.error(chalk.gray('Usage: morph-spec revert <feature-name> --to <phase>'));
-    process.exit(1);
-  }
-
-  const targetPhase = options.to;
-  if (!targetPhase) {
-    console.error(chalk.red('Error: Target phase required (--to <phase>)'));
-    console.error(chalk.gray(`Valid phases: ${PHASE_ORDER.map(p => p.key).join(', ')}`));
-    process.exit(1);
-  }
-
-  const targetDef = PHASE_ORDER.find(p => p.key === targetPhase);
-  if (!targetDef) {
-    console.error(chalk.red(`Error: Unknown phase: ${targetPhase}`));
-    console.error(chalk.gray(`Valid phases: ${PHASE_ORDER.map(p => p.key).join(', ')}`));
-    process.exit(1);
-  }
-
-  const feature = getFeature(featureName);
-  if (!feature) {
-    console.error(chalk.red(`Error: Feature '${featureName}' not found`));
-    process.exit(1);
-  }
-
-  const currentDef = PHASE_ORDER.find(p => p.key === feature.phase);
-  if (currentDef && targetDef.order >= currentDef.order) {
-    console.error(chalk.red(`Error: Cannot revert forward. Current phase: ${feature.phase}, target: ${targetPhase}`));
-    process.exit(1);
-  }
-
-  // Get affected outputs
-  const affected = getAffectedOutputs(targetPhase);
-  const outputDir = path.join(process.cwd(), '.morph/features', featureName);
-  const existingAffected = affected.filter(a =>
-    fs.existsSync(path.join(outputDir, a.file))
-  );
-
-  // Show what will happen
-  console.log(chalk.cyan('\n┌────────────────────────────────────────────────────────────┐'));
-  console.log(chalk.cyan('│                   MORPH-SPEC REVERT                        │'));
-  console.log(chalk.cyan('└────────────────────────────────────────────────────────────┘\n'));
-
-  console.log(chalk.white.bold(`Feature: ${featureName}`));
-  console.log(chalk.gray(`Current phase: ${feature.phase} → Reverting to: ${targetPhase}\n`));
-
-  if (existingAffected.length > 0) {
-    if (options.deleteOutputs) {
-      console.log(chalk.yellow('The following files will be DELETED:'));
-    } else {
-      console.log(chalk.yellow('The following outputs will be marked as draft (files preserved):'));
-    }
-    for (const item of existingAffected) {
-      console.log(chalk.gray(`  - ${item.file} (from ${item.phase} phase)`));
-    }
-    console.log('');
-  }
-
-  // Update state
-  const state = loadState();
-  const stateFeature = state.features[featureName];
-
-  // Revert phase
-  stateFeature.phase = targetPhase;
-  stateFeature.updatedAt = new Date().toISOString();
-
-  // Mark affected outputs as not created in state
-  const outputKeyMap = {
-    'proposal.md': 'proposal',
-    'spec.md': 'spec',
-    'schema-analysis.md': 'schemaAnalysis',
-    'contracts.cs': 'contracts',
-    'decisions.md': 'decisions',
-    'clarifications.md': 'clarifications',
-    'tasks.md': 'tasks',
-    'tasks.json': 'tasks',
-    'ui-design-system.md': 'uiDesignSystem',
-    'ui-mockups.md': 'uiMockups',
-    'ui-components.md': 'uiComponents',
-    'ui-flows.md': 'uiFlows',
-    'recap.md': 'recap'
-  };
-
-  for (const item of affected) {
-    const key = outputKeyMap[item.file];
-    if (key && stateFeature.outputs[key]) {
-      stateFeature.outputs[key].created = false;
-    }
-  }
-
-  // Reset approval gates for later phases
-  for (const phase of PHASE_ORDER) {
-    if (phase.order > targetDef.order && stateFeature.approvalGates?.[phase.key]) {
-      stateFeature.approvalGates[phase.key].approved = false;
-      stateFeature.approvalGates[phase.key].timestamp = null;
-      stateFeature.approvalGates[phase.key].approvedBy = null;
-    }
-  }
-
-  // Reset tasks if reverting before tasks phase
-  if (targetDef.order < 5) {
-    stateFeature.tasks = { total: 0, completed: 0, inProgress: 0, pending: 0 };
-  }
-
-  saveState(state);
-
-  // Delete files if requested
-  if (options.deleteOutputs && existingAffected.length > 0) {
-    for (const item of existingAffected) {
-      const filePath = path.join(outputDir, item.file);
-      if (fs.existsSync(filePath)) {
-        fs.unlinkSync(filePath);
-      }
-    }
-    console.log(chalk.yellow(`Deleted ${existingAffected.length} file(s).`));
-  }
-
-  console.log(chalk.green(`✓ Feature '${featureName}' reverted to phase: ${targetPhase}`));
-  console.log(chalk.gray(`  State updated. Run 'morph-spec status ${featureName}' to see current status.\n`));
-}
-
-export default revertCommand;

package/src/commands/project/standards.js

@@ -1,80 +0,0 @@
-/**
- * Standards CLI Commands
- *
- * Provides browsable access to the framework standards registry.
- * Usage:
- *   morph-spec standards --list
- *   morph-spec standards --search <query>
- *   morph-spec standards --show <id>
- *   morph-spec standards --category <cat>
- */
-
-import { readFileSync } from 'fs';
-import { join } from 'path';
-import { fileURLToPath } from 'url';
-import { logger } from '../../utils/logger.js';
-
-const __dirname = fileURLToPath(new URL('.', import.meta.url));
-const REGISTRY_PATH = join(__dirname, '..', '..', '..', 'framework', 'standards', 'STANDARDS.json');
-
-function loadRegistry() {
-  return JSON.parse(readFileSync(REGISTRY_PATH, 'utf8')).standards;
-}
-
-/**
- * List all standards, optionally filtered by category.
- * @param {{ json?: boolean, category?: string }} opts
- * @returns {Promise<Array>}
- */
-export async function listStandards({ json, category } = {}) {
-  let standards = loadRegistry();
-  if (category) {
-    standards = standards.filter(s => s.category === category);
-  }
-  if (json) return standards;
-  standards.forEach(s =>
-    logger.info(`${s.id.padEnd(55)} ${s.category}`)
-  );
-  return standards;
-}
-
-/**
- * Search standards by query string (matches id, name, or tags).
- * @param {string} query
- * @param {{ json?: boolean }} opts
- * @returns {Promise<Array>}
- */
-export async function searchStandards(query, { json } = {}) {
-  const q = query.toLowerCase();
-  const results = loadRegistry().filter(s =>
-    s.name.toLowerCase().includes(q) ||
-    s.id.toLowerCase().includes(q) ||
-    s.tags.some(t => t.toLowerCase().includes(q))
-  );
-  if (json) return results;
-  if (results.length === 0) {
-    logger.warn(`No standards found matching "${query}"`);
-  } else {
-    results.forEach(s => logger.info(`${s.id}: ${s.name}  [${s.category}]`));
-  }
-  return results;
-}
-
-/**
- * Show the full content of a standard by its id.
- * @param {string} id
- * @returns {Promise<string|null>}
- */
-export async function showStandard(id) {
-  const standard = loadRegistry().find(s => s.id === id);
-  if (!standard) {
-    logger.error(`Standard '${id}' not found. Use --list to see available standards.`);
-    return null;
-  }
-  const content = readFileSync(
-    join(__dirname, '..', '..', '..', 'framework', 'standards', standard.path),
-    'utf8'
-  );
-  logger.info(content);
-  return content;
-}

package/src/commands/project/sync.js

@@ -1,167 +0,0 @@
-import { join } from 'path';
-import { readdirSync, existsSync } from 'fs';
-import ora from 'ora';
-import chalk from 'chalk';
-import { logger } from '../../utils/logger.js';
-import { readFile, writeFile, ensureDir } from '../../utils/file-copier.js';
-import { analyzeConversation } from '../../lib/detectors/conversation-analyzer.js';
-
-export async function syncCommand(options) {
-  const targetPath = options.path || process.cwd();
-
-  logger.header('MORPH-SPEC Standards Sync');
-  logger.dim(`Project: ${targetPath}`);
-  logger.blank();
-
-  const spinner = ora('Analyzing feature decisions...').start();
-
-  try {
-    // 1. Find all decisions.md files
-    const outputsPath = join(targetPath, '.morph', 'project', 'outputs');
-
-    if (!existsSync(outputsPath)) {
-      spinner.warn('No features found');
-      logger.dim('Create features first using MORPH workflow.');
-      return;
-    }
-
-    const features = readdirSync(outputsPath, { withFileTypes: true })
-      .filter(dirent => dirent.isDirectory())
-      .map(dirent => dirent.name);
-
-    if (features.length === 0) {
-      spinner.warn('No features found');
-      return;
-    }
-
-    spinner.text = `Found ${features.length} features, analyzing decisions...`;
-
-    // 2. Analyze all decisions
-    const conversation = await analyzeConversation(targetPath);
-
-    if (conversation.decisions.length === 0) {
-      spinner.warn('No decisions found to sync');
-      logger.dim('Features may not have decisions.md files yet.');
-      return;
-    }
-
-    spinner.succeed(`Found ${conversation.decisions.length} decisions`);
-    logger.blank();
-
-    // 3. Group by category
-    const byCategory = groupByCategory(conversation.decisions);
-
-    // 4. Display candidates
-    logger.header('Decisions by Category:');
-    logger.blank();
-
-    let totalCandidates = 0;
-
-    for (const [category, decisions] of Object.entries(byCategory)) {
-      if (decisions.length > 0) {
-        logger.info(chalk.cyan(`${formatCategory(category)} (${decisions.length})`));
-        decisions.slice(0, 3).forEach(d => {
-          const preview = d.text.split('\n')[0].substring(0, 70);
-          logger.dim(`  - ${preview}...`);
-        });
-        if (decisions.length > 3) {
-          logger.dim(`  ... and ${decisions.length - 3} more`);
-        }
-        logger.blank();
-        totalCandidates += decisions.length;
-      }
-    }
-
-    // 5. Sync (for now, just report - interactive approval would be added later)
-    if (options.dryRun) {
-      logger.warn('Dry run mode - no files updated');
-      logger.dim(`Would update ${Object.keys(byCategory).length} standard files`);
-      return;
-    }
-
-    spinner.start('Updating standards...');
-
-    const standardsDir = join(targetPath, '.morph', 'project', 'standards');
-    await ensureDir(standardsDir);
-
-    let updatedFiles = [];
-
-    for (const [category, decisions] of Object.entries(byCategory)) {
-      if (decisions.length === 0) continue;
-
-      const fileName = `${category}.md`;
-      const filePath = join(standardsDir, fileName);
-
-      // Read existing or create new
-      let content = '';
-      if (existsSync(filePath)) {
-        content = await readFile(filePath);
-      } else {
-        content = `# ${formatCategory(category)} Standards\n\n> Project-specific standards for ${category}\n\n`;
-      }
-
-      // Append new decisions
-      content += `\n## Decisions from Features (${new Date().toISOString().split('T')[0]})\n\n`;
-
-      decisions.forEach((d, idx) => {
-        const preview = d.text.split('\n').slice(0, 5).join('\n');
-        content += `### Decision ${idx + 1}\n\n${preview}\n\n`;
-      });
-
-      await writeFile(filePath, content);
-      updatedFiles.push(fileName);
-    }
-
-    spinner.succeed(`Updated ${updatedFiles.length} standard files`);
-
-    updatedFiles.forEach(file => {
-      logger.dim(`  - ${file}`);
-    });
-
-    logger.blank();
-    logger.success('Standards sync complete!');
-    logger.dim('Commit these changes with a sync: message.');
-
-  } catch (error) {
-    spinner.fail('Sync failed');
-    logger.error(error.message);
-    process.exit(1);
-  }
-}
-
-/**
- * Group decisions by category
- */
-function groupByCategory(decisions) {
-  const categories = {
-    'coding': [],
-    'architecture': [],
-    'azure': [],
-    'integrations': [],
-    'ui-ux': []
-  };
-
-  decisions.forEach(decision => {
-    const category = decision.category || 'coding';
-    if (categories[category]) {
-      categories[category].push(decision);
-    }
-  });
-
-  return categories;
-}
-
-/**
- * Format category name
- */
-function formatCategory(category) {
-  const names = {
-    'coding': 'Coding Standards',
-    'architecture': 'Architecture Patterns',
-    'azure': 'Azure & Infrastructure',
-    'integrations': 'Integration Patterns',
-    'ui-ux': 'UI/UX Standards'
-  };
-
-  return names[category] || category;
-}