@polymorphism-tech/morph-spec 4.3.4 → 4.3.6

package/src/commands/project/update.js

@@ -9,9 +9,11 @@ import { logger } from '../../utils/logger.js';
 import {
   getContentDir,
   copyDirectory,
+  copyFile,
   pathExists,
   ensureDir,
   createDirectoryLink,
+  createSymlink,
   readJson,
   writeJson
 } from '../../utils/file-copier.js';
@@ -26,6 +28,79 @@ import { installClaudeHooks } from '../../utils/hooks-installer.js';
 import { AutoContextOrchestrator } from '../../core/orchestrator.js';
 import { detectClaudeCode } from '../../llm/environment-detector.js';
 
+/**
+ * Backup user's config.json before cleaning
+ * @param {string} morphPath - Path to .morph directory
+ * @returns {Promise<object|null>} Backup of config.json or null
+ */
+async function backupUserConfig(morphPath) {
+  try {
+    const configPath = join(morphPath, 'config', 'config.json');
+    if (await pathExists(configPath)) {
+      const config = await readJson(configPath);
+      return config;
+    }
+  } catch (error) {
+    // If backup fails, return null and continue
+  }
+  return null;
+}
+
+/**
+ * Clean framework directories but preserve .morph/project/
+ * @param {string} morphPath - Path to .morph directory
+ * @param {string} targetPath - Project root path
+ */
+async function cleanFrameworkDirs(morphPath, targetPath) {
+  const dirsToClean = [
+    join(morphPath, 'templates'),
+    join(morphPath, 'standards'),
+    join(morphPath, 'config'),
+    join(targetPath, '.claude')
+  ];
+
+  for (const dir of dirsToClean) {
+    try {
+      if (await pathExists(dir)) {
+        await fs.remove(dir);
+      }
+    } catch (error) {
+      // Continue even if cleanup fails for one directory
+    }
+  }
+}
+
+/**
+ * Restore user's config.json after reinstallation
+ * @param {string} morphPath - Path to .morph directory
+ * @param {string} targetPath - Project root path
+ * @param {object|null} configBackup - Backup of config.json
+ * @param {string} currentVersion - Current CLI version
+ */
+async function restoreUserConfig(morphPath, targetPath, configBackup, currentVersion) {
+  const configDir = join(morphPath, 'config');
+  await ensureDir(configDir);
+  const configPath = join(configDir, 'config.json');
+
+  if (configBackup) {
+    // Preserve user data but update framework version
+    configBackup.frameworkVersion = currentVersion;
+    await writeJson(configPath, configBackup);
+  } else {
+    // Create basic config if none existed
+    const dirName = targetPath.split(/[\\/]/).pop();
+    const defaultConfig = {
+      framework: 'global',
+      frameworkVersion: currentVersion,
+      project: {
+        name: dirName,
+        architecture: 'unknown'
+      }
+    };
+    await writeJson(configPath, defaultConfig);
+  }
+}
+
 export async function updateCommand(options) {
   const targetPath = process.cwd();
   const contentDir = getContentDir();
@@ -34,10 +109,17 @@ export async function updateCommand(options) {
   logger.header('MORPH-SPEC Update');
 
   // Check if MORPH is initialized
+  let needsInitialization = false;
   if (!(await pathExists(morphPath))) {
-    logger.error('MORPH not initialized in this directory.');
-    logger.dim('Run "morph-spec init" first.');
-    process.exit(1);
+    logger.warn('MORPH not fully initialized. Creating basic structure...');
+    needsInitialization = true;
+
+    // Create basic .morph structure
+    await ensureDir(join(morphPath, 'project', 'context'));
+    await ensureDir(join(morphPath, 'project', 'standards'));
+    await ensureDir(join(morphPath, 'project', 'outputs'));
+    await ensureDir(join(morphPath, 'config'));
+    logger.dim('  ✓ Created .morph directory structure');
   }
 
   // Check CLI version
@@ -93,6 +175,18 @@ export async function updateCommand(options) {
   const updateSpinner = ora('Updating MORPH-SPEC...').start();
 
   try {
+    // Backup user config before cleaning
+    updateSpinner.text = 'Backing up user configuration...';
+    const configBackup = await backupUserConfig(morphPath);
+    if (configBackup) {
+      logger.dim('  ✓ User config backed up');
+    }
+
+    // Clean framework directories (preserve .morph/project/)
+    updateSpinner.text = 'Cleaning old framework files...';
+    await cleanFrameworkDirs(morphPath, targetPath);
+    logger.dim('  ✓ Old framework files removed');
+
     const updateTemplates = !options.standards || options.templates;
     const updateStandards = !options.templates || options.standards;
 
@@ -112,54 +206,94 @@ export async function updateCommand(options) {
       await copyDirectory(standardsSrc, standardsDest);
     }
 
-    // Update agents.json (sourced from framework root .morph/config/ — canonical single source of truth)
+    // Update agents.json (sourced from framework/ — canonical single source of truth)
     updateSpinner.text = 'Updating agents configuration...';
-    const agentsSrc = join(__dirname, '..', '..', '..', '.morph', 'config', 'agents.json');
+    const agentsSrc = join(__dirname, '..', '..', '..', 'framework', 'agents.json');
     const agentsDest = join(morphPath, 'config', 'agents.json');
     if (await pathExists(agentsSrc)) {
-      await copyDirectory(agentsSrc, agentsDest);
+      await copyFile(agentsSrc, agentsDest);
+    }
+
+    // Update azure-pricing files
+    updateSpinner.text = 'Updating Azure pricing data...';
+    const configDir = join(morphPath, 'config');
+    const pricingSrc = join(contentDir, '.morph', 'config', 'azure-pricing.json');
+    const pricingDest = join(configDir, 'azure-pricing.json');
+    if (await pathExists(pricingSrc)) {
+      await copyFile(pricingSrc, pricingDest);
+    }
+    const pricingSchemaSrc = join(contentDir, '.morph', 'config', 'azure-pricing.schema.json');
+    const pricingSchemaDest = join(configDir, 'azure-pricing.schema.json');
+    if (await pathExists(pricingSchemaSrc)) {
+      await copyFile(pricingSchemaSrc, pricingSchemaDest);
     }
 
     // Update .claude commands and skills
-    // Source: framework root .claude/ (canonical for all stacks)
-    updateSpinner.text = 'Updating Claude commands and skills...';
-    const claudeSrc = join(__dirname, '..', '..', '..', '.claude');
+    // Source: framework/ (canonical for all stacks)
+    updateSpinner.text = 'Setting up Claude Code integration...';
+    const frameworkDir = join(__dirname, '..', '..', '..', 'framework');
     const claudeDest = join(targetPath, '.claude');
-    let claudeUpdated = false;
-    if (await pathExists(claudeSrc)) {
-      // Copy commands (always copy, these are small)
-      const commandsSrc = join(claudeSrc, 'commands');
-      const commandsDest = join(claudeDest, 'commands');
-      if (await pathExists(commandsSrc)) {
-        await copyDirectory(commandsSrc, commandsDest);
-        claudeUpdated = true;
-
-        // Clean up stale command files moved to skills/workflows/ in v2.4+
-        const staleCommands = [
-          'morph-setup.md', 'morph-uiux.md', 'morph-design.md',
-          'morph-clarify.md', 'morph-tasks.md'
-        ];
-        for (const file of staleCommands) {
-          const stalePath = join(commandsDest, file);
-          if (await pathExists(stalePath)) {
-            await fs.remove(stalePath);
-          }
-        }
-      } else {
-        logger.warn('  ⚠ .claude/commands/ source missing — commands not updated');
-      }
 
-      // Update skills using directory links per category
-      const skillsSrc = join(claudeSrc, 'skills');
+    let symlinkCount = 0;
+    let copyCount = 0;
+    let commandsCopied = false;
+
+    // Copy commands directory (slash commands): framework/commands/ → .claude/commands/
+    const commandsSrc = join(frameworkDir, 'commands');
+    const commandsDest = join(claudeDest, 'commands');
+    if (await pathExists(commandsSrc)) {
+      await copyDirectory(commandsSrc, commandsDest);
+      commandsCopied = true;
+    } else {
+      logger.warn('  ⚠ framework/commands/ source missing — commands not updated');
+    }
+
+    // Create directory links for skill categories (or copy if linking fails)
+    // Source: framework/skills/ → .claude/skills/
+    {
+      const skillsSrc = join(frameworkDir, 'skills');
       const skillsDest = join(claudeDest, 'skills');
+
       if (await pathExists(skillsSrc)) {
         await ensureDir(skillsDest);
+
         const entries = await fs.readdir(skillsSrc, { withFileTypes: true });
+
+        let linkedCategories = 0;
+        let copiedCategories = 0;
+        let totalSkillFiles = 0;
+
+        // Link category directories (specialists/, infra/, checklists/, etc.)
         for (const entry of entries) {
           if (entry.isDirectory()) {
-            await createDirectoryLink(join(skillsSrc, entry.name), join(skillsDest, entry.name));
+            const categorySrc = join(skillsSrc, entry.name);
+            const categoryDest = join(skillsDest, entry.name);
+
+            // Count .md files for reporting
+            const categoryEntries = await fs.readdir(categorySrc, { withFileTypes: true });
+            const mdFiles = categoryEntries.filter(e => e.isFile() && e.name.endsWith('.md'));
+            totalSkillFiles += mdFiles.length;
+
+            const result = await createDirectoryLink(categorySrc, categoryDest);
+            if (result === 'copy') {
+              copiedCategories++;
+            } else {
+              linkedCategories++;
+            }
+          } else if (entry.isFile() && entry.name.endsWith('.md')) {
+            // Handle .md files in skills root
+            totalSkillFiles++;
+            const result = await createSymlink(join(skillsSrc, entry.name), join(skillsDest, entry.name), 'file');
+            if (result === 'symlink') {
+              linkedCategories++;
+            } else {
+              copiedCategories++;
+            }
           }
         }
+
+        symlinkCount = linkedCategories > 0 ? totalSkillFiles : 0;
+        copyCount = linkedCategories === 0 ? totalSkillFiles : 0;
       }
     }
 
@@ -173,20 +307,15 @@ export async function updateCommand(options) {
     const claudeMdDest = join(targetPath, 'CLAUDE.md');
     await copyDirectory(claudeMdSrc, claudeMdDest);
 
+    // Restore user config after framework reinstallation
+    updateSpinner.text = 'Restoring user configuration...';
+    await restoreUserConfig(morphPath, targetPath, configBackup, cliCheck.current);
+    logger.dim('  ✓ User config restored with updated framework version');
+
     // Update .morphversion
     updateSpinner.text = 'Saving version info...';
     await saveProjectMorphVersion(targetPath, cliCheck.current);
 
-    // Update config.json frameworkVersion (BUG #9 fix)
-    const configPath = join(morphPath, 'config', 'config.json');
-    if (await pathExists(configPath)) {
-      try {
-        const config = await readJson(configPath);
-        config.frameworkVersion = cliCheck.current;
-        await writeJson(configPath, config);
-      } catch { /* preserve existing config if read/write fails */ }
-    }
-
     updateSpinner.succeed('MORPH-SPEC updated successfully!');
     logger.blank();
 
@@ -204,7 +333,17 @@ export async function updateCommand(options) {
     if (updateTemplates) logger.dim('  ✓ .morph/templates/');
     if (updateStandards) logger.dim('  ✓ .morph/standards/');
     logger.dim('  ✓ .morph/config/agents.json');
-    if (claudeUpdated) logger.dim('  ✓ .claude/commands/ and .claude/skills/');
+    logger.dim('  ✓ .morph/config/azure-pricing.json');
+    if (commandsCopied) logger.dim('  ✓ .claude/commands/');
+
+    if (symlinkCount > 0) {
+      const linkType = process.platform === 'win32' ? 'junction-linked' : 'symlinked';
+      logger.dim(`  ✓ .claude/skills/ (${symlinkCount} ${linkType})`);
+    } else if (copyCount > 0) {
+      logger.dim(`  ✓ .claude/skills/ (${copyCount} copied)`);
+      logger.warn(`  ⚠ Directory links not supported (copied instead). Skills won't auto-update.`);
+    }
+
     logger.dim('  ✓ .claude/settings.local.json (agent-teams hooks)');
     logger.dim('  ✓ CLAUDE.md');
     logger.blank();