@polymorphism-tech/morph-spec 3.1.0 → 3.2.0

package/src/commands/capture-pattern.js

@@ -0,0 +1,121 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { appendFileSync, existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+
+/**
+ * Capture Pattern Command - Document lessons learned
+ *
+ * Appends patterns to patterns-learned.md for future reference
+ */
+
+const program = new Command();
+
+const VALID_CATEGORIES = ['success', 'avoid', 'optimization', 'security', 'convention', 'best-practice'];
+
+program
+  .name('capture-pattern')
+  .description('Capture a pattern or lesson learned from a feature')
+  .argument('<feature>', 'Feature name')
+  .argument('<category>', `Pattern category (${VALID_CATEGORIES.join(', ')})`)
+  .argument('<description>', 'Brief description of the pattern')
+  .option('--auto', 'Auto-capture without opening editor', false)
+  .action(async (featureName, category, description, options) => {
+    try {
+      // Validate category
+      if (!VALID_CATEGORIES.includes(category)) {
+        console.error(chalk.red(`\n❌ Invalid category: ${category}`));
+        console.log(chalk.gray(`Valid categories: ${VALID_CATEGORIES.join(', ')}\n`));
+        process.exit(1);
+      }
+
+      // 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('Run "morph-spec init" to create the file.\n'));
+        process.exit(1);
+      }
+
+      // Create pattern entry
+      const timestamp = new Date().toISOString().split('T')[0];
+      const categoryDisplay = category === 'avoid' ? 'Anti-Pattern to Avoid' :
+                              category === 'success' ? 'Best Practice' :
+                              category === 'optimization' ? 'Performance Optimization' :
+                              category === 'security' ? 'Security Best Practice' :
+                              category === 'convention' ? 'Convention' :
+                              'Best Practice';
+
+      const patternTemplate = `
+
+---
+
+## Pattern: ${description}
+
+**Source:** Feature \`${featureName}\` (${timestamp})
+**Category:** ${categoryDisplay}
+**Date:** ${timestamp}
+
+**Problem:**
+[Describe the problem this pattern solves]
+
+**Implementation:**
+\`\`\`csharp
+// Add code example here
+\`\`\`
+
+**Why:**
+- [Reason 1]
+- [Reason 2]
+
+**When to Use:**
+[Describe scenarios where this pattern applies]
+
+**Reuse:** [List features/scenarios where this can be reused]
+
+---
+`;
+
+      // Append to file
+      appendFileSync(patternsPath, patternTemplate, 'utf8');
+
+      console.log(chalk.green(`\n✅ Pattern captured successfully`));
+      console.log(chalk.cyan(`   Feature: ${featureName}`));
+      console.log(chalk.cyan(`   Category: ${categoryDisplay}`));
+      console.log(chalk.cyan(`   Description: ${description}\n`));
+
+      if (!options.auto) {
+        console.log(chalk.bold('📝 Next Steps:'));
+        console.log(chalk.gray(`1. Edit ${patternsPath}`));
+        console.log(chalk.gray('2. Fill in: Problem, Implementation (code), Why, When to Use'));
+        console.log(chalk.gray('3. Add code examples and rationale\n'));
+      }
+
+      // Show location in file
+      const content = readFileSync(patternsPath, 'utf8');
+      const lines = content.split('\n');
+      const patternLine = lines.findIndex(line => line.includes(`Pattern: ${description}`));
+
+      if (patternLine !== -1) {
+        console.log(chalk.gray(`Pattern added at line ${patternLine + 1}`));
+      }
+
+      console.log(chalk.gray(`\nFile: ${patternsPath}\n`));
+
+    } catch (error) {
+      console.error(chalk.red(`\n❌ Error capturing pattern: ${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/generate.js

@@ -4,11 +4,13 @@
  */
 
 import { mkdirSync, writeFileSync } from 'fs';
-import { dirname } from 'path';
+import { dirname, join } from 'path';
 import ora from 'ora';
 import chalk from 'chalk';
 import { logger } from '../utils/logger.js';
 import * as DesignSystemGenerator from '../lib/design-system-generator.js';
+import { getFeature } from '../lib/state-manager.js';
+import { extractFeatureMetadata } from '../lib/metadata-extractor.js';
 
 // ============================================================================
 // Design System Subcommand
@@ -118,6 +120,126 @@ export async function generateDesignSystemCommand(designSystemPath, options) {
   }
 }
 
+// ============================================================================
+// Metadata Subcommand
+// ============================================================================
+
+/**
+ * Generate metadata.json from feature outputs
+ * @param {string} featureName - Feature name
+ * @param {Object} options - CLI options
+ */
+export async function generateMetadataCommand(featureName, options) {
+  if (!featureName) {
+    logger.error('Feature name required');
+    logger.dim('  Usage: morph-spec generate metadata <feature>');
+    logger.blank();
+    logger.dim('  Example:');
+    logger.dim('    morph-spec generate metadata my-feature');
+    process.exit(1);
+  }
+
+  logger.header('MORPH-SPEC Metadata Generator');
+  logger.blank();
+
+  const spinner = ora('Extracting metadata...').start();
+
+  try {
+    // Get feature state
+    const feature = getFeature(featureName);
+    if (!feature) {
+      spinner.fail('Feature not found');
+      logger.error(`Feature not found: ${featureName}`);
+      process.exit(1);
+    }
+
+    // Extract metadata
+    const metadata = extractFeatureMetadata(feature);
+
+    spinner.succeed('Metadata extracted!');
+    logger.blank();
+
+    // Display summary
+    logger.header('Feature Summary:');
+    logger.info(`Feature: ${chalk.cyan(metadata.feature)}`);
+    logger.info(`Phase: ${chalk.cyan(metadata.phase)}`);
+    logger.info(`Status: ${chalk.cyan(metadata.status)}`);
+
+    if (metadata.progress) {
+      const progressBar = '█'.repeat(Math.floor(metadata.progress.percentage / 5)) +
+                         '░'.repeat(20 - Math.floor(metadata.progress.percentage / 5));
+      logger.info(`Progress: ${chalk.cyan(`${metadata.progress.completed}/${metadata.progress.total}`)} ${progressBar} ${chalk.cyan(metadata.progress.percentage + '%')}`);
+    }
+
+    logger.info(`Active Agents: ${chalk.cyan(metadata.agents.length)}`);
+    logger.info(`Checkpoints: ${chalk.cyan(metadata.checkpoints.length)}`);
+    logger.blank();
+
+    // Show outputs
+    logger.header('Outputs Extracted:');
+    Object.entries(metadata.outputs).forEach(([type, data]) => {
+      if (data.error) {
+        logger.error(`  ✗ ${type}: ${data.error}`);
+      } else {
+        logger.success(`  ✓ ${type}`);
+
+        // Show key stats
+        if (type === 'spec' && data.summary) {
+          logger.dim(`    Tags: ${data.summary.tags.join(', ')}`);
+        }
+        if (type === 'decisions' && data.total) {
+          logger.dim(`    Decisions: ${data.total} ADRs`);
+        }
+        if (type === 'tasks' && data.total) {
+          logger.dim(`    Tasks: ${data.total} (${data.regularTasks} regular + ${data.checkpoints} checkpoints)`);
+        }
+      }
+    });
+    logger.blank();
+
+    if (options.dryRun) {
+      logger.warn('Dry run - file not written');
+      logger.blank();
+      return;
+    }
+
+    // Determine output path
+    const outputPath = options.output ||
+      join(process.cwd(), `.morph/project/outputs/${featureName}/metadata.json`);
+
+    // Write metadata
+    const writeSpinner = ora('Writing metadata.json...').start();
+
+    mkdirSync(dirname(outputPath), { recursive: true });
+
+    const jsonContent = options.pretty !== false
+      ? JSON.stringify(metadata, null, 2)
+      : JSON.stringify(metadata);
+
+    writeFileSync(outputPath, jsonContent, 'utf8');
+
+    writeSpinner.succeed('Metadata generated!');
+    logger.blank();
+
+    logger.success(`  ✓ ${outputPath}`);
+    logger.blank();
+
+    // Usage tip
+    logger.header('💡 Usage:');
+    logger.dim(`   cat ${outputPath}`);
+    logger.dim(`   # Quick status check - no need to read full markdown files`);
+    logger.blank();
+
+  } catch (error) {
+    spinner.fail('Generation failed');
+    logger.error(error.message);
+    if (error.stack) {
+      logger.dim(error.stack);
+    }
+    process.exit(1);
+  }
+}
+
 // ============================================================================
 // Main Generate Command (router for future subcommands)
 // ============================================================================
@@ -132,6 +254,10 @@ export async function generateCommand(subcommand, args, options) {
       await generateDesignSystemCommand(args[0], options);
       break;
 
+    case 'metadata':
+      await generateMetadataCommand(args[0], options);
+      break;
+
     // Future: Add more generation commands
     // case 'component':
     //   await generateComponentCommand(args[0], options);
@@ -142,6 +268,7 @@ export async function generateCommand(subcommand, args, options) {
       logger.blank();
       logger.info('Available subcommands:');
       logger.dim('  design-system    Generate CSS + theme files from ui-design-system.md');
+      logger.dim('  metadata         Generate metadata.json from feature outputs');
       logger.blank();
       logger.dim('Run "morph-spec generate --help" for more information');
       process.exit(1);

package/src/commands/init.js

@@ -18,6 +18,8 @@ import {
   createDirectoryLink
 } from '../utils/file-copier.js';
 import { saveProjectMorphVersion, getInstalledCLIVersion } from '../utils/version-checker.js';
+import { AutoContextOrchestrator } from '../orchestrator.js';
+import { detectClaudeCode } from '../llm/environment-detector.js';
 
 export async function initCommand(options) {
   const targetPath = options.path || process.cwd();
@@ -250,6 +252,41 @@ Run \`morph-spec detect\` to analyze your project.
 
     logger.blank();
 
+    // 12. Auto-detect project context (if Claude Code is available and not --skip-detection)
+    if (!options.skipDetection && detectClaudeCode()) {
+      logger.blank();
+      logger.header('Auto-Detecting Project Context');
+      logger.dim('Using Claude Code LLM to analyze your project...');
+      logger.blank();
+
+      try {
+        const orchestrator = new AutoContextOrchestrator();
+        const result = await orchestrator.execute(targetPath, {
+          skipReview: false,
+          fallbackOnError: true,
+          wizardMode: options.wizard || false
+        });
+
+        if (result.success) {
+          logger.success('Project context detected and saved to .morph/project.md');
+        } else {
+          logger.warn('Auto-detection incomplete. Run "morph-spec update" to retry.');
+        }
+      } catch (error) {
+        logger.warn(`Auto-detection failed: ${error.message}`);
+        logger.dim('You can run "morph-spec update" later to re-analyze your project.');
+      }
+    } else if (options.skipDetection) {
+      logger.dim('\nSkipped auto-detection (--skip-detection flag)');
+      logger.dim('Run "morph-spec update" later to analyze your project.');
+    } else {
+      logger.warn('\n⚠️  Claude Code not detected');
+      logger.dim('Auto-detection requires Claude Code CLI.');
+      logger.dim('Run "morph-spec update --wizard" to configure manually.');
+    }
+
+    logger.blank();
+
   } catch (error) {
     spinner.fail('Installation failed');
     logger.error(error.message);

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/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;