@polymorphism-tech/morph-spec 3.1.0 → 4.2.0

package/src/commands/feature/index.js

@@ -0,0 +1,6 @@
+/**
+ * Feature Management Commands
+ */
+export { createStoryCommand } from './create-story.js';
+export { shardSpecCommand } from './shard-spec.js';
+export { sprintStatusCommand } from './sprint-status.js';

package/src/commands/{shard-spec.js → feature/shard-spec.js}

@@ -8,8 +8,8 @@ import fs from 'fs';
 import path from 'path';
 import ora from 'ora';
 import chalk from 'chalk';
-import { logger } from '../utils/logger.js';
-import { ensureDir, writeFile } from '../utils/file-copier.js';
+import { logger } from '../../utils/logger.js';
+import { ensureDir, writeFile } from '../../utils/file-copier.js';
 
 // ============================================================================
 // Helper Functions

package/src/commands/{sprint-status.js → feature/sprint-status.js}

@@ -8,7 +8,7 @@ import path from 'path';
 import yaml from 'yaml';
 import ora from 'ora';
 import chalk from 'chalk';
-import { logger } from '../utils/logger.js';
+import { logger } from '../../utils/logger.js';
 
 // ============================================================================
 // Helper Functions

package/src/commands/{generate-context.js → generation/generate-context.js}

@@ -1,40 +1,40 @@
-/**
- * @fileoverview Generate Context Command
- *
- * CLI: morph-spec generate context [feature]
- *
- * Generates CONTEXT.md (project-level) or CONTEXT-{feature}.md (feature-level)
- * with all relevant project data for Claude's consumption.
- *
- * @module generate-context
- */
-
-import { generateContext } from '../lib/context-generator.js';
-
-/**
- * Generate context files
- * @param {string} projectPath - Root path of the project
- * @param {string} featureName - Optional feature name
- * @returns {Promise<void>}
- */
-export async function generateContextCommand(projectPath, featureName = null) {
-  console.log('📄 Generating CONTEXT files...\n');
-
-  try {
-    const results = await generateContext(projectPath, featureName);
-
-    console.log('✅ Generated:');
-    console.log(`   - ${results.projectContext}`);
-
-    if (results.featureContext) {
-      console.log(`   - ${results.featureContext}`);
-    }
-
-    console.log('\n💡 Use these files to provide full context to Claude Code.');
-
-  } catch (err) {
-    console.error('❌ Error generating context:');
-    console.error(`   ${err.message}`);
-    process.exit(1);
-  }
-}
+/**
+ * @fileoverview Generate Context Command
+ *
+ * CLI: morph-spec generate context [feature]
+ *
+ * Generates CONTEXT.md (project-level) or CONTEXT-{feature}.md (feature-level)
+ * with all relevant project data for Claude's consumption.
+ *
+ * @module generate-context
+ */
+
+import { generateContext } from '../../lib/generators/context-generator.js';
+
+/**
+ * Generate context files
+ * @param {string} projectPath - Root path of the project
+ * @param {string} featureName - Optional feature name
+ * @returns {Promise<void>}
+ */
+export async function generateContextCommand(projectPath, featureName = null) {
+  console.log('📄 Generating CONTEXT files...\n');
+
+  try {
+    const results = await generateContext(projectPath, featureName);
+
+    console.log('✅ Generated:');
+    console.log(`   - ${results.projectContext}`);
+
+    if (results.featureContext) {
+      console.log(`   - ${results.featureContext}`);
+    }
+
+    console.log('\n💡 Use these files to provide full context to Claude Code.');
+
+  } catch (err) {
+    console.error('❌ Error generating context:');
+    console.error(`   ${err.message}`);
+    process.exit(1);
+  }
+}

package/src/commands/{generate.js → generation/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 { logger } from '../../utils/logger.js';
+import * as DesignSystemGenerator from '../../lib/generators/design-system-generator.js';
+import { getFeature } from '../../core/state/state-manager.js';
+import { extractFeatureMetadata } from '../../lib/generators/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/generation/index.js

@@ -0,0 +1,5 @@
+/**
+ * Code/Documentation Generation Commands
+ */
+export { generateCommand } from './generate.js';
+export { generateContextCommand } from './generate-context.js';

package/src/commands/index.js

@@ -0,0 +1,16 @@
+/**
+ * All Commands - Category Exports
+ *
+ * Commands organized by functional category.
+ */
+
+export * from './feature/index.js';
+export * from './state/index.js';
+export * from './generation/index.js';
+export * from './validation/index.js';
+export * from './templates/index.js';
+export * from './project/index.js';
+export * from './learning/index.js';
+export * from './tasks/index.js';
+export * from './agents/index.js';
+export * from './utils/index.js';

package/src/commands/learning/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/learning/index.js

@@ -0,0 +1,5 @@
+/**
+ * Pattern Learning Commands
+ */
+export { capturePatternCommand } from './capture-pattern.js';
+export { searchPatternsCommand } from './search-patterns.js';

package/src/commands/learning/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;