myaidev-method 0.2.10 → 0.2.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "myaidev-method",
-  "version": "0.2.10",
+  "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'));
+}