@polymorphism-tech/morph-spec 4.7.2 → 4.8.1

package/src/commands/learning/capture-pattern.js

@@ -1,121 +0,0 @@
-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

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

package/src/commands/learning/search-patterns.js

@@ -1,126 +0,0 @@
-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;

package/src/commands/mcp/mcp.js

@@ -1,102 +0,0 @@
-/**
- * MCP CLI command — MCP server analysis and optimization
- *
- * Usage:
- *   morph-spec mcp optimize
- *   morph-spec mcp list
- */
-
-import chalk from 'chalk';
-import { analyzeMCP } from '../../lib/context/mcp-optimizer.js';
-
-const STATUS_COLORS = {
-  used: chalk.green,
-  unused: chalk.red,
-  unknown: chalk.gray
-};
-
-function formatTokens(n) {
-  return n >= 1000 ? `${(n / 1000).toFixed(1)}K` : String(n);
-}
-
-export async function mcpOptimizeCommand(options) {
-  try {
-    const analysis = analyzeMCP();
-
-    if (!analysis.found) {
-      console.log(chalk.yellow(`\n  ⚠ ${analysis.message}\n`));
-      return;
-    }
-
-    console.log(chalk.cyan('\n  MCP Optimization Analysis\n'));
-    console.log('  ' + '─'.repeat(60));
-
-    console.log(`\n  Settings file: ${chalk.gray(analysis.settingsPath)}`);
-    console.log(`  Total servers: ${analysis.totalServers}`);
-    console.log(`  Total context overhead: ${chalk.yellow(formatTokens(analysis.totalOverhead) + ' tokens')}`);
-
-    if (analysis.unusedCount > 0) {
-      console.log(`  Unused servers: ${chalk.red(analysis.unusedCount)}`);
-      console.log(`  Potential savings: ${chalk.green(formatTokens(analysis.potentialSavings) + ' tokens')}`);
-    }
-
-    if (analysis.recommendations.length === 0) {
-      console.log(chalk.green('\n  ✓ MCP configuration looks optimized!\n'));
-      return;
-    }
-
-    console.log(chalk.yellow('\n  Recommendations:\n'));
-    for (const rec of analysis.recommendations) {
-      console.log(`  ${chalk.bold(rec.title)}`);
-      console.log(`  ${rec.description}`);
-      console.log(`  Savings: ${chalk.green(formatTokens(rec.estimatedSavings) + ' tokens')}`);
-      console.log(`  Action: ${chalk.cyan(rec.action)}`);
-      console.log('');
-    }
-
-    console.log('  ' + '─'.repeat(60));
-    console.log('');
-  } catch (err) {
-    console.error(chalk.red(`Error: ${err.message}`));
-    process.exit(1);
-  }
-}
-
-export async function mcpListCommand(options) {
-  try {
-    const analysis = analyzeMCP();
-
-    if (!analysis.found) {
-      console.log(chalk.yellow(`\n  ⚠ ${analysis.message}\n`));
-      return;
-    }
-
-    if (analysis.servers.length === 0) {
-      console.log(chalk.gray('\n  No MCP servers configured.\n'));
-      return;
-    }
-
-    console.log(chalk.cyan('\n  Configured MCP Servers\n'));
-    console.log('  ' + 'Name'.padEnd(25) + ' ' + 'Status'.padEnd(10) + ' ' + 'Overhead');
-    console.log('  ' + '─'.repeat(50));
-
-    for (const server of analysis.servers) {
-      const colorFn = STATUS_COLORS[server.usageStatus] || chalk.white;
-      console.log(
-        '  ' +
-        server.name.padEnd(25) + ' ' +
-        colorFn(server.usageStatus.padEnd(10)) + ' ' +
-        formatTokens(server.overhead) + ' tokens'
-      );
-    }
-
-    console.log('\n  ' + `Total overhead: ${formatTokens(analysis.totalOverhead)} tokens`);
-    if (analysis.recommendations.length > 0) {
-      console.log(chalk.yellow(`  Run 'morph-spec mcp optimize' for recommendations`));
-    }
-    console.log('');
-  } catch (err) {
-    console.error(chalk.red(`Error: ${err.message}`));
-    process.exit(1);
-  }
-}

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;