proagents 1.0.4 → 1.0.6

package/lib/commands/init.js

@@ -2,6 +2,7 @@ import { existsSync, mkdirSync, cpSync, writeFileSync, readFileSync, readdirSync
 import { join, dirname } from 'path';
 import { fileURLToPath } from 'url';
 import chalk from 'chalk';
+import yaml from 'js-yaml';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -9,11 +10,13 @@ const __dirname = dirname(__filename);
 // Files/folders to preserve during update (user customizations)
 const PRESERVE_PATHS = [
   'active-features',           // User's work in progress
-  'proagents.config.yaml',     // User's configuration
   '.learning',                 // Learned patterns
   'cache',                     // Cached analysis
 ];
 
+// Config file is handled specially - merged not preserved
+const CONFIG_FILE = 'proagents.config.yaml';
+
 // Files that should always be updated (framework files)
 const FRAMEWORK_FOLDERS = [
   'prompts',
@@ -109,7 +112,7 @@ export async function initCommand(options = {}) {
       console.log(chalk.green('\n✓ ProAgents updated successfully!\n'));
       console.log(chalk.gray('Preserved:'));
       console.log(chalk.gray('  • active-features/ (your work in progress)'));
-      console.log(chalk.gray('  • proagents.config.yaml (your configuration)'));
+      console.log(chalk.gray('  • proagents.config.yaml (your values + new options merged)'));
       console.log(chalk.gray('  • .learning/ (learned patterns)'));
       console.log(chalk.gray('  • cache/ (analysis cache)\n'));
       return;
@@ -284,6 +287,21 @@ async function smartUpdate(sourceDir, targetDir) {
     }
   }
 
+  // Before updating, migrate any modified template files
+  const migrationResult = migrateModifiedTemplates(sourceDir, targetDir);
+  if (migrationResult.migrated.length > 0) {
+    console.log(chalk.green(`✓ Migrated ${migrationResult.migrated.length} modified template(s) to user files`));
+    for (const file of migrationResult.migrated) {
+      console.log(chalk.gray(`  • ${file}`));
+    }
+  }
+  if (migrationResult.backedUp.length > 0) {
+    console.log(chalk.yellow(`⚠️  Backed up ${migrationResult.backedUp.length} modified template(s)`));
+    for (const file of migrationResult.backedUp) {
+      console.log(chalk.gray(`  • ${file}`));
+    }
+  }
+
   // Update framework folders
   let updatedCount = 0;
   for (const folder of FRAMEWORK_FOLDERS) {
@@ -301,6 +319,9 @@ async function smartUpdate(sourceDir, targetDir) {
   }
   console.log(chalk.green(`✓ Updated ${updatedCount} framework folders`));
 
+  // Restore user files that were migrated (they were saved before folder deletion)
+  restoreUserFiles(targetDir, migrationResult);
+
   // Update framework root files
   let filesUpdated = 0;
   for (const file of FRAMEWORK_FILES) {
@@ -314,6 +335,22 @@ async function smartUpdate(sourceDir, targetDir) {
   }
   console.log(chalk.green(`✓ Updated ${filesUpdated} framework files`));
 
+  // Merge config file - keep user values, add new options
+  const userConfigPath = join(targetDir, CONFIG_FILE);
+  const newConfigPath = join(sourceDir, CONFIG_FILE);
+
+  if (existsSync(newConfigPath)) {
+    const mergeResult = mergeConfigs(userConfigPath, newConfigPath);
+    if (mergeResult.newOptions > 0) {
+      console.log(chalk.green(`✓ Config merged: ${mergeResult.newOptions} new options added`));
+      if (mergeResult.newKeys.length > 0 && mergeResult.newKeys.length <= 5) {
+        console.log(chalk.gray(`  New: ${mergeResult.newKeys.join(', ')}`));
+      }
+    } else {
+      console.log(chalk.green(`✓ Config up to date`));
+    }
+  }
+
   // Ensure preserved paths still exist (they should, but just in case)
   for (const [path, fullPath] of Object.entries(backups)) {
     if (!existsSync(fullPath)) {
@@ -327,3 +364,212 @@ async function smartUpdate(sourceDir, targetDir) {
     }
   }
 }
+
+/**
+ * Deep merge two objects - source values override target, but target values are preserved
+ * Returns the merged object and list of new keys added
+ */
+function deepMerge(target, source, path = '') {
+  const result = { ...target };
+  const newKeys = [];
+
+  for (const key of Object.keys(source)) {
+    const currentPath = path ? `${path}.${key}` : key;
+
+    if (!(key in target)) {
+      // New key - add it
+      result[key] = source[key];
+      newKeys.push(currentPath);
+    } else if (
+      typeof source[key] === 'object' &&
+      source[key] !== null &&
+      !Array.isArray(source[key]) &&
+      typeof target[key] === 'object' &&
+      target[key] !== null &&
+      !Array.isArray(target[key])
+    ) {
+      // Both are objects - recurse
+      const merged = deepMerge(target[key], source[key], currentPath);
+      result[key] = merged.result;
+      newKeys.push(...merged.newKeys);
+    }
+    // If key exists in target and is not an object, keep target value
+  }
+
+  return { result, newKeys };
+}
+
+/**
+ * Merge user config with new framework config
+ * Preserves user values, adds new options from framework
+ */
+function mergeConfigs(userConfigPath, newConfigPath) {
+  try {
+    const newConfigContent = readFileSync(newConfigPath, 'utf-8');
+    const newConfig = yaml.load(newConfigContent);
+
+    if (!existsSync(userConfigPath)) {
+      // No user config - just copy the new one
+      writeFileSync(userConfigPath, newConfigContent);
+      return { newOptions: Object.keys(newConfig).length, newKeys: ['(new config created)'] };
+    }
+
+    const userConfigContent = readFileSync(userConfigPath, 'utf-8');
+    const userConfig = yaml.load(userConfigContent);
+
+    if (!userConfig || typeof userConfig !== 'object') {
+      // User config is empty or invalid - use new config
+      writeFileSync(userConfigPath, newConfigContent);
+      return { newOptions: Object.keys(newConfig).length, newKeys: ['(config replaced)'] };
+    }
+
+    // Deep merge - user values take precedence, new keys added
+    const { result: mergedConfig, newKeys } = deepMerge(userConfig, newConfig);
+
+    if (newKeys.length > 0) {
+      // Write merged config with comment
+      const header = `# ProAgents Configuration\n# User values preserved, new options added during update\n# Last updated: ${new Date().toISOString().split('T')[0]}\n\n`;
+      const mergedYaml = yaml.dump(mergedConfig, {
+        indent: 2,
+        lineWidth: 120,
+        noRefs: true,
+        sortKeys: false
+      });
+      writeFileSync(userConfigPath, header + mergedYaml);
+    }
+
+    return { newOptions: newKeys.length, newKeys };
+  } catch (error) {
+    // If merge fails, don't break the update - just warn
+    console.log(chalk.yellow(`⚠️  Could not merge config: ${error.message}`));
+    return { newOptions: 0, newKeys: [] };
+  }
+}
+
+/**
+ * Find all template files in a directory recursively
+ * Template files have '.template.' in their name
+ */
+function findTemplateFiles(dir, baseDir = dir) {
+  const templates = [];
+
+  if (!existsSync(dir)) return templates;
+
+  const entries = readdirSync(dir, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const fullPath = join(dir, entry.name);
+    const relativePath = fullPath.replace(baseDir + '/', '');
+
+    if (entry.isDirectory()) {
+      templates.push(...findTemplateFiles(fullPath, baseDir));
+    } else if (entry.name.includes('.template.')) {
+      templates.push(relativePath);
+    }
+  }
+
+  return templates;
+}
+
+/**
+ * Get the user file path for a template file
+ * e.g., 'config/rules/custom-rules.template.yaml' -> 'config/rules/custom-rules.yaml'
+ */
+function getUserFilePath(templatePath) {
+  return templatePath.replace('.template.', '.');
+}
+
+/**
+ * Check if a file has been modified by comparing with source
+ */
+function isFileModified(sourcePath, targetPath) {
+  if (!existsSync(targetPath)) return false;
+  if (!existsSync(sourcePath)) return true; // File exists in target but not source = modified/custom
+
+  try {
+    const sourceContent = readFileSync(sourcePath, 'utf-8');
+    const targetContent = readFileSync(targetPath, 'utf-8');
+    return sourceContent !== targetContent;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Migrate modified template files to user files before update
+ * Returns info about migrated and backed up files
+ */
+function migrateModifiedTemplates(sourceDir, targetDir) {
+  const result = {
+    migrated: [],      // Templates copied to user files
+    backedUp: [],      // Templates backed up (user file already existed)
+    userFiles: {}      // Map of user file paths to their content (for restoration)
+  };
+
+  // Find all template files in target directory
+  const templateFiles = findTemplateFiles(targetDir);
+
+  for (const templateRelPath of templateFiles) {
+    const templateTargetPath = join(targetDir, templateRelPath);
+    const templateSourcePath = join(sourceDir, templateRelPath);
+    const userFileRelPath = getUserFilePath(templateRelPath);
+    const userFilePath = join(targetDir, userFileRelPath);
+
+    // Check if template was modified by user
+    if (isFileModified(templateSourcePath, templateTargetPath)) {
+      try {
+        const modifiedContent = readFileSync(templateTargetPath, 'utf-8');
+
+        if (existsSync(userFilePath)) {
+          // User file already exists - backup the modified template
+          const backupPath = templateTargetPath + '.backup';
+          writeFileSync(backupPath, modifiedContent);
+          result.backedUp.push(templateRelPath);
+          // Save backup content for restoration after folder deletion
+          result.userFiles[templateRelPath + '.backup'] = modifiedContent;
+        } else {
+          // No user file - migrate template to user file
+          result.userFiles[userFileRelPath] = modifiedContent;
+          result.migrated.push(`${templateRelPath} → ${userFileRelPath}`);
+        }
+      } catch (error) {
+        // Skip files that can't be read
+        continue;
+      }
+    }
+
+    // Also preserve existing user files (non-template versions)
+    if (existsSync(userFilePath)) {
+      try {
+        const userContent = readFileSync(userFilePath, 'utf-8');
+        result.userFiles[userFileRelPath] = userContent;
+      } catch {
+        // Skip files that can't be read
+      }
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Restore user files after framework folders have been updated
+ */
+function restoreUserFiles(targetDir, migrationResult) {
+  for (const [relativePath, content] of Object.entries(migrationResult.userFiles)) {
+    const fullPath = join(targetDir, relativePath);
+    const dirPath = dirname(fullPath);
+
+    try {
+      // Ensure directory exists
+      if (!existsSync(dirPath)) {
+        mkdirSync(dirPath, { recursive: true });
+      }
+
+      // Write the user file
+      writeFileSync(fullPath, content);
+    } catch (error) {
+      console.log(chalk.yellow(`⚠️  Could not restore ${relativePath}: ${error.message}`));
+    }
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "proagents",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "description": "AI-agnostic development workflow framework that automates the full software development lifecycle",
   "type": "module",
   "main": "lib/index.js",
@@ -47,6 +47,7 @@
   },
   "dependencies": {
     "commander": "^11.1.0",
-    "chalk": "^5.3.0"
+    "chalk": "^5.3.0",
+    "js-yaml": "^4.1.0"
   }
 }