proagents 1.0.3 → 1.0.5

package/lib/commands/init.js

@@ -1,11 +1,93 @@
-import { existsSync, mkdirSync, cpSync, writeFileSync, readFileSync } from 'fs';
+import { existsSync, mkdirSync, cpSync, writeFileSync, readFileSync, readdirSync, rmSync } from 'fs';
 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);
 
+// Files/folders to preserve during update (user customizations)
+const PRESERVE_PATHS = [
+  'active-features',           // User's work in progress
+  '.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',
+  'templates',
+  'checklists',
+  'standards',
+  'examples',
+  'git',
+  'ui-integration',
+  'workflow-modes',
+  'security',
+  'performance',
+  'testing-standards',
+  'patterns',
+  'scaffolding',
+  'cli',
+  'adr',
+  'ai-models',
+  'ai-training',
+  'api-versioning',
+  'approval-workflows',
+  'automation',
+  'changelog',
+  'cicd',
+  'collaboration',
+  'compliance',
+  'config-versioning',
+  'config',
+  'contract-testing',
+  'cost',
+  'database',
+  'dependency-management',
+  'disaster-recovery',
+  'environments',
+  'existing-projects',
+  'feature-flags',
+  'getting-started',
+  'i18n',
+  'ide-integration',
+  'integrations',
+  'learning',
+  'logging',
+  'mcp',
+  'metrics',
+  'migrations',
+  'monitoring',
+  'multi-project',
+  'notifications',
+  'offline-mode',
+  'parallel-features',
+  'plugins',
+  'pm-integration',
+  'reporting',
+  'reverse-engineering',
+  'rules',
+  'runbooks',
+  'secrets',
+  'team',
+  'troubleshooting',
+  'webhooks',
+];
+
+// Root files to always update
+const FRAMEWORK_FILES = [
+  'README.md',
+  'WORKFLOW.md',
+  'PROAGENTS.md',
+  'GETTING-STARTED-STORY.md',
+  'slash-commands.json',
+];
+
 /**
  * Initialize ProAgents in the current project
  */
@@ -18,16 +100,37 @@ export async function initCommand(options = {}) {
   console.log(chalk.blue('========================\n'));
 
   // Check if already initialized
-  if (existsSync(proagentsDir) && !options.force) {
-    console.log(chalk.yellow('⚠️  ProAgents is already initialized in this project.'));
-    console.log(chalk.gray('   Use --force to overwrite.\n'));
-    return;
+  const alreadyInitialized = existsSync(proagentsDir);
+
+  if (alreadyInitialized && !options.force) {
+    // Smart update mode - preserve user files, update framework
+    console.log(chalk.cyan('ℹ️  ProAgents detected. Running smart update...'));
+    console.log(chalk.gray('   (Preserving your customizations)\n'));
+
+    try {
+      await smartUpdate(sourceDir, proagentsDir);
+      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 values + new options merged)'));
+      console.log(chalk.gray('  • .learning/ (learned patterns)'));
+      console.log(chalk.gray('  • cache/ (analysis cache)\n'));
+      return;
+    } catch (error) {
+      console.error(chalk.red('\n✗ Error updating ProAgents:'));
+      console.error(chalk.red(error.message));
+      process.exit(1);
+    }
   }
 
   try {
-    // Copy proagents folder
+    if (options.force && alreadyInitialized) {
+      console.log(chalk.yellow('⚠️  Force mode: Overwriting all files...'));
+    }
+
+    // Fresh install or force overwrite
     console.log(chalk.gray('Copying framework files...'));
-    cpSync(sourceDir, proagentsDir, { recursive: true, force: options.force || false });
+    cpSync(sourceDir, proagentsDir, { recursive: true, force: true });
     console.log(chalk.green('✓ Framework files copied to ./proagents/'));
 
     // Create config if not skipped
@@ -52,7 +155,6 @@ export async function initCommand(options = {}) {
     }
     if (!existsSync(releasesDir)) {
       mkdirSync(releasesDir, { recursive: true });
-      // Create releases index
       writeFileSync(join(releasesDir, 'README.md'),
 `# Release History
 
@@ -143,12 +245,10 @@ For detailed commands, see \`./proagents/PROAGENTS.md\`
     if (existsSync(readmePath)) {
       const readmeContent = readFileSync(readmePath, 'utf-8');
       if (!readmeContent.includes('PROAGENTS:START')) {
-        // Prepend to existing README
         writeFileSync(readmePath, proagentsSection + readmeContent);
         console.log(chalk.green('✓ Added ProAgents commands to README.md'));
       }
     } else {
-      // Create new README with ProAgents section
       writeFileSync(readmePath, proagentsSection + `# Project Name\n\nProject description.\n`);
       console.log(chalk.green('✓ Created README.md with ProAgents commands'));
     }
@@ -173,3 +273,157 @@ For detailed commands, see \`./proagents/PROAGENTS.md\`
     process.exit(1);
   }
 }
+
+/**
+ * Smart update - preserves user files, updates framework files
+ */
+async function smartUpdate(sourceDir, targetDir) {
+  // Backup preserved paths
+  const backups = {};
+  for (const path of PRESERVE_PATHS) {
+    const fullPath = join(targetDir, path);
+    if (existsSync(fullPath)) {
+      backups[path] = fullPath;
+    }
+  }
+
+  // Update framework folders
+  let updatedCount = 0;
+  for (const folder of FRAMEWORK_FOLDERS) {
+    const sourcePath = join(sourceDir, folder);
+    const targetPath = join(targetDir, folder);
+
+    if (existsSync(sourcePath)) {
+      // Remove old folder and copy new
+      if (existsSync(targetPath)) {
+        rmSync(targetPath, { recursive: true, force: true });
+      }
+      cpSync(sourcePath, targetPath, { recursive: true });
+      updatedCount++;
+    }
+  }
+  console.log(chalk.green(`✓ Updated ${updatedCount} framework folders`));
+
+  // Update framework root files
+  let filesUpdated = 0;
+  for (const file of FRAMEWORK_FILES) {
+    const sourcePath = join(sourceDir, file);
+    const targetPath = join(targetDir, file);
+
+    if (existsSync(sourcePath)) {
+      cpSync(sourcePath, targetPath, { force: true });
+      filesUpdated++;
+    }
+  }
+  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)) {
+      console.log(chalk.yellow(`⚠️  ${path} was removed during update, restoring...`));
+      // The backup reference is the same as the original, so if it doesn't exist
+      // it means we need to recreate the structure
+      if (path === 'active-features') {
+        mkdirSync(fullPath, { recursive: true });
+        writeFileSync(join(fullPath, '.gitkeep'), '');
+      }
+    }
+  }
+}
+
+/**
+ * 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: [] };
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "proagents",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "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"
   }
 }