@polymorphism-tech/morph-spec 1.0.2 → 2.0.0

package/src/commands/sync.js

@@ -0,0 +1,167 @@
+import { join } from 'path';
+import { readdirSync, existsSync } from 'fs';
+import ora from 'ora';
+import chalk from 'chalk';
+import { logger } from '../utils/logger.js';
+import { readFile, writeFile, ensureDir } from '../utils/file-copier.js';
+import { analyzeConversation } from '../../detectors/conversation-analyzer.js';
+
+export async function syncCommand(options) {
+  const targetPath = options.path || process.cwd();
+
+  logger.header('MORPH-SPEC Standards Sync');
+  logger.dim(`Project: ${targetPath}`);
+  logger.blank();
+
+  const spinner = ora('Analyzing feature decisions...').start();
+
+  try {
+    // 1. Find all decisions.md files
+    const outputsPath = join(targetPath, '.morph', 'project', 'outputs');
+
+    if (!existsSync(outputsPath)) {
+      spinner.warn('No features found');
+      logger.dim('Create features first using MORPH workflow.');
+      return;
+    }
+
+    const features = readdirSync(outputsPath, { withFileTypes: true })
+      .filter(dirent => dirent.isDirectory())
+      .map(dirent => dirent.name);
+
+    if (features.length === 0) {
+      spinner.warn('No features found');
+      return;
+    }
+
+    spinner.text = `Found ${features.length} features, analyzing decisions...`;
+
+    // 2. Analyze all decisions
+    const conversation = await analyzeConversation(targetPath);
+
+    if (conversation.decisions.length === 0) {
+      spinner.warn('No decisions found to sync');
+      logger.dim('Features may not have decisions.md files yet.');
+      return;
+    }
+
+    spinner.succeed(`Found ${conversation.decisions.length} decisions`);
+    logger.blank();
+
+    // 3. Group by category
+    const byCategory = groupByCategory(conversation.decisions);
+
+    // 4. Display candidates
+    logger.header('Decisions by Category:');
+    logger.blank();
+
+    let totalCandidates = 0;
+
+    for (const [category, decisions] of Object.entries(byCategory)) {
+      if (decisions.length > 0) {
+        logger.info(chalk.cyan(`${formatCategory(category)} (${decisions.length})`));
+        decisions.slice(0, 3).forEach(d => {
+          const preview = d.text.split('\n')[0].substring(0, 70);
+          logger.dim(`  - ${preview}...`);
+        });
+        if (decisions.length > 3) {
+          logger.dim(`  ... and ${decisions.length - 3} more`);
+        }
+        logger.blank();
+        totalCandidates += decisions.length;
+      }
+    }
+
+    // 5. Sync (for now, just report - interactive approval would be added later)
+    if (options.dryRun) {
+      logger.warn('Dry run mode - no files updated');
+      logger.dim(`Would update ${Object.keys(byCategory).length} standard files`);
+      return;
+    }
+
+    spinner.start('Updating standards...');
+
+    const standardsDir = join(targetPath, '.morph', 'project', 'standards');
+    await ensureDir(standardsDir);
+
+    let updatedFiles = [];
+
+    for (const [category, decisions] of Object.entries(byCategory)) {
+      if (decisions.length === 0) continue;
+
+      const fileName = `${category}.md`;
+      const filePath = join(standardsDir, fileName);
+
+      // Read existing or create new
+      let content = '';
+      if (existsSync(filePath)) {
+        content = await readFile(filePath);
+      } else {
+        content = `# ${formatCategory(category)} Standards\n\n> Project-specific standards for ${category}\n\n`;
+      }
+
+      // Append new decisions
+      content += `\n## Decisions from Features (${new Date().toISOString().split('T')[0]})\n\n`;
+
+      decisions.forEach((d, idx) => {
+        const preview = d.text.split('\n').slice(0, 5).join('\n');
+        content += `### Decision ${idx + 1}\n\n${preview}\n\n`;
+      });
+
+      await writeFile(filePath, content);
+      updatedFiles.push(fileName);
+    }
+
+    spinner.succeed(`Updated ${updatedFiles.length} standard files`);
+
+    updatedFiles.forEach(file => {
+      logger.dim(`  - ${file}`);
+    });
+
+    logger.blank();
+    logger.success('Standards sync complete!');
+    logger.dim('Commit these changes with a sync: message.');
+
+  } catch (error) {
+    spinner.fail('Sync failed');
+    logger.error(error.message);
+    process.exit(1);
+  }
+}
+
+/**
+ * Group decisions by category
+ */
+function groupByCategory(decisions) {
+  const categories = {
+    'coding': [],
+    'architecture': [],
+    'azure': [],
+    'integrations': [],
+    'ui-ux': []
+  };
+
+  decisions.forEach(decision => {
+    const category = decision.category || 'coding';
+    if (categories[category]) {
+      categories[category].push(decision);
+    }
+  });
+
+  return categories;
+}
+
+/**
+ * Format category name
+ */
+function formatCategory(category) {
+  const names = {
+    'coding': 'Coding Standards',
+    'architecture': 'Architecture Patterns',
+    'azure': 'Azure & Infrastructure',
+    'integrations': 'Integration Patterns',
+    'ui-ux': 'UI/UX Standards'
+  };
+
+  return names[category] || category;
+}

package/src/commands/update-pricing.js

@@ -0,0 +1,206 @@
+/**
+ * Update Azure Pricing Command
+ *
+ * Updates azure-pricing.json with latest pricing data
+ */
+
+import { writeFileSync, readFileSync, existsSync } from 'fs';
+import { join, dirname } from 'path';
+import chalk from 'chalk';
+import Ajv from 'ajv';
+import addFormats from 'ajv-formats';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+/**
+ * Get pricing file path
+ * @returns {string} Path to azure-pricing.json
+ */
+function getPricingPath() {
+  return join(__dirname, '..', '..', 'content', '.morph', 'config', 'azure-pricing.json');
+}
+
+/**
+ * Get schema file path
+ * @returns {string} Path to azure-pricing.schema.json
+ */
+function getSchemaPath() {
+  return join(__dirname, '..', '..', 'content', '.morph', 'config', 'azure-pricing.schema.json');
+}
+
+/**
+ * Validate pricing data against JSON schema
+ * @param {Object} pricingData - Pricing data to validate
+ * @returns {boolean} True if valid
+ * @throws {Error} If validation fails
+ */
+function validatePricingData(pricingData) {
+  const schemaPath = getSchemaPath();
+
+  if (!existsSync(schemaPath)) {
+    throw new Error(`Schema file not found: ${schemaPath}`);
+  }
+
+  const schema = JSON.parse(readFileSync(schemaPath, 'utf8'));
+
+  const ajv = new Ajv();
+  addFormats(ajv);
+  const validate = ajv.compile(schema);
+
+  const valid = validate(pricingData);
+
+  if (!valid) {
+    const errors = validate.errors.map(err => {
+      return `  - ${err.instancePath || 'root'}: ${err.message}`;
+    }).join('\n');
+    throw new Error(`Pricing data validation failed:\n${errors}`);
+  }
+
+  return true;
+}
+
+/**
+ * Update pricing for a specific resource type
+ * @param {Object} options - Command options
+ * @param {string} options.resourceType - Resource type (e.g., "Microsoft.Sql/servers/databases")
+ * @param {string} options.sku - SKU name (e.g., "S0")
+ * @param {number} options.price - Monthly price
+ * @param {boolean} options.dryRun - Preview without saving
+ * @param {boolean} options.validate - Validate after update
+ */
+export async function updateResourcePricing(options) {
+  const { resourceType, sku, price, dryRun = false, validate = true } = options;
+
+  const pricingPath = getPricingPath();
+
+  if (!existsSync(pricingPath)) {
+    console.log(chalk.red(`✗ Pricing file not found: ${pricingPath}`));
+    process.exit(1);
+  }
+
+  // Load current pricing
+  const pricingData = JSON.parse(readFileSync(pricingPath, 'utf8'));
+
+  // Ensure resource type exists
+  if (!pricingData.resources[resourceType]) {
+    pricingData.resources[resourceType] = {};
+    console.log(chalk.yellow(`  Creating new resource type: ${resourceType}`));
+  }
+
+  // Update SKU price
+  const oldPrice = pricingData.resources[resourceType][sku];
+  pricingData.resources[resourceType][sku] = price;
+
+  // Update metadata
+  pricingData.lastUpdated = new Date().toISOString();
+
+  // Validate if requested
+  if (validate) {
+    try {
+      validatePricingData(pricingData);
+      console.log(chalk.green('✓ Validation passed'));
+    } catch (err) {
+      console.log(chalk.red(`✗ Validation failed: ${err.message}`));
+      process.exit(1);
+    }
+  }
+
+  // Show changes
+  console.log(chalk.blue('\nChanges:'));
+  console.log(`  ${resourceType}`);
+  console.log(`    ${sku}: ${oldPrice !== undefined ? `$${oldPrice}` : 'NEW'} → $${price}/month`);
+
+  // Save if not dry run
+  if (!dryRun) {
+    writeFileSync(pricingPath, JSON.stringify(pricingData, null, 2) + '\n', 'utf8');
+    console.log(chalk.green(`\n✓ Updated ${pricingPath}`));
+  } else {
+    console.log(chalk.yellow('\n⚠ Dry run - no changes saved'));
+  }
+}
+
+/**
+ * Show current pricing
+ * @param {Object} options - Command options
+ * @param {string} options.resourceType - Optional resource type filter
+ * @param {string} options.format - Output format (table or json)
+ */
+export async function showPricing(options) {
+  const { resourceType = null, format = 'table' } = options;
+
+  const pricingPath = getPricingPath();
+
+  if (!existsSync(pricingPath)) {
+    console.log(chalk.red(`✗ Pricing file not found: ${pricingPath}`));
+    process.exit(1);
+  }
+
+  const pricingData = JSON.parse(readFileSync(pricingPath, 'utf8'));
+
+  if (format === 'json') {
+    console.log(JSON.stringify(resourceType ? pricingData.resources[resourceType] : pricingData, null, 2));
+    return;
+  }
+
+  // Table format
+  console.log(chalk.bold('\nAzure Pricing Table'));
+  console.log(chalk.dim(`Region: ${pricingData.region} | Currency: ${pricingData.currency}`));
+  console.log(chalk.dim(`Last Updated: ${pricingData.lastUpdated}`));
+  console.log('');
+
+  const resourceTypes = resourceType
+    ? [resourceType]
+    : Object.keys(pricingData.resources).sort();
+
+  for (const type of resourceTypes) {
+    if (!pricingData.resources[type]) {
+      console.log(chalk.red(`✗ Resource type not found: ${type}`));
+      continue;
+    }
+
+    console.log(chalk.cyan(type));
+
+    const skus = Object.entries(pricingData.resources[type]).sort((a, b) => a[1] - b[1]);
+
+    for (const [skuName, price] of skus) {
+      const priceStr = price === 0 ? chalk.green('FREE') : `$${price.toFixed(2)}/month`;
+      console.log(`  ${skuName.padEnd(20)} ${priceStr}`);
+    }
+
+    console.log('');
+  }
+}
+
+/**
+ * Validate pricing file
+ */
+export async function validatePricing() {
+  const pricingPath = getPricingPath();
+
+  if (!existsSync(pricingPath)) {
+    console.log(chalk.red(`✗ Pricing file not found: ${pricingPath}`));
+    process.exit(1);
+  }
+
+  const pricingData = JSON.parse(readFileSync(pricingPath, 'utf8'));
+
+  console.log(chalk.blue('Validating pricing data...'));
+
+  try {
+    validatePricingData(pricingData);
+    console.log(chalk.green('✓ Pricing data is valid'));
+
+    // Show stats
+    const resourceCount = Object.keys(pricingData.resources).length;
+    const skuCount = Object.values(pricingData.resources).reduce((sum, skus) => sum + Object.keys(skus).length, 0);
+
+    console.log(chalk.dim(`\nStats:`));
+    console.log(chalk.dim(`  Resource types: ${resourceCount}`));
+    console.log(chalk.dim(`  SKUs: ${skuCount}`));
+  } catch (err) {
+    console.log(chalk.red(`✗ Validation failed: ${err.message}`));
+    process.exit(1);
+  }
+}

package/src/commands/update.js

@@ -1,11 +1,19 @@
 import { join } from 'path';
 import ora from 'ora';
+import chalk from 'chalk';
 import { logger } from '../utils/logger.js';
 import {
   getContentDir,
   copyDirectory,
   pathExists
 } from '../utils/file-copier.js';
+import {
+  checkCLIOutdated,
+  checkProjectOutdated,
+  saveProjectMorphVersion,
+  getUpdateInstructions,
+  detectInstallMethod
+} from '../utils/version-checker.js';
 
 export async function updateCommand(options) {
   const targetPath = process.cwd();
@@ -21,7 +29,57 @@ export async function updateCommand(options) {
     process.exit(1);
   }
 
-  const spinner = ora('Updating MORPH-SPEC...').start();
+  // Check CLI version
+  const spinner = ora('Checking versions...').start();
+  const cliCheck = await checkCLIOutdated();
+  const projectCheck = await checkProjectOutdated(targetPath);
+
+  spinner.stop();
+
+  // Display version info
+  logger.blank();
+  logger.info('Version Status:');
+  logger.dim(`  CLI version: ${cliCheck.current}`);
+
+  if (projectCheck.current) {
+    logger.dim(`  Project MORPH version: ${projectCheck.current}`);
+  } else {
+    logger.dim('  Project MORPH version: not found (legacy installation)');
+  }
+
+  if (cliCheck.latest) {
+    const latestColor = cliCheck.isOutdated ? chalk.yellow : chalk.green;
+    logger.dim(`  Latest available: ${latestColor(cliCheck.latest)}`);
+  }
+  logger.blank();
+
+  // If CLI is outdated, stop and instruct user
+  if (cliCheck.isOutdated && cliCheck.latest) {
+    logger.warn(`Your CLI is outdated (${cliCheck.current} → ${cliCheck.latest})`);
+    logger.blank();
+    logger.info('Please update the CLI first:');
+    logger.blank();
+
+    const method = detectInstallMethod();
+    const instructions = getUpdateInstructions(method);
+
+    instructions.forEach(line => {
+      if (line === '') {
+        logger.blank();
+      } else if (line.startsWith('Or ')) {
+        logger.dim(line);
+      } else {
+        logger.box([line]);
+      }
+    });
+
+    logger.blank();
+    logger.dim('Then run "morph-spec update" again.');
+    process.exit(0);
+  }
+
+  // Proceed with update
+  const updateSpinner = ora('Updating MORPH-SPEC...').start();
 
   try {
     const updateTemplates = !options.standards || options.templates;
@@ -29,55 +87,72 @@ export async function updateCommand(options) {
 
     // Update templates
     if (updateTemplates) {
-      spinner.text = 'Updating templates...';
+      updateSpinner.text = 'Updating templates...';
       const templatesSrc = join(contentDir, '.morph', 'templates');
       const templatesDest = join(morphPath, 'templates');
       await copyDirectory(templatesSrc, templatesDest);
-      logger.dim('Updated .morph/templates/');
     }
 
     // Update standards
     if (updateStandards) {
-      spinner.text = 'Updating standards...';
+      updateSpinner.text = 'Updating standards...';
       const standardsSrc = join(contentDir, '.morph', 'standards');
       const standardsDest = join(morphPath, 'standards');
       await copyDirectory(standardsSrc, standardsDest);
-      logger.dim('Updated .morph/standards/');
     }
 
     // Update agents.json
-    spinner.text = 'Updating agents configuration...';
+    updateSpinner.text = 'Updating agents configuration...';
     const agentsSrc = join(contentDir, '.morph', 'config', 'agents.json');
     const agentsDest = join(morphPath, 'config', 'agents.json');
     if (await pathExists(agentsSrc)) {
       await copyDirectory(agentsSrc, agentsDest);
-      logger.dim('Updated .morph/config/agents.json');
     }
 
     // Update .claude commands and skills
-    spinner.text = 'Updating Claude commands and skills...';
+    updateSpinner.text = 'Updating Claude commands and skills...';
     const claudeSrc = join(contentDir, '.claude');
     const claudeDest = join(targetPath, '.claude');
     if (await pathExists(claudeSrc)) {
       await copyDirectory(claudeSrc, claudeDest);
-      logger.dim('Updated .claude/commands/ and .claude/skills/');
     }
 
     // Update CLAUDE.md
-    spinner.text = 'Updating CLAUDE.md...';
+    updateSpinner.text = 'Updating CLAUDE.md...';
     const claudeMdSrc = join(contentDir, 'CLAUDE.md');
     const claudeMdDest = join(targetPath, 'CLAUDE.md');
     await copyDirectory(claudeMdSrc, claudeMdDest);
-    logger.dim('Updated CLAUDE.md');
 
-    spinner.succeed('MORPH-SPEC updated successfully!');
+    // Update .morphversion
+    updateSpinner.text = 'Saving version info...';
+    await saveProjectMorphVersion(targetPath, cliCheck.current);
+
+    updateSpinner.succeed('MORPH-SPEC updated successfully!');
+    logger.blank();
+
+    // Show version change
+    if (projectCheck.current && projectCheck.current !== cliCheck.current) {
+      logger.success(`Updated: ${projectCheck.current} → ${cliCheck.current}`);
+    } else if (!projectCheck.current) {
+      logger.success(`Updated to v${cliCheck.current}`);
+    } else {
+      logger.success(`Already up to date (v${cliCheck.current})`);
+    }
+
+    logger.blank();
+    logger.info('Updated files:');
+    if (updateTemplates) logger.dim('  ✓ .morph/templates/');
+    if (updateStandards) logger.dim('  ✓ .morph/standards/');
+    logger.dim('  ✓ .morph/config/agents.json');
+    logger.dim('  ✓ .claude/commands/ and .claude/skills/');
+    logger.dim('  ✓ CLAUDE.md');
     logger.blank();
     logger.info('Your config.json was preserved.');
     logger.dim('Review the updated files for any new features.');
     logger.blank();
 
   } catch (error) {
-    spinner.fail('Update failed');
+    updateSpinner.fail('Update failed');
     logger.error(error.message);
     process.exit(1);
   }