@polymorphism-tech/morph-spec 3.0.1 → 3.2.0

package/src/commands/migrate-state.js

@@ -0,0 +1,158 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { readFileSync, writeFileSync, existsSync } from 'fs';
+import { join } from 'path';
+
+/**
+ * Migrate State Command - Upgrade state.json to v3.0 schema
+ *
+ * Adds approval gates to existing features
+ */
+
+const program = new Command();
+
+program
+  .name('migrate-state')
+  .description('Migrate state.json to v3.0 schema (add approval gates)')
+  .option('--dry-run', 'Preview changes without writing')
+  .option('--force', 'Skip confirmation')
+  .action(async (options) => {
+    try {
+      const statePath = join(process.cwd(), '.morph/state.json');
+
+      if (!existsSync(statePath)) {
+        console.error(chalk.red(`\n❌ No state.json found at ${statePath}`));
+        console.log(chalk.yellow('This project may not be initialized with MORPH-SPEC.\n'));
+        process.exit(1);
+      }
+
+      // Read current state
+      const state = JSON.parse(readFileSync(statePath, 'utf8'));
+
+      console.log(chalk.cyan('\n🔄 Migrating state.json to v3.0 schema...\n'));
+
+      // Check if already migrated
+      if (state.version === '3.0.0') {
+        console.log(chalk.green('✅ State already at v3.0.0 - no migration needed\n'));
+        process.exit(0);
+      }
+
+      // Track changes
+      let featuresUpdated = 0;
+      const changes = [];
+
+      // Migrate each feature
+      Object.entries(state.features || {}).forEach(([featureName, feature]) => {
+        // Skip if already has approvalGates
+        if (feature.approvalGates) {
+          return;
+        }
+
+        // Determine which gates to auto-approve based on current phase
+        const currentPhase = feature.phase || 'proposal';
+        const approvalGates = {
+          proposal: { approved: false, timestamp: null, approvedBy: null },
+          uiux: { approved: false, timestamp: null, approvedBy: null },
+          design: { approved: false, timestamp: null, approvedBy: null },
+          tasks: { approved: false, timestamp: null, approvedBy: null }
+        };
+
+        // Auto-approve past gates
+        const phaseOrder = ['proposal', 'setup', 'uiux', 'design', 'clarify', 'tasks', 'implement', 'sync', 'archived'];
+        const currentPhaseIndex = phaseOrder.indexOf(currentPhase);
+
+        if (currentPhaseIndex >= phaseOrder.indexOf('proposal')) {
+          approvalGates.proposal.approved = true;
+          approvalGates.proposal.timestamp = feature.createdAt || new Date().toISOString();
+          approvalGates.proposal.approvedBy = 'auto-migration';
+        }
+
+        if (currentPhaseIndex >= phaseOrder.indexOf('design')) {
+          approvalGates.design.approved = true;
+          approvalGates.design.timestamp = feature.updatedAt || new Date().toISOString();
+          approvalGates.design.approvedBy = 'auto-migration';
+        }
+
+        if (currentPhaseIndex >= phaseOrder.indexOf('tasks')) {
+          approvalGates.tasks.approved = true;
+          approvalGates.tasks.timestamp = feature.updatedAt || new Date().toISOString();
+          approvalGates.tasks.approvedBy = 'auto-migration';
+        }
+
+        // Add approval gates to feature
+        feature.approvalGates = approvalGates;
+
+        featuresUpdated++;
+        changes.push({
+          feature: featureName,
+          phase: currentPhase,
+          approvedGates: Object.entries(approvalGates)
+            .filter(([_, gate]) => gate.approved)
+            .map(([name]) => name)
+        });
+      });
+
+      // Update state version
+      state.version = '3.0.0';
+
+      // Show changes
+      console.log(chalk.bold('📊 Migration Summary:\n'));
+      console.log(chalk.cyan(`   Features to update: ${featuresUpdated}`));
+
+      if (changes.length > 0) {
+        console.log(chalk.gray('\n   Changes:'));
+        changes.forEach(change => {
+          console.log(chalk.white(`   - ${change.feature} (${change.phase})`));
+          console.log(chalk.gray(`     Auto-approved gates: ${change.approvedGates.join(', ') || 'none'}`));
+        });
+      }
+
+      console.log('');
+
+      // Dry run
+      if (options.dryRun) {
+        console.log(chalk.yellow('🔍 DRY RUN - No changes written\n'));
+        console.log(chalk.gray('Run without --dry-run to apply migration.\n'));
+        return;
+      }
+
+      // Confirmation
+      if (!options.force) {
+        console.log(chalk.yellow('⚠️  This will modify .morph/state.json'));
+        console.log(chalk.gray('   A backup will be created at .morph/state.json.backup\n'));
+        console.log(chalk.gray('   Run with --force to skip this confirmation, or Ctrl+C to cancel.\n'));
+
+        // Wait for user confirmation (in CLI context, assume proceed for now)
+        // In real implementation, use inquirer for interactive confirmation
+      }
+
+      // Backup original
+      const backupPath = `${statePath}.backup`;
+      writeFileSync(backupPath, JSON.stringify(state, null, 2));
+      console.log(chalk.gray(`📦 Backup created: ${backupPath}\n`));
+
+      // Write migrated state
+      writeFileSync(statePath, JSON.stringify(state, null, 2));
+
+      console.log(chalk.green('✅ Migration complete!\n'));
+      console.log(chalk.bold('Next steps:\n'));
+      console.log(chalk.gray('1. Review .morph/config/llm-interaction.json (created on next init)'));
+      console.log(chalk.gray('2. Configure approval gates, checkpoints, patterns'));
+      console.log(chalk.gray('3. Continue working with v3.0 features\n'));
+
+    } catch (error) {
+      console.error(chalk.red(`\n❌ Migration failed: ${error.message}\n`));
+      process.exit(1);
+    }
+  });
+
+// Only parse if run directly (not imported as module)
+if (import.meta.url === `file://${process.argv[1]}`) {
+  if (process.argv.length > 2) {
+    program.parse(process.argv);
+  } else {
+    program.help();
+  }
+}
+
+export default program;

package/src/commands/rollback-phase.js

@@ -1,185 +1,185 @@
-/**
- * MORPH-SPEC Rollback Phase Command
- *
- * Rolls back a feature to a previous phase, marking outputs as draft.
- *
- * Usage:
- *   morph-spec rollback <feature-name> <target-phase>
- *
- * Example:
- *   morph-spec rollback scheduled-reports design
- */
-
-import fs from 'fs';
-import path from 'path';
-import chalk from 'chalk';
-import { loadState, saveState, getFeature, updateFeature } from '../lib/state-manager.js';
-
-// Phase order
-const PHASE_ORDER = ['proposal', 'setup', 'uiux', 'design', 'clarify', 'tasks', 'implement', 'sync'];
-
-/**
- * Get phase index
- */
-function getPhaseIndex(phase) {
-  return PHASE_ORDER.indexOf(phase);
-}
-
-/**
- * Get outputs that should be marked as draft when rolling back
- */
-function getOutputsToReset(fromPhase, toPhase) {
-  const fromIndex = getPhaseIndex(fromPhase);
-  const toIndex = getPhaseIndex(toPhase);
-
-  // Map phases to their outputs
-  const phaseOutputs = {
-    'proposal': ['proposal'],
-    'setup': [],
-    'uiux': ['uiDesignSystem', 'uiMockups', 'uiComponents', 'uiFlows'],
-    'design': ['spec', 'contracts', 'decisions'],
-    'clarify': [],
-    'tasks': ['tasks'],
-    'implement': ['recap'],
-    'sync': []
-  };
-
-  const outputsToReset = [];
-
-  // Collect all outputs from phases after target
-  for (let i = toIndex + 1; i <= fromIndex; i++) {
-    const phase = PHASE_ORDER[i];
-    if (phaseOutputs[phase]) {
-      outputsToReset.push(...phaseOutputs[phase]);
-    }
-  }
-
-  return outputsToReset;
-}
-
-/**
- * Main command handler
- */
-export async function rollbackPhaseCommand(feature, targetPhase, options = {}) {
-  console.log(chalk.cyan('\n╔════════════════════════════════════════════════╗'));
-  console.log(chalk.cyan('║     MORPH-SPEC ROLLBACK                        ║'));
-  console.log(chalk.cyan('╚════════════════════════════════════════════════╝\n'));
-
-  // Validate target phase
-  if (!PHASE_ORDER.includes(targetPhase)) {
-    console.log(chalk.red(`❌ Invalid phase: ${targetPhase}`));
-    console.log(chalk.gray('\nValid phases:'));
-    PHASE_ORDER.forEach(p => console.log(chalk.gray(`  - ${p}`)));
-    process.exit(1);
-  }
-
-  // Get current feature state
-  let featureState;
-  try {
-    featureState = getFeature(feature);
-  } catch (error) {
-    console.log(chalk.red(`❌ Feature not found: ${feature}`));
-    console.log(chalk.gray('  Run: morph-spec state list'));
-    process.exit(1);
-  }
-
-  if (!featureState) {
-    console.log(chalk.red(`❌ Feature not found: ${feature}`));
-    process.exit(1);
-  }
-
-  const currentPhase = featureState.phase || 'proposal';
-  const currentIndex = getPhaseIndex(currentPhase);
-  const targetIndex = getPhaseIndex(targetPhase);
-
-  // Check if rollback makes sense
-  if (targetIndex >= currentIndex) {
-    console.log(chalk.yellow(`⚠️  Cannot rollback: target phase '${targetPhase}' is not before current phase '${currentPhase}'`));
-    process.exit(1);
-  }
-
-  // Get outputs to reset
-  const outputsToReset = getOutputsToReset(currentPhase, targetPhase);
-
-  // Show what will happen
-  console.log(chalk.gray('Feature:'), feature);
-  console.log(chalk.gray('Current Phase:'), currentPhase);
-  console.log(chalk.gray('Target Phase:'), targetPhase);
-  console.log('');
-
-  if (outputsToReset.length > 0) {
-    console.log(chalk.yellow('Outputs that will be marked as draft:'));
-    outputsToReset.forEach(o => {
-      console.log(chalk.gray(`  - ${o}`));
-    });
-    console.log('');
-  }
-
-  // Confirm unless --force
-  if (!options.force) {
-    console.log(chalk.yellow('⚠️  This will:'));
-    console.log(chalk.gray('  1. Set phase back to: ' + targetPhase));
-    console.log(chalk.gray('  2. Reset task progress'));
-    console.log(chalk.gray('  3. Mark outputs as not created (files remain on disk)'));
-    console.log('');
-    console.log(chalk.gray('Run with --force to confirm.'));
-    process.exit(1);
-  }
-
-  // Perform rollback
-  try {
-    const state = loadState();
-
-    // Update phase
-    state.features[feature].phase = targetPhase;
-    state.features[feature].status = 'in_progress';
-    state.features[feature].updatedAt = new Date().toISOString();
-
-    // Reset outputs
-    for (const output of outputsToReset) {
-      if (state.features[feature].outputs[output]) {
-        state.features[feature].outputs[output].created = false;
-      }
-    }
-
-    // Reset tasks if rolling back before tasks phase
-    if (targetIndex < getPhaseIndex('tasks')) {
-      state.features[feature].tasks = {
-        total: 0,
-        completed: 0,
-        inProgress: 0,
-        pending: 0
-      };
-    }
-
-    // Add checkpoint for rollback
-    state.features[feature].checkpoints = state.features[feature].checkpoints || [];
-    state.features[feature].checkpoints.push({
-      timestamp: new Date().toISOString(),
-      phase: targetPhase,
-      completedTasks: 0,
-      note: `Rollback from ${currentPhase} to ${targetPhase}`
-    });
-
-    // Track skipped phases (if any were skipped)
-    if (!state.features[feature].skippedPhases) {
-      state.features[feature].skippedPhases = [];
-    }
-
-    saveState(state);
-
-    console.log(chalk.green('✅ Rollback completed!'));
-    console.log('');
-    console.log(chalk.gray('Current state:'));
-    console.log(chalk.gray(`  Phase: ${targetPhase}`));
-    console.log(chalk.gray(`  Status: in_progress`));
-    console.log('');
-    console.log(chalk.cyan('Next steps:'));
-    console.log(chalk.gray(`  1. Review and update outputs for phase: ${targetPhase}`));
-    console.log(chalk.gray(`  2. Run: morph-spec session-summary ${feature}`));
-
-  } catch (error) {
-    console.log(chalk.red(`❌ Rollback failed: ${error.message}`));
-    process.exit(1);
-  }
-}
+/**
+ * MORPH-SPEC Rollback Phase Command
+ *
+ * Rolls back a feature to a previous phase, marking outputs as draft.
+ *
+ * Usage:
+ *   morph-spec rollback <feature-name> <target-phase>
+ *
+ * Example:
+ *   morph-spec rollback scheduled-reports design
+ */
+
+import fs from 'fs';
+import path from 'path';
+import chalk from 'chalk';
+import { loadState, saveState, getFeature, updateFeature } from '../lib/state-manager.js';
+
+// Phase order
+const PHASE_ORDER = ['proposal', 'setup', 'uiux', 'design', 'clarify', 'tasks', 'implement', 'sync'];
+
+/**
+ * Get phase index
+ */
+function getPhaseIndex(phase) {
+  return PHASE_ORDER.indexOf(phase);
+}
+
+/**
+ * Get outputs that should be marked as draft when rolling back
+ */
+function getOutputsToReset(fromPhase, toPhase) {
+  const fromIndex = getPhaseIndex(fromPhase);
+  const toIndex = getPhaseIndex(toPhase);
+
+  // Map phases to their outputs
+  const phaseOutputs = {
+    'proposal': ['proposal'],
+    'setup': [],
+    'uiux': ['uiDesignSystem', 'uiMockups', 'uiComponents', 'uiFlows'],
+    'design': ['spec', 'contracts', 'decisions'],
+    'clarify': [],
+    'tasks': ['tasks'],
+    'implement': ['recap'],
+    'sync': []
+  };
+
+  const outputsToReset = [];
+
+  // Collect all outputs from phases after target
+  for (let i = toIndex + 1; i <= fromIndex; i++) {
+    const phase = PHASE_ORDER[i];
+    if (phaseOutputs[phase]) {
+      outputsToReset.push(...phaseOutputs[phase]);
+    }
+  }
+
+  return outputsToReset;
+}
+
+/**
+ * Main command handler
+ */
+export async function rollbackPhaseCommand(feature, targetPhase, options = {}) {
+  console.log(chalk.cyan('\n╔════════════════════════════════════════════════╗'));
+  console.log(chalk.cyan('║     MORPH-SPEC ROLLBACK                        ║'));
+  console.log(chalk.cyan('╚════════════════════════════════════════════════╝\n'));
+
+  // Validate target phase
+  if (!PHASE_ORDER.includes(targetPhase)) {
+    console.log(chalk.red(`❌ Invalid phase: ${targetPhase}`));
+    console.log(chalk.gray('\nValid phases:'));
+    PHASE_ORDER.forEach(p => console.log(chalk.gray(`  - ${p}`)));
+    process.exit(1);
+  }
+
+  // Get current feature state
+  let featureState;
+  try {
+    featureState = getFeature(feature);
+  } catch (error) {
+    console.log(chalk.red(`❌ Feature not found: ${feature}`));
+    console.log(chalk.gray('  Run: morph-spec state list'));
+    process.exit(1);
+  }
+
+  if (!featureState) {
+    console.log(chalk.red(`❌ Feature not found: ${feature}`));
+    process.exit(1);
+  }
+
+  const currentPhase = featureState.phase || 'proposal';
+  const currentIndex = getPhaseIndex(currentPhase);
+  const targetIndex = getPhaseIndex(targetPhase);
+
+  // Check if rollback makes sense
+  if (targetIndex >= currentIndex) {
+    console.log(chalk.yellow(`⚠️  Cannot rollback: target phase '${targetPhase}' is not before current phase '${currentPhase}'`));
+    process.exit(1);
+  }
+
+  // Get outputs to reset
+  const outputsToReset = getOutputsToReset(currentPhase, targetPhase);
+
+  // Show what will happen
+  console.log(chalk.gray('Feature:'), feature);
+  console.log(chalk.gray('Current Phase:'), currentPhase);
+  console.log(chalk.gray('Target Phase:'), targetPhase);
+  console.log('');
+
+  if (outputsToReset.length > 0) {
+    console.log(chalk.yellow('Outputs that will be marked as draft:'));
+    outputsToReset.forEach(o => {
+      console.log(chalk.gray(`  - ${o}`));
+    });
+    console.log('');
+  }
+
+  // Confirm unless --force
+  if (!options.force) {
+    console.log(chalk.yellow('⚠️  This will:'));
+    console.log(chalk.gray('  1. Set phase back to: ' + targetPhase));
+    console.log(chalk.gray('  2. Reset task progress'));
+    console.log(chalk.gray('  3. Mark outputs as not created (files remain on disk)'));
+    console.log('');
+    console.log(chalk.gray('Run with --force to confirm.'));
+    process.exit(1);
+  }
+
+  // Perform rollback
+  try {
+    const state = loadState();
+
+    // Update phase
+    state.features[feature].phase = targetPhase;
+    state.features[feature].status = 'in_progress';
+    state.features[feature].updatedAt = new Date().toISOString();
+
+    // Reset outputs
+    for (const output of outputsToReset) {
+      if (state.features[feature].outputs[output]) {
+        state.features[feature].outputs[output].created = false;
+      }
+    }
+
+    // Reset tasks if rolling back before tasks phase
+    if (targetIndex < getPhaseIndex('tasks')) {
+      state.features[feature].tasks = {
+        total: 0,
+        completed: 0,
+        inProgress: 0,
+        pending: 0
+      };
+    }
+
+    // Add checkpoint for rollback
+    state.features[feature].checkpoints = state.features[feature].checkpoints || [];
+    state.features[feature].checkpoints.push({
+      timestamp: new Date().toISOString(),
+      phase: targetPhase,
+      completedTasks: 0,
+      note: `Rollback from ${currentPhase} to ${targetPhase}`
+    });
+
+    // Track skipped phases (if any were skipped)
+    if (!state.features[feature].skippedPhases) {
+      state.features[feature].skippedPhases = [];
+    }
+
+    saveState(state);
+
+    console.log(chalk.green('✅ Rollback completed!'));
+    console.log('');
+    console.log(chalk.gray('Current state:'));
+    console.log(chalk.gray(`  Phase: ${targetPhase}`));
+    console.log(chalk.gray(`  Status: in_progress`));
+    console.log('');
+    console.log(chalk.cyan('Next steps:'));
+    console.log(chalk.gray(`  1. Review and update outputs for phase: ${targetPhase}`));
+    console.log(chalk.gray(`  2. Run: morph-spec session-summary ${feature}`));
+
+  } catch (error) {
+    console.log(chalk.red(`❌ Rollback failed: ${error.message}`));
+    process.exit(1);
+  }
+}

package/src/commands/search-patterns.js

@@ -0,0 +1,126 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { readFileSync, existsSync } from 'fs';
+import { join } from 'path';
+
+/**
+ * Search Patterns Command - Find relevant patterns
+ *
+ * Searches patterns-learned.md for keywords
+ */
+
+const program = new Command();
+
+program
+  .name('search-patterns')
+  .description('Search for patterns by keyword')
+  .argument('<keyword>', 'Keyword to search for')
+  .option('--category <category>', 'Filter by category')
+  .option('--limit <number>', 'Limit number of results', '10')
+  .option('--json', 'Output as JSON', false)
+  .action(async (keyword, options) => {
+    try {
+      // Get patterns file path
+      const patternsPath = join(process.cwd(), '.morph/memory/patterns-learned.md');
+
+      if (!existsSync(patternsPath)) {
+        console.error(chalk.red(`\n❌ Patterns file not found: ${patternsPath}`));
+        console.log(chalk.yellow('No patterns learned yet. Complete some features first!\n'));
+        process.exit(1);
+      }
+
+      // Read patterns file
+      const content = readFileSync(patternsPath, 'utf8');
+
+      // Split into pattern sections
+      const sections = content.split('---').filter(s => s.trim().length > 0);
+
+      // Search patterns
+      const keywordLower = keyword.toLowerCase();
+      const matches = [];
+
+      sections.forEach(section => {
+        if (section.toLowerCase().includes(keywordLower)) {
+          // Extract pattern name
+          const nameMatch = section.match(/## Pattern: (.+)/);
+          const categoryMatch = section.match(/\*\*Category:\*\* (.+)/);
+          const sourceMatch = section.match(/\*\*Source:\*\* (.+)/);
+
+          if (nameMatch) {
+            const patternName = nameMatch[1].trim();
+            const category = categoryMatch ? categoryMatch[1].trim() : 'Unknown';
+            const source = sourceMatch ? sourceMatch[1].trim() : 'Unknown';
+
+            // Filter by category if specified
+            if (options.category && !category.toLowerCase().includes(options.category.toLowerCase())) {
+              return;
+            }
+
+            matches.push({
+              name: patternName,
+              category,
+              source,
+              content: section.trim(),
+              preview: section.substring(0, 300).trim() + '...'
+            });
+          }
+        }
+      });
+
+      // Limit results
+      const limit = parseInt(options.limit, 10);
+      const limitedMatches = matches.slice(0, limit);
+
+      if (options.json) {
+        // JSON output
+        console.log(JSON.stringify({ keyword, matches: limitedMatches, total: matches.length }, null, 2));
+        return;
+      }
+
+      // Pretty output
+      if (limitedMatches.length === 0) {
+        console.log(chalk.yellow(`\n⚠️  No patterns found for keyword: "${keyword}"\n`));
+        console.log(chalk.gray('Try a different keyword or broader search term.\n'));
+        return;
+      }
+
+      console.log(chalk.bold(`\n🔍 Found ${matches.length} pattern(s) for: "${keyword}"`));
+      if (matches.length > limit) {
+        console.log(chalk.gray(`Showing first ${limit} results (use --limit to see more)\n`));
+      }
+      console.log('━'.repeat(60));
+
+      limitedMatches.forEach((match, index) => {
+        console.log(chalk.green(`\n${index + 1}. ${match.name}`));
+        console.log(chalk.cyan(`   Category: ${match.category}`));
+        console.log(chalk.gray(`   Source: ${match.source}`));
+
+        // Show first few lines of the pattern
+        const lines = match.content.split('\n').slice(0, 15);
+        console.log(chalk.gray('\n   ' + lines.join('\n   ')));
+
+        if (match.content.split('\n').length > 15) {
+          console.log(chalk.gray(`   ... (see full pattern in ${patternsPath})`));
+        }
+      });
+
+      console.log('\n' + '━'.repeat(60));
+      console.log(chalk.bold('\n💡 Usage:'));
+      console.log(chalk.gray(`   Edit ${patternsPath} to see full pattern details\n`));
+
+    } catch (error) {
+      console.error(chalk.red(`\n❌ Error searching patterns: ${error.message}\n`));
+      process.exit(1);
+    }
+  });
+
+// Only parse if run directly (not imported as module)
+if (import.meta.url === `file://${process.argv[1]}`) {
+  if (process.argv.length > 2) {
+    program.parse(process.argv);
+  } else {
+    program.help();
+  }
+}
+
+export default program;