@polymorphism-tech/morph-spec 3.1.0 → 4.2.0

package/src/commands/utils/upgrade.js

@@ -0,0 +1,346 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { execSync } from 'child_process';
+
+/**
+ * Upgrade Command - Upgrade MORPH-SPEC project to v3.0
+ *
+ * Orchestrates:
+ * - State migration (add approval gates)
+ * - llm-interaction.json creation
+ * - patterns-learned.md creation
+ * - Documentation updates
+ */
+
+const program = new Command();
+
+program
+  .name('upgrade')
+  .description('Upgrade MORPH-SPEC project to v3.0')
+  .option('--to-version <version>', 'Target version (default: 3.0.0)', '3.0.0')
+  .option('--preset <preset>', 'Configuration preset (strict | lightweight | no-guardrails)', 'strict')
+  .option('--dry-run', 'Preview changes without writing')
+  .option('--force', 'Skip confirmations')
+  .action(async (options) => {
+    try {
+      console.log(chalk.cyan(`
+███████╗ MORPH-SPEC Upgrade
+╚══════╝ Upgrading to v${options.toVersion}
+`));
+
+      // Validate project
+      if (!existsSync(join(process.cwd(), '.morph'))) {
+        console.error(chalk.red('❌ No .morph directory found'));
+        console.log(chalk.yellow('   This does not appear to be a MORPH-SPEC project.\n'));
+        process.exit(1);
+      }
+
+      // Read current state
+      const statePath = join(process.cwd(), '.morph/state.json');
+      if (!existsSync(statePath)) {
+        console.error(chalk.red('❌ No state.json found'));
+        console.log(chalk.yellow('   Run "morph-spec init" first.\n'));
+        process.exit(1);
+      }
+
+      const state = JSON.parse(readFileSync(statePath, 'utf8'));
+      const currentVersion = state.version || '2.0.0';
+
+      console.log(chalk.gray(`Current version: ${currentVersion}`));
+      console.log(chalk.gray(`Target version: ${options.toVersion}\n`));
+
+      // Check if upgrade needed
+      if (currentVersion === options.toVersion) {
+        console.log(chalk.green(`✅ Already at v${options.toVersion}\n`));
+        process.exit(0);
+      }
+
+      // Upgrade steps
+      const steps = [
+        { name: 'Migrate state.json', fn: migrateState },
+        { name: 'Create llm-interaction.json', fn: createLLMConfig },
+        { name: 'Create patterns-learned.md', fn: createPatternsLibrary },
+        { name: 'Update CLAUDE.md', fn: updateClaudeMd },
+        { name: 'Create metadata directory', fn: createMetadataDir }
+      ];
+
+      console.log(chalk.bold('📋 Upgrade Plan:\n'));
+      steps.forEach((step, i) => {
+        console.log(chalk.cyan(`   ${i + 1}. ${step.name}`));
+      });
+      console.log('');
+
+      if (options.dryRun) {
+        console.log(chalk.yellow('🔍 DRY RUN - No changes will be written\n'));
+      }
+
+      if (!options.force && !options.dryRun) {
+        console.log(chalk.yellow('⚠️  This will modify your project'));
+        console.log(chalk.gray('   Backups will be created for modified files\n'));
+        console.log(chalk.gray('   Press Ctrl+C to cancel, or run with --force to skip confirmation.\n'));
+        // In real implementation, use inquirer for confirmation
+      }
+
+      // Execute steps
+      const results = [];
+      for (const [index, step] of steps.entries()) {
+        console.log(chalk.cyan(`\n[${index + 1}/${steps.length}] ${step.name}...`));
+
+        try {
+          const result = await step.fn(options);
+          results.push({ step: step.name, status: 'success', result });
+          console.log(chalk.green(`✅ ${step.name} complete`));
+        } catch (error) {
+          results.push({ step: step.name, status: 'failed', error: error.message });
+          console.log(chalk.red(`❌ ${step.name} failed: ${error.message}`));
+
+          if (!options.force) {
+            console.log(chalk.yellow('\nUpgrade halted due to error.'));
+            console.log(chalk.gray('Run with --force to continue despite errors.\n'));
+            process.exit(1);
+          }
+        }
+      }
+
+      // Summary
+      console.log(chalk.bold('\n\n📊 Upgrade Summary:\n'));
+
+      const succeeded = results.filter(r => r.status === 'success').length;
+      const failed = results.filter(r => r.status === 'failed').length;
+
+      results.forEach(result => {
+        const icon = result.status === 'success' ? '✅' : '❌';
+        const color = result.status === 'success' ? chalk.green : chalk.red;
+        console.log(color(`   ${icon} ${result.step}`));
+
+        if (result.status === 'failed') {
+          console.log(chalk.gray(`      Error: ${result.error}`));
+        }
+      });
+
+      console.log('');
+
+      if (failed === 0) {
+        console.log(chalk.green.bold('🎉 Upgrade to v3.0 complete!\n'));
+
+        console.log(chalk.bold('Next steps:\n'));
+        console.log(chalk.gray('1. Review .morph/config/llm-interaction.json'));
+        console.log(chalk.gray('2. Read docs/llm-interaction-config.md for configuration options'));
+        console.log(chalk.gray('3. Try new features:'));
+        console.log(chalk.gray('   - npx morph-spec search-patterns "{keyword}"'));
+        console.log(chalk.gray('   - npx morph-spec approve {feature} design'));
+        console.log(chalk.gray('   - npx morph-spec spawn-team {feature}'));
+        console.log(chalk.gray('4. Continue development with v3.0 workflow\n'));
+      } else {
+        console.log(chalk.yellow(`⚠️  Upgrade completed with ${failed} error(s)\n`));
+        console.log(chalk.gray('Review errors above and fix manually.\n'));
+        process.exit(1);
+      }
+
+    } catch (error) {
+      console.error(chalk.red(`\n❌ Upgrade failed: ${error.message}\n`));
+      process.exit(1);
+    }
+  });
+
+/**
+ * Step 1: Migrate state.json
+ */
+async function migrateState(options) {
+  const migrateCommand = options.dryRun
+    ? 'npx morph-spec migrate-state --dry-run --force'
+    : 'npx morph-spec migrate-state --force';
+
+  try {
+    execSync(migrateCommand, { cwd: process.cwd(), stdio: 'pipe' });
+    return { featuresUpdated: 'N/A' };
+  } catch (error) {
+    // If migrate-state doesn't exist yet, do inline migration
+    const statePath = join(process.cwd(), '.morph/state.json');
+    const state = JSON.parse(readFileSync(statePath, 'utf8'));
+
+    let featuresUpdated = 0;
+
+    Object.values(state.features || {}).forEach(feature => {
+      if (!feature.approvalGates) {
+        feature.approvalGates = {
+          proposal: { approved: true, timestamp: new Date().toISOString(), approvedBy: 'auto-migration' },
+          uiux: { approved: false, timestamp: null, approvedBy: null },
+          design: { approved: true, timestamp: new Date().toISOString(), approvedBy: 'auto-migration' },
+          tasks: { approved: true, timestamp: new Date().toISOString(), approvedBy: 'auto-migration' }
+        };
+        featuresUpdated++;
+      }
+    });
+
+    state.version = '3.0.0';
+
+    if (!options.dryRun) {
+      writeFileSync(`${statePath}.backup`, readFileSync(statePath));
+      writeFileSync(statePath, JSON.stringify(state, null, 2));
+    }
+
+    return { featuresUpdated };
+  }
+}
+
+/**
+ * Step 2: Create llm-interaction.json
+ */
+async function createLLMConfig(options) {
+  const configPath = join(process.cwd(), '.morph/config/llm-interaction.json');
+
+  // Choose preset
+  const presets = {
+    strict: {
+      approvalGates: { enabled: true, required: ['design', 'tasks'], allowSkip: false },
+      checkpoints: { frequency: 3, autoValidate: true, onFailure: { blockProgress: true } },
+      phaseValidation: { strictTransitions: true, requireContentValidation: true },
+      agentSpawning: { enabled: true, teamMode: 'auto' },
+      metadata: { autoGenerate: true },
+      patterns: { searchBeforeStart: true, captureOnComplete: true },
+      interactiveDecisions: { enabled: true }
+    },
+    lightweight: {
+      approvalGates: { enabled: true, required: ['design'], allowSkip: true },
+      checkpoints: { frequency: 5, autoValidate: true, onFailure: { blockProgress: false } },
+      phaseValidation: { strictTransitions: true, allowPhaseSkip: true },
+      agentSpawning: { enabled: false },
+      metadata: { autoGenerate: false },
+      patterns: { searchBeforeStart: true, captureOnComplete: false },
+      interactiveDecisions: { enabled: true }
+    },
+    'no-guardrails': {
+      approvalGates: { enabled: false },
+      checkpoints: { autoValidate: false },
+      phaseValidation: { strictTransitions: false, allowPhaseSkip: true },
+      agentSpawning: { enabled: false },
+      metadata: { autoGenerate: false },
+      patterns: { searchBeforeStart: false, captureOnComplete: false },
+      interactiveDecisions: { enabled: false }
+    }
+  };
+
+  const preset = presets[options.preset] || presets.strict;
+
+  const config = {
+    version: '1.0.0',
+    enabled: true,
+    ...preset,
+    checkpoints: {
+      ...preset.checkpoints,
+      validators: { enabled: ['architecture', 'packages', 'design-system', 'security'] },
+      hooks: { runTests: false, runLinters: true, buildCheck: false },
+      onFailure: { ...preset.checkpoints.onFailure, maxRetries: 3 }
+    },
+    agentSpawning: {
+      ...preset.agentSpawning,
+      autoDetect: true,
+      spawnThreshold: { complexity: 'high', fileCount: 15, multiDomain: true, agentCount: 5 }
+    },
+    metadata: { ...preset.metadata, updateFrequency: 'on_task_done' },
+    patterns: { ...preset.patterns, location: '.morph/memory/patterns-learned.md' },
+    templates: { mcpDataInjection: true, dataSources: ['projectStructure', 'complianceStatus', 'recentActivity'] },
+    interactiveDecisions: {
+      ...preset.interactiveDecisions,
+      usePromptTemplates: true,
+      requireUserInput: ['architecture-choice', 'scope-change', 'validator-override']
+    }
+  };
+
+  if (!options.dryRun) {
+    mkdirSync(join(process.cwd(), '.morph/config'), { recursive: true });
+    writeFileSync(configPath, JSON.stringify(config, null, 2));
+  }
+
+  return { preset: options.preset, path: configPath };
+}
+
+/**
+ * Step 3: Create patterns-learned.md
+ */
+async function createPatternsLibrary(options) {
+  const patternsPath = join(process.cwd(), '.morph/memory/patterns-learned.md');
+
+  if (existsSync(patternsPath)) {
+    return { status: 'already exists' };
+  }
+
+  const initialContent = `# Patterns Learned
+
+This file tracks reusable patterns, lessons learned, and anti-patterns discovered during development.
+
+**Usage:**
+- Search: \`npx morph-spec search-patterns "{keyword}"\`
+- Capture: \`npx morph-spec capture-pattern {feature} {category} "Description"\`
+
+---
+
+## Pre-Seeded Framework Patterns
+
+See framework/.morph/memory/patterns-learned.md for standard patterns.
+
+---
+`;
+
+  if (!options.dryRun) {
+    mkdirSync(join(process.cwd(), '.morph/memory'), { recursive: true });
+    writeFileSync(patternsPath, initialContent);
+  }
+
+  return { path: patternsPath };
+}
+
+/**
+ * Step 4: Update CLAUDE.md
+ */
+async function updateClaudeMd(options) {
+  const claudePath = join(process.cwd(), 'CLAUDE.md');
+
+  if (!existsSync(claudePath)) {
+    return { status: 'not found, skipped' };
+  }
+
+  const content = readFileSync(claudePath, 'utf8');
+
+  // Check if already updated
+  if (content.includes('## APPROVAL GATES')) {
+    return { status: 'already up-to-date' };
+  }
+
+  // Add note about v3.0 features
+  const note = `\n---\n\n> **MORPH-SPEC v3.0 Features:** This project now supports approval gates, checkpoint automation, pattern learning, and metadata generation. See \`.morph/config/llm-interaction.json\` for configuration.\n\n---\n`;
+
+  if (!options.dryRun) {
+    writeFileSync(`${claudePath}.backup`, content);
+    writeFileSync(claudePath, content + note);
+  }
+
+  return { status: 'updated with v3.0 note' };
+}
+
+/**
+ * Step 5: Create metadata output directory
+ */
+async function createMetadataDir(options) {
+  const metadataDir = join(process.cwd(), '.morph/project/outputs');
+
+  if (!options.dryRun) {
+    mkdirSync(metadataDir, { recursive: true });
+  }
+
+  return { path: metadataDir };
+}
+
+// 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;