@polymorphism-tech/morph-spec 4.7.2 → 4.8.4

package/src/commands/project/changes.js

@@ -1,66 +0,0 @@
-/**
- * Changes Command
- *
- * Lists files created/modified by a feature, grouped by phase.
- */
-
-import chalk from 'chalk';
-import { logger } from '../../utils/logger.js';
-import { getFileChanges } from '../../core/state/state-manager.js';
-
-export async function changesCommand(feature, options = {}) {
-  if (!feature) {
-    logger.error('Usage: morph-spec changes <feature>');
-    process.exit(1);
-  }
-
-  try {
-    const grouped = getFileChanges(feature, { groupByPhase: true });
-
-    if (options.json) {
-      console.log(JSON.stringify(grouped, null, 2));
-      return;
-    }
-
-    const phases = Object.keys(grouped);
-
-    if (phases.length === 0) {
-      logger.warn(`No file changes tracked for feature '${feature}'.`);
-      return;
-    }
-
-    logger.header(`File Changes — ${feature}`);
-
-    let totalFiles = 0;
-
-    for (const phase of phases) {
-      const changes = grouped[phase];
-      totalFiles += changes.length;
-
-      console.log(chalk.cyan(`\n  Phase: ${phase} (${changes.length} files)`));
-      console.log('  ' + '─'.repeat(50));
-
-      for (const change of changes) {
-        const actionIcon = {
-          created: chalk.green('+'),
-          modified: chalk.yellow('~'),
-          deleted: chalk.red('-')
-        }[change.action] || ' ';
-
-        const timestamp = change.timestamp
-          ? chalk.dim(` (${new Date(change.timestamp).toLocaleDateString()})`)
-          : '';
-
-        console.log(`  ${actionIcon} ${change.path}${timestamp}`);
-      }
-    }
-
-    logger.blank();
-    logger.dim(`Total: ${totalFiles} file(s) across ${phases.length} phase(s)`);
-    logger.blank();
-
-  } catch (error) {
-    logger.error(error.message);
-    process.exit(1);
-  }
-}

package/src/commands/project/cost.js

@@ -1,179 +0,0 @@
-/**
- * MORPH-SPEC Cost Tracking Command
- *
- * Track and estimate costs (token usage, Azure resources) across phases.
- *
- * Usage:
- *   morph-spec cost <feature-name>
- *   morph-spec cost <feature-name> --json
- */
-
-import chalk from 'chalk';
-import { getFeature, loadState, saveState } from '../../core/state/state-manager.js';
-
-/**
- * Phase cost weights (relative token usage)
- */
-const PHASE_COST_WEIGHTS = {
-  proposal: 5,
-  setup: 3,
-  uiux: 12,
-  design: 18,
-  clarify: 20,
-  tasks: 17,
-  implement: 80
-};
-
-/**
- * Cost per 1K tokens (approximate for Claude models)
- */
-const COST_PER_1K_INPUT = 0.003;
-const COST_PER_1K_OUTPUT = 0.015;
-
-/**
- * Record token usage for a phase
- */
-export function recordPhaseUsage(featureName, phase, inputTokens, outputTokens) {
-  const state = loadState();
-  const feature = state.features[featureName];
-  if (!feature) return;
-
-  if (!feature.costs) {
-    feature.costs = { phases: {}, estimated: 0, approved: false };
-  }
-
-  if (!feature.costs.phases[phase]) {
-    feature.costs.phases[phase] = { inputTokens: 0, outputTokens: 0, usd: 0 };
-  }
-
-  feature.costs.phases[phase].inputTokens += inputTokens;
-  feature.costs.phases[phase].outputTokens += outputTokens;
-  feature.costs.phases[phase].usd =
-    (feature.costs.phases[phase].inputTokens / 1000 * COST_PER_1K_INPUT) +
-    (feature.costs.phases[phase].outputTokens / 1000 * COST_PER_1K_OUTPUT);
-
-  saveState(state);
-}
-
-/**
- * Calculate estimated remaining cost
- */
-function estimateRemaining(feature) {
-  const currentPhaseIndex = Object.keys(PHASE_COST_WEIGHTS).indexOf(feature.phase);
-  const completedWeight = Object.entries(PHASE_COST_WEIGHTS)
-    .filter(([_, __], i) => i <= currentPhaseIndex)
-    .reduce((sum, [_, w]) => sum + w, 0);
-
-  const totalWeight = Object.values(PHASE_COST_WEIGHTS).reduce((a, b) => a + b, 0);
-  const remainingWeight = totalWeight - completedWeight;
-
-  // Estimate based on actual usage so far
-  const actualSpent = Object.values(feature.costs?.phases || {})
-    .reduce((sum, p) => sum + p.usd, 0);
-
-  if (completedWeight === 0 || actualSpent === 0) {
-    // No data yet, use default estimates
-    const estimatedTokens = remainingWeight * 1000;
-    return (estimatedTokens / 1000 * COST_PER_1K_INPUT) + (estimatedTokens / 1000 * COST_PER_1K_OUTPUT);
-  }
-
-  const costPerWeight = actualSpent / completedWeight;
-  return costPerWeight * remainingWeight;
-}
-
-/**
- * Main cost command
- */
-export async function costCommand(featureName, options = {}) {
-  if (!featureName) {
-    console.error(chalk.red('Error: Feature name required'));
-    console.error(chalk.gray('Usage: morph-spec cost <feature-name>'));
-    process.exit(1);
-  }
-
-  const feature = getFeature(featureName);
-  if (!feature) {
-    console.error(chalk.red(`Error: Feature '${featureName}' not found`));
-    process.exit(1);
-  }
-
-  const costs = feature.costs || { phases: {} };
-  const totalSpent = Object.values(costs.phases)
-    .reduce((sum, p) => sum + (p.usd || 0), 0);
-  const estimatedRemaining = estimateRemaining(feature);
-  const totalTokens = Object.values(costs.phases)
-    .reduce((sum, p) => sum + (p.inputTokens || 0) + (p.outputTokens || 0), 0);
-
-  // JSON output
-  if (options.json) {
-    const output = {
-      feature: featureName,
-      currentPhase: feature.phase,
-      totalTokens,
-      totalSpentUsd: Math.round(totalSpent * 100) / 100,
-      estimatedRemainingUsd: Math.round(estimatedRemaining * 100) / 100,
-      estimatedTotalUsd: Math.round((totalSpent + estimatedRemaining) * 100) / 100,
-      phases: Object.entries(costs.phases).map(([phase, data]) => ({
-        phase,
-        inputTokens: data.inputTokens,
-        outputTokens: data.outputTokens,
-        usd: Math.round(data.usd * 100) / 100
-      })),
-      infraCosts: {
-        estimated: costs.estimated || 0,
-        approved: costs.approved || false
-      }
-    };
-    console.log(JSON.stringify(output, null, 2));
-    return;
-  }
-
-  // Visual output
-  console.log(chalk.cyan('\n┌────────────────────────────────────────────────────────────┐'));
-  console.log(chalk.cyan('│                 MORPH-SPEC COST TRACKER                    │'));
-  console.log(chalk.cyan('└────────────────────────────────────────────────────────────┘\n'));
-
-  console.log(chalk.white.bold(`Feature: ${featureName}`));
-  console.log(chalk.gray(`Current Phase: ${feature.phase}\n`));
-
-  console.log(chalk.white.bold('Token usage by phase:'));
-
-  const allPhases = Object.keys(PHASE_COST_WEIGHTS);
-  for (const phase of allPhases) {
-    const data = costs.phases[phase];
-    const weight = PHASE_COST_WEIGHTS[phase];
-    const phaseIndex = allPhases.indexOf(phase);
-    const currentIndex = allPhases.indexOf(feature.phase);
-    const isLast = phaseIndex === allPhases.length - 1;
-    const prefix = isLast ? '└─' : '├─';
-
-    if (data) {
-      const tokens = (data.inputTokens || 0) + (data.outputTokens || 0);
-      const usd = Math.round((data.usd || 0) * 100) / 100;
-      const tokensStr = tokens >= 1000 ? `${Math.round(tokens / 1000)}k` : `${tokens}`;
-      console.log(`${prefix} ${phase.toUpperCase()}: ${chalk.white(tokensStr)} tokens ${chalk.gray(`($${usd})`)}`);
-    } else if (phaseIndex <= currentIndex) {
-      console.log(`${prefix} ${phase.toUpperCase()}: ${chalk.gray('(no data recorded)')}`);
-    } else {
-      console.log(`${prefix} ${phase.toUpperCase()}: ${chalk.gray(`~${weight}k tokens (estimated)`)}`);
-    }
-  }
-
-  console.log('');
-  console.log(chalk.gray('─'.repeat(60)));
-
-  const totalTokensStr = totalTokens >= 1000 ? `${Math.round(totalTokens / 1000)}k` : `${totalTokens}`;
-  console.log(chalk.white(`Total spent: ${totalTokensStr} tokens ($${Math.round(totalSpent * 100) / 100})`));
-  console.log(chalk.yellow(`Estimated remaining: ~$${Math.round(estimatedRemaining * 100) / 100}`));
-  console.log(chalk.white.bold(`Estimated total: ~$${Math.round((totalSpent + estimatedRemaining) * 100) / 100}`));
-
-  // Infrastructure costs
-  if (costs.estimated > 0) {
-    console.log(chalk.white(`\nInfra costs (monthly): $${costs.estimated}`));
-    console.log(costs.approved ? chalk.green('  ✓ Approved') : chalk.yellow('  ⚠ Not yet approved'));
-  }
-
-  console.log('');
-}
-
-export default costCommand;

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;