myaidev-method 0.2.11 → 0.2.12

package/CHANGELOG.md

@@ -0,0 +1,164 @@
+# Changelog
+
+All notable changes to the MyAIDev Method package will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.2.12] - 2025-11-10
+
+### Added
+- **Update Command**: `npx myaidev-method@latest update` for intelligent component updates
+  - Interactive conflict resolution for modified files
+  - Automatic backup creation before updates
+  - Dry-run mode to preview changes
+  - Force mode for clean updates
+  - Version tracking with `.claude/.myaidev-version`
+  - Updates all components: commands, agents, scripts, libs, docs, MCP configs
+- Comprehensive update documentation in USER_GUIDE.md
+- Update instructions in README.md
+- CHANGELOG.md for version history tracking
+
+### Changed
+- Init command now saves installation version for update tracking
+- Enhanced documentation with update best practices
+
+## [0.2.11] - 2025-11-10
+
+### Fixed
+- Script installation for non-Node.js projects
+  - Scripts now installed to `.myaidev-method/` with self-contained dependencies
+  - No longer requires Node.js project structure (package.json in root)
+  - Works in any project type (WordPress themes, Hugo sites, plain folders)
+  - Agent documentation updated to reference `.myaidev-method/` paths
+
+### Changed
+- Scripts copied to `.myaidev-method/scripts/` directory
+- Libraries copied to `.myaidev-method/lib/` directory
+- Dependencies installed locally in `.myaidev-method/node_modules/`
+- Added `.gitignore` guidance in CLAUDE.md template
+
+## [0.2.10] - 2025-11-06
+
+### Changed
+- ⚠️ **Deprecated approach**: Attempted node_modules path (reverted in v0.2.11)
+
+## [0.2.9] - 2025-11-06
+
+### Added
+- User Pathways section in USER_GUIDE.md
+  - Content Creator pathway with complete publishing pipeline
+  - Developer pathway with SPARC methodology guidance
+  - End-to-end workflow examples
+
+### Changed
+- Enhanced documentation structure
+- Improved onboarding experience
+
+## [0.2.8] - 2025-11-06
+
+### Changed
+- Package documentation distribution updates
+- Fixed package.json files array
+
+## [0.2.7] - 2025-11-06
+
+### Added
+- Comprehensive content creation pipeline examples
+- Multi-platform publishing workflows
+
+## [0.2.6] - 2025-11-05
+
+### Changed
+- Documentation updates and improvements
+
+## [0.2.5] - 2025-11-04
+
+### Added
+- PayloadCMS authentication simplification
+- JWT-based authentication for PayloadCMS
+- Improved publishing workflows
+
+## [0.2.4] - 2025-11-03
+
+### Added
+- Slash command fixes and improvements
+- 14 command updates with proper Task tool invocations
+
+## [0.2.3] - 2025-11-02
+
+### Added
+- Enhanced MCP server integration
+- SPARC orchestrator improvements
+
+## [0.2.2] - 2025-11-01
+
+### Added
+- WordPress admin utilities
+- Security scanning scripts
+- Performance checking tools
+
+## [0.2.1] - 2025-10-31
+
+### Added
+- Coolify deployment integration
+- Multi-platform publishing support
+
+## [0.2.0] - 2025-10-30
+
+### Added
+- SPARC methodology implementation
+- Development workflow agents
+- Git & CI/CD workflows
+
+## [0.1.0] - 2025-10-29
+
+### Added
+- Initial release
+- Content writer agent
+- WordPress publishing integration
+- Basic slash commands
+- MCP server foundation
+
+---
+
+## Release Notes
+
+### Version 0.2.12 Highlights
+
+**Major Feature: Update Command**
+
+The highlight of this release is the new intelligent update system. Users can now easily keep their MyAIDev Method installation current while preserving customizations:
+
+```bash
+npx myaidev-method@latest update --claude
+```
+
+Key features:
+- Interactive conflict resolution - choose what to update
+- Automatic backups - safe rollback if needed
+- Dry-run mode - preview changes first
+- Version tracking - know what version you're running
+
+This solves a major pain point where users had to manually track updates or risk losing customizations by re-running init.
+
+### Migration Guide
+
+**From v0.2.10 or earlier to v0.2.12**:
+
+1. Your scripts are now in `.myaidev-method/` instead of `node_modules/`
+2. If you have any custom scripts referencing the old path, update them
+3. Add `.myaidev-method/node_modules/` to your `.gitignore`
+4. Use the new update command going forward instead of re-running init
+
+**Checking Your Version**:
+```bash
+cat .claude/.myaidev-version
+```
+
+**First-Time Update Setup**:
+If you installed before v0.2.12, the version file won't exist. The update command will still work, but it won't know your current version. Consider it an upgrade from "unknown" to v0.2.12.
+
+---
+
+For more details on any release, see the [commit history](https://github.com/myaione/myaidev-method/commits/master) or [release notes](https://github.com/myaione/myaidev-method/releases).

package/README.md

@@ -29,6 +29,7 @@ The **MyAIDev Method** is a complete development framework for AI CLI tools (Cla
 - [Features](#features)
 - [Installation](#installation)
 - [Quick Start](#quick-start)
+- [Updating](#updating)
 - [SPARC Development Workflow](#sparc-development-workflow)
 - [Development Agents](#development-agents)
 - [Content & Publishing Agents](#content--publishing-agents)
@@ -134,6 +135,30 @@ npx myaidev-method@latest init
    /myai-wordpress-admin health-check
    ```
 
+## 🔄 Updating
+
+Keep your MyAIDev Method installation up to date with the latest features and bug fixes:
+
+```bash
+# Interactive update (recommended) - prompts for conflicts
+npx myaidev-method@latest update --claude
+
+# Force update - overwrites all files
+npx myaidev-method@latest update --claude --force
+
+# Preview changes without updating
+npx myaidev-method@latest update --claude --dry-run
+```
+
+The update command:
+- ✅ Detects your current version
+- ✅ Updates commands, agents, scripts, and documentation
+- ✅ Preserves your customizations (interactive conflict resolution)
+- ✅ Creates automatic backups before updating
+- ✅ Installs updated dependencies
+
+See [USER_GUIDE.md - Updating Section](USER_GUIDE.md#-updating-myaidev-method) for detailed update instructions and best practices.
+
 ## 🏗️ SPARC Development Workflow
 
 The **MyAIDev Method** implements the **SPARC methodology** - a systematic 5-phase approach to software development inspired by [GitHub Spec-Kit](https://github.com/github/spec-kit) patterns for agentic software development.

package/USER_GUIDE.md

@@ -7,6 +7,7 @@ This guide covers everything you need to know about using, customizing, and exte
 ## 📋 Table of Contents
 
 - [Quick Start](#quick-start)
+- [Updating MyAIDev Method](#-updating-myaidev-method)
 - [Understanding the Structure](#understanding-the-structure)
 - [👤 User Pathways](#-user-pathways)
   - [Content Creator Pathway](#content-creator-pathway)
@@ -98,6 +99,161 @@ You'll have a `.claude` folder in your project:
 /myai-configure agents --list
 ```
 
+## 🔄 Updating MyAIDev Method
+
+The MyAIDev Method package receives regular updates with new features, bug fixes, and improved agents. Keep your installation up to date to access the latest capabilities.
+
+### Checking for Updates
+
+Your current installation version is stored in `.claude/.myaidev-version`. When new versions are published to npm, you can update using the dedicated update command.
+
+### Running Updates
+
+```bash
+# Interactive update (recommended) - prompts for conflicts
+npx myaidev-method@latest update --claude
+
+# Force update - overwrites all files without prompting
+npx myaidev-method@latest update --claude --force
+
+# Preview changes - see what would be updated without making changes
+npx myaidev-method@latest update --claude --dry-run
+
+# Verbose output - show detailed progress
+npx myaidev-method@latest update --claude --verbose
+```
+
+### What Gets Updated
+
+The update command updates all MyAIDev Method components:
+
+- ✅ **Slash commands** (`.claude/commands/`) - New commands and improvements
+- ✅ **Agent definitions** (`.claude/agents/`) - Enhanced prompts and capabilities
+- ✅ **Executable scripts** (`.myaidev-method/scripts/`) - Bug fixes and new features
+- ✅ **Utility libraries** (`.myaidev-method/lib/`) - Helper functions and utilities
+- ✅ **Documentation files** (`USER_GUIDE.md`, `PUBLISHING_GUIDE.md`, etc.) - Updated guides
+- ✅ **MCP configurations** (`.claude/mcp/`) - Server configurations and integrations
+- ✅ **Dependencies** (`.myaidev-method/package.json`) - npm package updates
+
+### Handling Customizations
+
+If you've customized agents or commands, the update process intelligently handles conflicts:
+
+1. **Detection**: The update command detects which files you've modified
+2. **Diff Display**: Shows you the differences between your version and the new version
+3. **User Choice**: You decide what to do for each modified file:
+   - **Keep current** - Skip this update, preserve your customizations
+   - **Use new version** - Overwrite with the latest version
+   - **View diff** - See detailed line-by-line differences
+   - **Keep + backup** - Update to new version and save your current version as `.bak`
+
+Example update session:
+
+```
+$ npx myaidev-method@latest update --claude
+
+🔍 Detecting MyAIDev Method installation...
+
+✓ Found claude installation
+  Current version: 0.2.11
+  Latest version: 0.2.12
+
+⚠️  This will update your MyAIDev Method installation
+   Modified files will require your confirmation
+
+? Continue with update? Yes
+
+💾 Creating backup...
+✓ Backup created at: .myaidev-method-backup-2025-11-10T20-59-00
+
+📦 Updating components...
+
+Commands:
+  ➕ myai-new-feature.md (new)
+  ✓ myai-git-pr.md (unchanged)
+
+Agents:
+📝 content-writer.md has been modified
+? What would you like to do?
+  ❯ Keep current version (skip update)
+    Use new version (overwrite)
+    View diff
+    Keep current + backup (.bak)
+
+  ✅ payloadcms-publish.md (updated)
+
+Scripts:
+  ✅ payloadcms-publish.js (updated)
+  ✅ coolify-deploy-app.js (updated)
+
+═══════════════════════════════════════
+  Update Summary
+═══════════════════════════════════════
+  ✅ Updated: 5 files
+  ➕ Added: 2 new files
+  ⏭️  Skipped: 1 files (kept current)
+═══════════════════════════════════════
+
+✅ Successfully updated to v0.2.12
+   Backup available at: .myaidev-method-backup-2025-11-10T20-59-00
+```
+
+### Safety Features
+
+**Automatic Backups**: Before making any changes, the update command creates a complete backup:
+```
+.myaidev-method-backup-{timestamp}/
+├── .claude/
+├── .myaidev-method/
+└── *.md (documentation files)
+```
+
+**Dry Run Mode**: Preview all changes without modifying any files:
+```bash
+npx myaidev-method@latest update --claude --dry-run
+```
+
+**Version Tracking**: The update command checks your current version and only proceeds if an update is available.
+
+### Best Practices
+
+1. **Review Release Notes**: Check the [CHANGELOG.md](CHANGELOG.md) before updating
+2. **Use Dry Run**: Preview changes with `--dry-run` before actual update
+3. **Backup Custom Work**: If you have heavily customized agents, create manual backups
+4. **Update Regularly**: Stay current with latest features and security fixes
+5. **Test After Update**: Verify your workflows still function as expected
+
+### Troubleshooting Updates
+
+**Update command not found**:
+```bash
+# Ensure you're using the latest package
+npx myaidev-method@latest --version
+```
+
+**No installation detected**:
+```bash
+# Verify installation exists
+ls -la .claude
+
+# Reinstall if needed
+npx myaidev-method@latest init --claude
+```
+
+**Dependency installation fails**:
+```bash
+# Manually install dependencies
+cd .myaidev-method
+npm install
+```
+
+**Want to rollback an update**:
+```bash
+# Restore from backup
+rm -rf .claude .myaidev-method *.md
+cp -r .myaidev-method-backup-{timestamp}/* .
+```
+
 ## 🏗️ Understanding the Structure
 
 ### Commands Directory (`.claude/commands/`)

package/bin/cli.js

@@ -327,6 +327,29 @@ To update dependencies, run \`npm install\` inside the \`.myaidev-method/\` dire
 .myaidev-method/node_modules/
 \`\`\`
 
+## Updating MyAIDev Method
+
+To get the latest features, bug fixes, and improved agents:
+
+\`\`\`bash
+# Interactive update (recommended) - prompts for conflicts
+npx myaidev-method@latest update --claude
+
+# Force update - overwrites all files
+npx myaidev-method@latest update --claude --force
+
+# Preview changes without updating
+npx myaidev-method@latest update --claude --dry-run
+\`\`\`
+
+The update command:
+- ✅ Preserves your customizations (interactive conflict resolution)
+- ✅ Creates automatic backups before updating
+- ✅ Updates all components (commands, agents, scripts, docs)
+- ✅ Installs updated dependencies
+
+See \`USER_GUIDE.md\` for detailed update instructions and best practices.
+
 ## Notes
 
 This configuration follows Claude Code's official standards for custom commands and agents.
@@ -424,6 +447,11 @@ This configuration follows Claude Code's official standards for custom commands
       await fs.copy(sourcePath, path.join(projectDir, docFile));
     }
   }
+
+  // Save installation version for update tracking
+  const pkgJson = await fs.readJson(path.join(__dirname, '..', 'package.json'));
+  const versionFile = path.join(claudeDir, '.myaidev-version');
+  await fs.writeFile(versionFile, pkgJson.version);
 }
 
 async function setupGemini(projectDir) {
@@ -582,6 +610,154 @@ For full documentation, see the USER_GUIDE.md in your project root.
   await fs.writeFile(path.join(codexDir, 'README.md'), opencodeReadme);
 }
 
+program
+  .command('update')
+  .description('Update MyAIDev Method components to latest version')
+  .option('--claude', 'Update Claude Code configuration')
+  .option('--gemini', 'Update Gemini CLI configuration')
+  .option('--codex', 'Update Codex CLI configuration')
+  .option('--force', 'Force update all files without prompting')
+  .option('--dry-run', 'Show what would be updated without making changes')
+  .option('--verbose', 'Show detailed progress')
+  .action(async (options) => {
+    const ora = (await import('ora')).default;
+    const { fileURLToPath } = await import('url');
+    const updateManager = await import('../src/lib/update-manager.js');
+
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = path.dirname(__filename);
+    const packageRoot = path.join(__dirname, '..');
+
+    try {
+      const cwd = process.cwd();
+
+      // Detect existing installation
+      console.log(chalk.cyan('\n🔍 Detecting MyAIDev Method installation...\n'));
+      const installation = await updateManager.detectExistingInstallation(cwd);
+
+      if (!installation) {
+        console.log(chalk.red('❌ No MyAIDev Method installation found'));
+        console.log(chalk.gray('   Run: npx myaidev-method@latest init --claude'));
+        process.exit(1);
+      }
+
+      console.log(chalk.green(`✓ Found ${installation.type} installation`));
+      console.log(chalk.gray(`  Current version: ${installation.currentVersion}`));
+
+      // Get package version
+      const packageJson = await fs.readJson(path.join(packageRoot, 'package.json'));
+      const newVersion = packageJson.version;
+
+      console.log(chalk.gray(`  Latest version: ${newVersion}`));
+
+      // Check if already up to date
+      if (installation.currentVersion === newVersion && !options.force) {
+        console.log(chalk.green('\n✅ Already up to date!'));
+        process.exit(0);
+      }
+
+      if (options.dryRun) {
+        console.log(chalk.yellow('\n📋 DRY RUN MODE - No changes will be made\n'));
+      } else if (!options.force) {
+        console.log(chalk.yellow('\n⚠️  This will update your MyAIDev Method installation'));
+        console.log(chalk.gray('   Modified files will require your confirmation\n'));
+
+        const { confirm } = await inquirer.prompt([
+          {
+            type: 'confirm',
+            name: 'confirm',
+            message: 'Continue with update?',
+            default: true
+          }
+        ]);
+
+        if (!confirm) {
+          console.log(chalk.gray('Update cancelled'));
+          process.exit(0);
+        }
+      }
+
+      // Create backup unless dry-run
+      let backupDir;
+      if (!options.dryRun) {
+        console.log(chalk.cyan('\n💾 Creating backup...'));
+        backupDir = await updateManager.createBackup(cwd, installation.type);
+        console.log(chalk.green(`✓ Backup created at: ${path.basename(backupDir)}`));
+      }
+
+      // Update components
+      const allStats = {};
+
+      console.log(chalk.cyan('\n📦 Updating components...\n'));
+
+      // Commands
+      console.log(chalk.blue('Commands:'));
+      allStats.commands = await updateManager.updateComponent(
+        'commands', cwd, installation.type, packageRoot, options
+      );
+
+      // Agents
+      console.log(chalk.blue('\nAgents:'));
+      allStats.agents = await updateManager.updateComponent(
+        'agents', cwd, installation.type, packageRoot, options
+      );
+
+      // Scripts
+      console.log(chalk.blue('\nScripts:'));
+      allStats.scripts = await updateManager.updateComponent(
+        'scripts', cwd, installation.type, packageRoot, options
+      );
+
+      // Libraries
+      console.log(chalk.blue('\nLibraries:'));
+      allStats.lib = await updateManager.updateComponent(
+        'lib', cwd, installation.type, packageRoot, options
+      );
+
+      // MCP configurations
+      console.log(chalk.blue('\nMCP Configurations:'));
+      allStats.mcp = await updateManager.updateComponent(
+        'mcp', cwd, installation.type, packageRoot, options
+      );
+
+      // Documentation
+      console.log(chalk.blue('\nDocumentation:'));
+      allStats.docs = await updateManager.updateComponent(
+        'docs', cwd, installation.type, packageRoot, options
+      );
+
+      // Update dependencies
+      if (!options.dryRun) {
+        await updateManager.updateDependencies(cwd);
+      }
+
+      // Save new version
+      if (!options.dryRun) {
+        await updateManager.saveVersion(cwd, installation.type, newVersion);
+      }
+
+      // Show report
+      updateManager.generateUpdateReport(allStats);
+
+      if (options.dryRun) {
+        console.log(chalk.yellow('This was a dry run. No changes were made.'));
+      } else {
+        console.log(chalk.green(`✅ Successfully updated to v${newVersion}`));
+        if (backupDir) {
+          console.log(chalk.gray(`   Backup available at: ${path.basename(backupDir)}`));
+        }
+      }
+
+    } catch (error) {
+      console.error(chalk.red('\n❌ Update failed:'));
+      console.error(error.message);
+      if (options.verbose) {
+        console.error(error);
+      }
+      process.exit(1);
+    }
+  });
+
 program
   .command('claudeweb')
   .description('Start MyAIDev Method Web UI with Claude Code Viewer')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "myaidev-method",
-  "version": "0.2.11",
+  "version": "0.2.12",
   "description": "Comprehensive development framework with SPARC methodology for AI-assisted software development, multi-platform publishing (WordPress, PayloadCMS, Astro, Docusaurus, Mintlify), and Coolify deployment",
   "mcpName": "io.github.myaione/myaidev-method",
   "main": "src/index.js",
@@ -142,7 +142,8 @@
     "PUBLISHING_GUIDE.md",
     "TECHNICAL_ARCHITECTURE.md",
     "PACKAGE_FIXES_SUMMARY.md",
-    "PAYLOADCMS_AUTH_UPDATE.md"
+    "PAYLOADCMS_AUTH_UPDATE.md",
+    "CHANGELOG.md"
   ],
   "engines": {
     "node": ">=18.0.0"

package/src/lib/update-manager.js

@@ -0,0 +1,385 @@
+import fs from 'fs-extra';
+import path from 'path';
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import { createHash } from 'crypto';
+
+/**
+ * Update Manager for MyAIDev Method
+ * Handles intelligent updates with conflict resolution
+ */
+
+/**
+ * Detect existing MyAIDev Method installation
+ * @param {string} projectDir - Project directory path
+ * @returns {Object} Installation info or null
+ */
+export async function detectExistingInstallation(projectDir) {
+  const installations = {
+    claude: path.join(projectDir, '.claude'),
+    gemini: path.join(projectDir, '.gemini'),
+    codex: path.join(projectDir, '.codex')
+  };
+
+  for (const [type, dir] of Object.entries(installations)) {
+    if (await fs.pathExists(dir)) {
+      // Check for version file
+      const versionFile = path.join(dir, '.myaidev-version');
+      let currentVersion = 'unknown';
+
+      if (await fs.pathExists(versionFile)) {
+        currentVersion = (await fs.readFile(versionFile, 'utf-8')).trim();
+      }
+
+      return {
+        type,
+        dir,
+        currentVersion,
+        scriptsDir: path.join(projectDir, '.myaidev-method')
+      };
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Get file hash for comparison
+ * @param {string} filePath - Path to file
+ * @returns {string} File hash
+ */
+async function getFileHash(filePath) {
+  if (!await fs.pathExists(filePath)) {
+    return null;
+  }
+  const content = await fs.readFile(filePath);
+  return createHash('md5').update(content).digest('hex');
+}
+
+/**
+ * Compare two files
+ * @param {string} localFile - Local file path
+ * @param {string} newFile - New file path
+ * @returns {string} Status: 'identical', 'modified', 'new', 'deleted'
+ */
+export async function compareFiles(localFile, newFile) {
+  const localExists = await fs.pathExists(localFile);
+  const newExists = await fs.pathExists(newFile);
+
+  if (!localExists && newExists) return 'new';
+  if (localExists && !newExists) return 'deleted';
+  if (!localExists && !newExists) return 'none';
+
+  const localHash = await getFileHash(localFile);
+  const newHash = await getFileHash(newFile);
+
+  return localHash === newHash ? 'identical' : 'modified';
+}
+
+/**
+ * Show diff preview for a file
+ * @param {string} localFile - Local file path
+ * @param {string} newFile - New file path
+ */
+async function showDiff(localFile, newFile) {
+  const localContent = await fs.readFile(localFile, 'utf-8');
+  const newContent = await fs.readFile(newFile, 'utf-8');
+
+  const localLines = localContent.split('\n');
+  const newLines = newContent.split('\n');
+
+  console.log(chalk.cyan('\n  Local version (first 10 lines):'));
+  localLines.slice(0, 10).forEach((line, i) => {
+    console.log(chalk.gray(`  ${i + 1}: ${line.slice(0, 80)}`));
+  });
+
+  console.log(chalk.green('\n  New version (first 10 lines):'));
+  newLines.slice(0, 10).forEach((line, i) => {
+    console.log(chalk.gray(`  ${i + 1}: ${line.slice(0, 80)}`));
+  });
+
+  console.log(chalk.yellow(`\n  Local: ${localLines.length} lines, New: ${newLines.length} lines\n`));
+}
+
+/**
+ * Prompt user for conflict resolution
+ * @param {string} file - File path relative to project
+ * @param {string} localPath - Local file absolute path
+ * @param {string} newPath - New file absolute path
+ * @returns {string} User choice: 'keep', 'replace', 'backup'
+ */
+export async function promptForConflict(file, localPath, newPath) {
+  console.log(chalk.yellow(`\n📝 ${file} has been modified`));
+
+  const answer = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'action',
+      message: 'What would you like to do?',
+      choices: [
+        { name: 'Keep current version (skip update)', value: 'keep' },
+        { name: 'Use new version (overwrite)', value: 'replace' },
+        { name: 'View diff', value: 'diff' },
+        { name: 'Keep current + backup (.bak)', value: 'backup' }
+      ]
+    }
+  ]);
+
+  if (answer.action === 'diff') {
+    await showDiff(localPath, newPath);
+    // Prompt again after showing diff
+    return promptForConflict(file, localPath, newPath);
+  }
+
+  return answer.action;
+}
+
+/**
+ * Create backup of installation
+ * @param {string} projectDir - Project directory
+ * @param {string} cliType - CLI type (claude/gemini/codex)
+ * @returns {string} Backup directory path
+ */
+export async function createBackup(projectDir, cliType) {
+  const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, -5);
+  const backupDir = path.join(projectDir, `.myaidev-method-backup-${timestamp}`);
+
+  await fs.ensureDir(backupDir);
+
+  // Backup CLI directory
+  const cliDir = path.join(projectDir, `.${cliType}`);
+  if (await fs.pathExists(cliDir)) {
+    await fs.copy(cliDir, path.join(backupDir, `.${cliType}`));
+  }
+
+  // Backup scripts directory
+  const scriptsDir = path.join(projectDir, '.myaidev-method');
+  if (await fs.pathExists(scriptsDir)) {
+    await fs.copy(scriptsDir, path.join(backupDir, '.myaidev-method'));
+  }
+
+  // Backup documentation
+  const docs = [
+    'USER_GUIDE.md',
+    'PUBLISHING_GUIDE.md',
+    'COOLIFY_DEPLOYMENT.md',
+    'DEV_WORKFLOW_GUIDE.md',
+    'MCP_INTEGRATION.md',
+    'WORDPRESS_ADMIN_SCRIPTS.md',
+    'TECHNICAL_ARCHITECTURE.md'
+  ];
+
+  for (const doc of docs) {
+    const docPath = path.join(projectDir, doc);
+    if (await fs.pathExists(docPath)) {
+      await fs.copy(docPath, path.join(backupDir, doc));
+    }
+  }
+
+  return backupDir;
+}
+
+/**
+ * Update a specific component
+ * @param {string} componentType - Type of component
+ * @param {string} projectDir - Project directory
+ * @param {string} cliType - CLI type
+ * @param {string} sourceDir - Source directory with new files
+ * @param {Object} options - Update options
+ * @returns {Object} Update statistics
+ */
+export async function updateComponent(componentType, projectDir, cliType, sourceDir, options = {}) {
+  const stats = {
+    updated: 0,
+    skipped: 0,
+    added: 0,
+    errors: 0
+  };
+
+  let targetDir, sourceSubDir;
+
+  switch (componentType) {
+    case 'commands':
+      targetDir = path.join(projectDir, `.${cliType}`, 'commands');
+      sourceSubDir = path.join(sourceDir, 'src', 'templates', cliType, 'commands');
+      break;
+    case 'agents':
+      targetDir = path.join(projectDir, `.${cliType}`, 'agents');
+      sourceSubDir = path.join(sourceDir, 'src', 'templates', 'claude', 'agents');
+      break;
+    case 'scripts':
+      targetDir = path.join(projectDir, '.myaidev-method', 'scripts');
+      sourceSubDir = path.join(sourceDir, 'src', 'scripts');
+      break;
+    case 'lib':
+      targetDir = path.join(projectDir, '.myaidev-method', 'lib');
+      sourceSubDir = path.join(sourceDir, 'src', 'lib');
+      break;
+    case 'mcp':
+      targetDir = path.join(projectDir, `.${cliType}`, 'mcp');
+      sourceSubDir = path.join(sourceDir, '.claude', 'mcp');
+      break;
+    case 'docs':
+      targetDir = projectDir;
+      sourceSubDir = sourceDir;
+      break;
+    default:
+      throw new Error(`Unknown component type: ${componentType}`);
+  }
+
+  if (!await fs.pathExists(sourceSubDir)) {
+    console.log(chalk.gray(`  Skipping ${componentType} (not found in package)`));
+    return stats;
+  }
+
+  const files = componentType === 'docs'
+    ? ['USER_GUIDE.md', 'PUBLISHING_GUIDE.md', 'COOLIFY_DEPLOYMENT.md', 'DEV_WORKFLOW_GUIDE.md',
+       'MCP_INTEGRATION.md', 'WORDPRESS_ADMIN_SCRIPTS.md', 'TECHNICAL_ARCHITECTURE.md']
+    : await fs.readdir(sourceSubDir);
+
+  for (const file of files) {
+    // Skip init-project.js from scripts
+    if (componentType === 'scripts' && file === 'init-project.js') continue;
+
+    const sourcePath = path.join(sourceSubDir, file);
+    const targetPath = path.join(targetDir, file);
+
+    // Skip if source doesn't exist (for docs)
+    if (!await fs.pathExists(sourcePath)) continue;
+
+    // Skip directories
+    const sourceStats = await fs.stat(sourcePath);
+    if (sourceStats.isDirectory()) continue;
+
+    // Skip non-relevant files for component type
+    if (componentType === 'commands' && !file.endsWith('.md') && !file.endsWith('.toml')) continue;
+    if (componentType === 'agents' && !file.endsWith('.md')) continue;
+    if (componentType === 'scripts' && !file.endsWith('.js')) continue;
+    if (componentType === 'mcp' && !file.endsWith('.js') && !file.endsWith('.json')) continue;
+
+    const status = await compareFiles(targetPath, sourcePath);
+
+    if (status === 'identical') {
+      if (options.verbose) {
+        console.log(chalk.gray(`  ✓ ${file} (unchanged)`));
+      }
+      continue;
+    }
+
+    if (status === 'new') {
+      await fs.copy(sourcePath, targetPath);
+      console.log(chalk.green(`  ➕ ${file} (new)`));
+      stats.added++;
+      continue;
+    }
+
+    if (status === 'modified') {
+      if (options.force) {
+        await fs.copy(sourcePath, targetPath);
+        console.log(chalk.blue(`  ✅ ${file} (updated)`));
+        stats.updated++;
+      } else if (options.dryRun) {
+        console.log(chalk.yellow(`  📝 ${file} (would update)`));
+      } else {
+        const action = await promptForConflict(file, targetPath, sourcePath);
+
+        if (action === 'replace') {
+          await fs.copy(sourcePath, targetPath);
+          console.log(chalk.blue(`  ✅ ${file} (updated)`));
+          stats.updated++;
+        } else if (action === 'backup') {
+          await fs.copy(targetPath, `${targetPath}.bak`);
+          await fs.copy(sourcePath, targetPath);
+          console.log(chalk.blue(`  ✅ ${file} (updated, backup created)`));
+          stats.updated++;
+        } else {
+          console.log(chalk.gray(`  ⏭️  ${file} (kept current)`));
+          stats.skipped++;
+        }
+      }
+    }
+  }
+
+  return stats;
+}
+
+/**
+ * Update dependencies in .myaidev-method
+ * @param {string} projectDir - Project directory
+ * @returns {boolean} Success status
+ */
+export async function updateDependencies(projectDir) {
+  const myaidevDir = path.join(projectDir, '.myaidev-method');
+  const packageJsonPath = path.join(myaidevDir, 'package.json');
+
+  if (!await fs.pathExists(packageJsonPath)) {
+    console.log(chalk.yellow('  ⚠️  No package.json found in .myaidev-method/'));
+    return false;
+  }
+
+  console.log(chalk.cyan('\n📦 Updating dependencies...'));
+
+  const { execSync } = await import('child_process');
+  try {
+    execSync('npm install', {
+      cwd: myaidevDir,
+      stdio: 'inherit'
+    });
+    console.log(chalk.green('  ✓ Dependencies updated successfully'));
+    return true;
+  } catch (error) {
+    console.log(chalk.red('  ✗ Failed to update dependencies'));
+    console.log(chalk.gray('  Run: cd .myaidev-method && npm install'));
+    return false;
+  }
+}
+
+/**
+ * Save version to installation
+ * @param {string} projectDir - Project directory
+ * @param {string} cliType - CLI type
+ * @param {string} version - Version to save
+ */
+export async function saveVersion(projectDir, cliType, version) {
+  const versionFile = path.join(projectDir, `.${cliType}`, '.myaidev-version');
+  await fs.writeFile(versionFile, version);
+}
+
+/**
+ * Generate update report
+ * @param {Object} allStats - Combined statistics from all components
+ */
+export function generateUpdateReport(allStats) {
+  const total = {
+    updated: 0,
+    skipped: 0,
+    added: 0,
+    errors: 0
+  };
+
+  for (const stats of Object.values(allStats)) {
+    total.updated += stats.updated;
+    total.skipped += stats.skipped;
+    total.added += stats.added;
+    total.errors += stats.errors;
+  }
+
+  console.log(chalk.cyan('\n═══════════════════════════════════════'));
+  console.log(chalk.cyan('  Update Summary'));
+  console.log(chalk.cyan('═══════════════════════════════════════'));
+
+  if (total.updated > 0) {
+    console.log(chalk.green(`  ✅ Updated: ${total.updated} files`));
+  }
+  if (total.added > 0) {
+    console.log(chalk.green(`  ➕ Added: ${total.added} new files`));
+  }
+  if (total.skipped > 0) {
+    console.log(chalk.gray(`  ⏭️  Skipped: ${total.skipped} files (kept current)`));
+  }
+  if (total.errors > 0) {
+    console.log(chalk.red(`  ✗ Errors: ${total.errors} files`));
+  }
+
+  console.log(chalk.cyan('═══════════════════════════════════════\n'));
+}