@joltdesign/scripts 0.21.0 → 0.22.1

package/dist/Command/WP.js

@@ -1,8 +1,10 @@
+import fs from 'node:fs/promises';
 import { userInfo } from 'node:os';
+import path from 'node:path';
 import ansis from 'ansis';
 import { Option } from 'clipanion';
 import * as t from 'typanion';
-import { execC, which } from '../utils.js';
+import { execC, fileExists, which } from '../utils.js';
 import JoltCommand from './JoltCommand.js';
 // Possible sub-arguments for the CLI command as of WP-CLI v2.12.0
 const possibleCliArgs = [
@@ -113,9 +115,10 @@ export class WPUpdateCommand extends JoltCommand {
         this.skipCore = Option.Boolean('--skip-core', false, { description: 'Skip WordPress core updates' });
         this.skipPlugins = Option.Boolean('--skip-plugins', false, { description: 'Skip plugin updates' });
         this.skipThemes = Option.Boolean('--skip-themes', false, { description: 'Skip theme updates' });
+        this.skipLanguages = Option.Boolean('--skip-languages', false, { description: 'Skip language/translation updates' });
     }
     async command() {
-        const { config, context: { stdout, stderr }, skipCore, skipPlugins, skipThemes, logo, } = this;
+        const { config, context: { stdout, stderr }, skipCore, skipPlugins, skipThemes, skipLanguages, logo, } = this;
         stdout.write(ansis.bold(`${logo} WordPress Updates\n\n`));
         // Load configuration
         const wpConfig = await config.loadWordPressConfig();
@@ -127,30 +130,19 @@ export class WPUpdateCommand extends JoltCommand {
         let updatedPluginCount = 0;
         let updatedThemeCount = 0;
         let updatedCore = false;
+        // Track detailed update information for summary
+        const updateSummary = {
+            plugins: [],
+            themes: [],
+            core: null,
+            translations: false,
+        };
         // Get current status
         if (!skipPlugins) {
-            stdout.write(ansis.cyan('🔌 Checking plugins...\n'));
-            const yarnCommand = await config.command('yarn');
-            const pluginsResult = await execC(yarnCommand, ['jolt', 'wp', 'cli', 'plugin', 'list', '--json'], {
-                reject: false,
-            });
-            const pluginsJson = pluginsResult.exitCode === 0 ? String(pluginsResult.stdout || '') : null;
-            if (pluginsJson) {
-                const plugins = this.parsePluginJson(pluginsJson);
-                stdout.write(`Found ${plugins.length} plugins\n`);
-            }
+            await this.getItems('plugin');
         }
         if (!skipThemes) {
-            stdout.write(ansis.cyan('🎨 Checking themes...\n'));
-            const yarnCommand = await config.command('yarn');
-            const themesResult = await execC(yarnCommand, ['jolt', 'wp', 'cli', 'theme', 'list', '--json'], {
-                reject: false,
-            });
-            const themesJson = themesResult.exitCode === 0 ? String(themesResult.stdout || '') : null;
-            if (themesJson) {
-                const themes = this.parseThemeJson(themesJson);
-                stdout.write(`Found ${themes.length} themes\n`);
-            }
+            await this.getItems('theme');
         }
         // We'll create the update branch only when we need to make our first commit
         const branchRef = { branch: undefined, created: false };
@@ -158,45 +150,21 @@ export class WPUpdateCommand extends JoltCommand {
         const originalHookPath = await this.disableGitHooks();
         try {
             // Update plugins
-            if (!skipPlugins) {
-                stdout.write(ansis.cyan('🔌 Updating plugins...\n'));
-                const yarnCommand = await config.command('yarn');
-                const pluginsResult = await execC(yarnCommand, ['jolt', 'wp', 'cli', 'plugin', 'list', '--json'], {
-                    reject: false,
-                });
-                const pluginsJson = pluginsResult.exitCode === 0 ? String(pluginsResult.stdout || '') : null;
-                if (pluginsJson) {
-                    const plugins = this.parsePluginJson(pluginsJson);
-                    for (const plugin of plugins) {
-                        const didUpdate = await this.maybeUpdatePlugin(plugin, wpConfig, branchRef);
-                        if (didUpdate) {
-                            updatedPluginCount++;
-                        }
-                    }
-                }
-            }
+            const pluginUpdates = await this.processItemUpdates('plugin', skipPlugins, wpConfig, branchRef);
+            updatedPluginCount = pluginUpdates.count;
+            updateSummary.plugins = pluginUpdates.details;
             // Update themes
-            if (!skipThemes) {
-                stdout.write(ansis.cyan('🎨 Updating themes...\n'));
-                const yarnCommand = await config.command('yarn');
-                const themesResult = await execC(yarnCommand, ['jolt', 'wp', 'cli', 'theme', 'list', '--json'], {
-                    reject: false,
-                });
-                const themesJson = themesResult.exitCode === 0 ? String(themesResult.stdout || '') : null;
-                if (themesJson) {
-                    const themes = this.parseThemeJson(themesJson);
-                    for (const theme of themes) {
-                        const didUpdate = await this.maybeUpdateTheme(theme, wpConfig, branchRef);
-                        if (didUpdate) {
-                            updatedThemeCount++;
-                        }
-                    }
-                }
-            }
+            const themeUpdates = await this.processItemUpdates('theme', skipThemes, wpConfig, branchRef);
+            updatedThemeCount = themeUpdates.count;
+            updateSummary.themes = themeUpdates.details;
             // Update core
             if (!skipCore) {
                 stdout.write(ansis.cyan('📦 Checking WordPress core...\n'));
-                updatedCore = await this.maybeUpdateCore(wpConfig, branchRef);
+                const coreResult = await this.maybeUpdateCore(wpConfig, branchRef);
+                updatedCore = coreResult.updated;
+                if (coreResult.updated && coreResult.details) {
+                    updateSummary.core = coreResult.details;
+                }
             }
         }
         finally {
@@ -210,218 +178,280 @@ export class WPUpdateCommand extends JoltCommand {
             stdout.write(ansis.cyan('📦 Updated WordPress core\n'));
         }
         const totalUpdates = updatedPluginCount + updatedThemeCount + (updatedCore ? 1 : 0);
+        // Update translations if possible
+        let updatedTranslations = false;
+        if (!skipLanguages && (totalUpdates > 0 || !branchRef.created)) {
+            stdout.write(ansis.cyan('🌐 Updating translations...\n'));
+            updatedTranslations = await this.maybeUpdateTranslations(branchRef);
+            updateSummary.translations = updatedTranslations;
+        }
+        // Show detailed update summary
+        if (totalUpdates > 0 || updatedTranslations) {
+            stdout.write(ansis.bold('\n📋 Update Summary:\n'));
+            if (updateSummary.plugins.length > 0) {
+                stdout.write(ansis.green('🔌 Plugins updated:\n'));
+                for (const plugin of updateSummary.plugins) {
+                    stdout.write(ansis.cyan(`  • ${plugin.title} (${plugin.fromVersion} → ${plugin.toVersion})\n`));
+                }
+            }
+            if (updateSummary.themes.length > 0) {
+                stdout.write(ansis.green('🎨 Themes updated:\n'));
+                for (const theme of updateSummary.themes) {
+                    stdout.write(ansis.cyan(`  • ${theme.title} (${theme.fromVersion} → ${theme.toVersion})\n`));
+                }
+            }
+            if (updateSummary.core) {
+                stdout.write(ansis.green('📦 WordPress core updated:\n'));
+                stdout.write(ansis.cyan(`  • WordPress (${updateSummary.core.fromVersion} → ${updateSummary.core.toVersion})\n`));
+            }
+            if (updateSummary.translations) {
+                stdout.write(ansis.green('🌐 Translations updated\n'));
+            }
+        }
         if (totalUpdates > 0 && branchRef.created) {
             stdout.write(ansis.yellow('\nNext steps:\n'));
-            stdout.write(`• Review updates: ${ansis.dim('jolt wp update modify')}\n`);
+            stdout.write(`• Review updates: ${ansis.dim(await this.getUpdateCommand('modify'))}\n`);
             // Use root config value directly
-            stdout.write(`• Merge to ${await config.get('branch')}: ${ansis.dim('jolt wp update merge')}\n`);
+            stdout.write(`• Merge to ${await config.get('branch')}: ${ansis.dim(await this.getUpdateCommand('merge'))}\n`);
         }
-        else if (totalUpdates === 0) {
+        else if (totalUpdates === 0 && !updatedTranslations) {
             stdout.write(ansis.green('\n✅ No updates available - staying on current branch\n'));
         }
         return 0;
     }
-    // Note: WP CLI invocations run via `yarn jolt wp cli ...` using execC directly.
-    parsePluginJson(pluginsJson) {
-        // Trim off any preceding warnings, try to look for the start of the actual JSON.
-        const trimmed = pluginsJson.substring(pluginsJson.indexOf('[{'));
-        const allPlugins = JSON.parse(trimmed);
-        return allPlugins.filter((plugin) => !['dropin', 'must-use'].includes(plugin.status));
-    }
-    parseThemeJson(themeJson) {
-        // Trim off any preceding warnings, try to look for the start of the actual JSON.
-        const trimmed = themeJson.substring(themeJson.indexOf('[{'));
-        return JSON.parse(trimmed);
-    }
-    // (No helper) obtain the package runner directly via config.command('yarn') where needed
-    async createBranch() {
-        const { config, context } = this;
-        const isoDate = new Date().toISOString().replace(/[:.]/g, '-').replace(/T/, '_').slice(0, -5);
-        const branchName = `joltWpUpdate/${isoDate}`;
-        const gitCommand = await config.command('git');
-        await execC(gitCommand, ['checkout', '-b', branchName], { context });
-        return branchName;
-    }
-    async ensureBranchCreated(_wpConfig, branchRef) {
-        if (!branchRef.created) {
-            branchRef.branch = await this.createBranch();
-            branchRef.created = true;
-            const { context: { stdout }, } = this;
-            stdout.write(ansis.green(`📋 Created update branch ${branchRef.branch}\n`));
-        }
-        return branchRef.branch;
-    }
-    async disableGitHooks() {
-        const { config, context } = this;
-        const gitCommand = await config.command('git');
-        try {
-            const result = await execC(gitCommand, ['config', '--get', 'core.hooksPath'], { context, reject: false });
-            const originalHookPath = String(result.stdout || '').trim();
-            await execC(gitCommand, ['config', 'core.hooksPath', '/dev/null'], { context });
-            return originalHookPath;
-        }
-        catch (_a) {
-            await execC(gitCommand, ['config', 'core.hooksPath', '/dev/null'], { context });
-            return '';
+    // Helper method to get the appropriate command format (short or long form)
+    async getUpdateCommand(subCommand) {
+        var _a;
+        const { config } = this;
+        const yarnCommand = await config.command('yarn');
+        const packageJson = await config.getPackageJson();
+        // Check if there's an 'update' script that acts as a shortcut for 'jolt wp update'
+        const updateScript = (_a = packageJson === null || packageJson === void 0 ? void 0 : packageJson.scripts) === null || _a === void 0 ? void 0 : _a.update;
+        if (updateScript && (updateScript === 'jolt wp update' || updateScript.startsWith('jolt wp update '))) {
+            return `${yarnCommand} update ${subCommand}`;
         }
+        // Fall back to the full command
+        return `${yarnCommand} jolt wp update ${subCommand}`;
     }
-    async rollbackGitHooks(originalHookPath) {
+    // Helper method to execute WP CLI commands
+    async executeWpCli(args, options) {
         const { config, context } = this;
-        const gitCommand = await config.command('git');
-        if (originalHookPath) {
-            await execC(gitCommand, ['config', 'core.hooksPath', originalHookPath], { context });
-        }
-        else {
-            await execC(gitCommand, ['config', '--unset', 'core.hooksPath'], { context, reject: false });
-        }
-    }
-    async maybeUpdatePlugin(plugin, wpConfig, branchRef) {
+        const yarnCommand = await config.command('yarn');
+        // For silent operations, don't pass context to suppress output
+        const execOptions = {
+            reject: false,
+            ...options,
+            ...(!(options === null || options === void 0 ? void 0 : options.silent) ? { context } : {}),
+        };
+        const result = await execC(yarnCommand, ['jolt', 'wp', 'cli', ...args], execOptions);
+        return {
+            exitCode: result.exitCode || 0,
+            stdout: result.exitCode === 0 ? String(result.stdout || '') : null,
+        };
+    }
+    // Configuration for different item types
+    getItemConfig(type) {
+        const configs = {
+            plugin: {
+                type: 'plugin',
+                icon: '🔌',
+                listCommand: ['plugin', 'list', '--json'],
+                updateCommand: (name) => ['plugin', 'update', name],
+                getFolder: (wpConfig) => wpConfig.pluginFolder,
+                commitPrefix: 'Update',
+            },
+            theme: {
+                type: 'theme',
+                icon: '🎨',
+                listCommand: ['theme', 'list', '--json'],
+                updateCommand: (name) => ['theme', 'update', name],
+                getFolder: (wpConfig) => wpConfig.themeFolder,
+                commitPrefix: 'Update theme',
+            },
+        };
+        return configs[type];
+    }
+    // Generic method to get and parse item lists
+    async getItems(type) {
         const { context: { stdout }, } = this;
-        if (wpConfig.doNotUpdate.includes(plugin.name)) {
-            stdout.write(ansis.dim(`  Skipping ${plugin.name} (configured to skip)\n`));
-            return false;
-        }
-        stdout.write(`  Checking ${plugin.name}...`);
-        if (plugin.update === 'available') {
-            stdout.write(ansis.green(' updating\n'));
-            return await this.updatePlugin(plugin, wpConfig, branchRef);
-        }
-        if (plugin.update === 'none') {
-            stdout.write(ansis.dim(' up to date\n'));
-        }
-        else if (plugin.update === 'version higher than expected') {
-            stdout.write(ansis.yellow(` local version ${plugin.version} is higher than remote\n`));
-        }
-        else {
-            stdout.write(ansis.red(` unknown status: ${plugin.update}\n`));
+        const itemConfig = this.getItemConfig(type);
+        stdout.write(ansis.cyan(`${itemConfig.icon} Checking ${type}s...\n`));
+        const result = await this.executeWpCli(itemConfig.listCommand, { silent: true });
+        if (!result.stdout) {
+            return [];
+        }
+        const items = this.parseItemJson(result.stdout);
+        stdout.write(`Found ${items.length} ${type}s\n`);
+        return items;
+    }
+    // Generic method to parse item JSON (plugins/themes have same structure)
+    parseItemJson(itemJson) {
+        // Trim off any preceding warnings, try to look for the start of the actual JSON.
+        const trimmed = itemJson.substring(itemJson.indexOf('[{'));
+        const allItems = JSON.parse(trimmed);
+        // For plugins, filter out dropin and must-use plugins
+        return allItems.filter((item) => !['dropin', 'must-use'].includes(item.status));
+    }
+    // Generic method to handle updating items
+    async processItemUpdates(type, skip, wpConfig, branchRef) {
+        if (skip) {
+            return { count: 0, details: [] };
+        }
+        const itemConfig = this.getItemConfig(type);
+        const items = await this.getItems(type);
+        const updateDetails = [];
+        let count = 0;
+        if (items.length > 0) {
+            this.context.stdout.write(ansis.cyan(`${itemConfig.icon} Updating ${type}s...\n`));
+            for (const item of items) {
+                const result = await this.maybeUpdateItem(item, wpConfig, branchRef, itemConfig);
+                if (result.updated) {
+                    count++;
+                    if (result.details) {
+                        updateDetails.push(result.details);
+                    }
+                }
+            }
         }
-        return false;
+        return { count, details: updateDetails };
     }
-    async maybeUpdateTheme(theme, wpConfig, branchRef) {
+    // Generic method to check and maybe update an item (plugin/theme)
+    async maybeUpdateItem(item, wpConfig, branchRef, itemConfig) {
         const { context: { stdout }, } = this;
-        if (wpConfig.doNotUpdate.includes(theme.name)) {
-            stdout.write(ansis.dim(`  Skipping ${theme.name} (configured to skip)\n`));
-            return false;
+        if (wpConfig.doNotUpdate.includes(item.name)) {
+            stdout.write(ansis.dim(`  Skipping ${item.name} (configured to skip)\n`));
+            return { updated: false };
         }
-        stdout.write(`  Checking ${theme.name}...`);
-        if (theme.update === 'available') {
+        stdout.write(`  Checking ${item.name}...`);
+        if (item.update === 'available') {
             stdout.write(ansis.green(' updating\n'));
-            return await this.updateTheme(theme, wpConfig, branchRef);
+            return await this.updateItem(item, wpConfig, branchRef, itemConfig);
         }
-        if (theme.update === 'none') {
+        if (item.update === 'none') {
             stdout.write(ansis.dim(' up to date\n'));
         }
-        else if (theme.update === 'version higher than expected') {
-            stdout.write(ansis.yellow(` local version ${theme.version} is higher than remote\n`));
+        else if (item.update === 'version higher than expected') {
+            stdout.write(ansis.yellow(` local version ${item.version} is higher than remote\n`));
         }
         else {
-            stdout.write(ansis.red(` unknown status: ${theme.update}\n`));
+            stdout.write(ansis.red(` unknown status: ${item.update}\n`));
         }
-        return false;
+        return { updated: false };
     }
-    async updatePlugin(plugin, wpConfig, branchRef) {
-        const { config, context, context: { stdout, stderr }, } = this;
+    // Generic method to update an item (plugin/theme)
+    async updateItem(item, wpConfig, branchRef, itemConfig) {
+        const { config, context: { stdout, stderr }, } = this;
         try {
             const gitCommand = await config.command('git');
-            const details = await this.getPluginDetails(plugin.name);
+            const details = await this.getDetails(item.name, itemConfig.type);
             if (!details) {
-                return false;
+                return { updated: false };
             }
             const fromVersion = details.version;
             const prettyTitle = this.cleanTitle(details.title);
-            const location = `${wpConfig.pluginFolder}/${plugin.name}`;
-            const yarnCommand = await config.command('yarn');
-            const updateResult = await execC(yarnCommand, ['jolt', 'wp', 'cli', 'plugin', 'update', plugin.name], {
-                reject: false,
-            });
-            const updateResultStr = updateResult.exitCode === 0 ? String(updateResult.stdout || '') : null;
-            if (!updateResultStr) {
-                stderr.write(ansis.red(`    Error updating ${plugin.name}\n`));
-                return false;
+            const location = `${itemConfig.getFolder(wpConfig)}/${item.name}`;
+            const updateResult = await this.executeWpCli(itemConfig.updateCommand(item.name), { silent: true });
+            if (updateResult.exitCode !== 0) {
+                stderr.write(ansis.red(`    Error updating ${item.name}\n`));
+                return { updated: false };
             }
-            const newDetails = await this.getPluginDetails(plugin.name);
+            const newDetails = await this.getDetails(item.name, itemConfig.type);
             if (!newDetails || newDetails.version === details.version) {
                 stderr.write(ansis.red('    Update failed!\n'));
-                return false;
+                return { updated: false };
             }
             // Ensure branch is created before making our first commit
             await this.ensureBranchCreated(wpConfig, branchRef);
-            const commitMessage = this.sanitizeCommitMessage(`Update ${prettyTitle} to ${newDetails.version}`);
-            await execC(gitCommand, ['add', location], { context });
+            // Special case handling for Redis dropin
+            try {
+                const looksLikeRedis = /redis/i.test(String(item.name || details.title || ''));
+                if (looksLikeRedis) {
+                    const cliResult = await this.executeWpCli(['redis', 'update-dropin'], { silent: true });
+                    const wpContentDir = path.join(wpConfig.wpRoot, 'wp-content');
+                    const dropinDest = path.join(wpContentDir, 'object-cache.php');
+                    if (cliResult.exitCode === 0) {
+                        const gitCommand = await config.command('git');
+                        await execC(gitCommand, ['add', dropinDest]);
+                    }
+                    else {
+                        // WP-CLI failed - fall back to copying the plugin-provided dropin
+                        await this.updateRedisDropinFromPlugin(item, wpConfig, itemConfig);
+                    }
+                }
+            }
+            catch (_a) {
+                // non-fatal - continue
+            }
+            const commitMessage = this.sanitizeCommitMessage(`${itemConfig.commitPrefix} ${prettyTitle} to ${newDetails.version}`);
+            await execC(gitCommand, ['add', location]);
             await execC(gitCommand, ['commit', '-m', commitMessage], {
-                context,
                 shell: false,
                 env: { SKIP: 'prepare-commit-msg' },
             });
             stdout.write(ansis.green(`    Updated ${prettyTitle} from ${fromVersion} to ${newDetails.version}\n`));
-            return true;
+            return {
+                updated: true,
+                details: {
+                    name: item.name,
+                    title: prettyTitle,
+                    fromVersion,
+                    toVersion: newDetails.version,
+                },
+            };
         }
         catch (error) {
-            stderr.write(ansis.red(`    Error updating ${plugin.name}: ${error}\n`));
-            return false;
+            stderr.write(ansis.red(`    Error updating ${item.name}: ${error}\n`));
+            return { updated: false };
+        }
+    }
+    async createBranch() {
+        const { config } = this;
+        const isoDate = new Date().toISOString().replace(/[:.]/g, '-').replace(/T/, '_').slice(0, -5);
+        const branchName = `joltWpUpdate/${isoDate}`;
+        const gitCommand = await config.command('git');
+        await execC(gitCommand, ['checkout', '-b', branchName]);
+        return branchName;
+    }
+    async ensureBranchCreated(_wpConfig, branchRef) {
+        if (!branchRef.created) {
+            branchRef.branch = await this.createBranch();
+            branchRef.created = true;
+            const { context: { stdout }, } = this;
+            stdout.write(ansis.green(`📋 Created update branch ${branchRef.branch}\n`));
         }
+        return branchRef.branch;
     }
-    async updateTheme(theme, wpConfig, branchRef) {
-        const { config, context, context: { stdout, stderr }, } = this;
+    async disableGitHooks() {
+        const { config, context, context: { stderr }, } = this;
+        const gitCommand = await config.command('git');
         try {
-            const gitCommand = await config.command('git');
-            const details = await this.getThemeDetails(theme.name);
-            if (!details) {
-                return false;
-            }
-            const fromVersion = details.version;
-            const prettyTitle = this.cleanTitle(details.title);
-            const location = `${wpConfig.themeFolder}/${theme.name}`;
-            const yarnCommand = await config.command('yarn');
-            const updateResult = await execC(yarnCommand, ['jolt', 'wp', 'cli', 'theme', 'update', theme.name], {
-                reject: false,
-            });
-            const updateResultStr = updateResult.exitCode === 0 ? String(updateResult.stdout || '') : null;
-            if (!updateResultStr) {
-                stderr.write(ansis.red(`    Error updating ${theme.name}\n`));
-                return false;
-            }
-            const newDetails = await this.getThemeDetails(theme.name);
-            if (!newDetails || newDetails.version === details.version) {
-                stderr.write(ansis.red('    Update failed!\n'));
-                return false;
-            }
-            // Ensure branch is created before making our first commit
-            await this.ensureBranchCreated(wpConfig, branchRef);
-            const commitMessage = this.sanitizeCommitMessage(`Update theme ${prettyTitle} to ${newDetails.version}`);
-            await execC(gitCommand, ['add', location], { context });
-            await execC(gitCommand, ['commit', '-m', commitMessage], {
-                context,
-                shell: false,
-                env: { SKIP: 'prepare-commit-msg' },
-            });
-            stdout.write(ansis.green(`    Updated theme ${prettyTitle} from ${fromVersion} to ${newDetails.version}\n`));
-            return true;
+            const result = await execC(gitCommand, ['config', '--get', 'core.hooksPath'], { stderr, reject: false });
+            const originalHookPath = String(result.stdout || '').trim();
+            await execC(gitCommand, ['config', 'core.hooksPath', '/dev/null'], { context });
+            return originalHookPath;
         }
-        catch (error) {
-            stderr.write(ansis.red(`    Error updating ${theme.name}: ${error}\n`));
-            return false;
+        catch (_a) {
+            await execC(gitCommand, ['config', 'core.hooksPath', '/dev/null'], { context });
+            return '';
         }
     }
-    async getPluginDetails(pluginName) {
-        return await this.getDetails(pluginName, 'plugin');
-    }
-    async getThemeDetails(themeName) {
-        return await this.getDetails(themeName, 'theme');
+    async rollbackGitHooks(originalHookPath) {
+        const { config, context } = this;
+        const gitCommand = await config.command('git');
+        if (originalHookPath) {
+            await execC(gitCommand, ['config', 'core.hooksPath', originalHookPath], { context });
+        }
+        else {
+            await execC(gitCommand, ['config', '--unset', 'core.hooksPath'], { context, reject: false });
+        }
     }
     async getDetails(name, type) {
-        const { config } = this;
-        const cmdType = type === 'plugin' ? 'plugin' : 'theme';
         try {
-            const yarnCommand = await config.command('yarn');
-            const detailsResult = await execC(yarnCommand, ['jolt', 'wp', 'cli', cmdType, 'get', '--json', name], {
-                reject: false,
-            });
-            const out = detailsResult.exitCode === 0 ? String(detailsResult.stdout || '') : null;
-            if (!out) {
+            const result = await this.executeWpCli([type, 'get', '--json', name], { silent: true });
+            if (!result.stdout) {
                 return null;
             }
-            let output = String(out || '');
+            let output = result.stdout;
             if (output.startsWith('$')) {
                 // Older Yarn versions include the script name in stdout so we need to trim the first line off
                 output = output.substring(1 + output.indexOf('\n'));
@@ -449,8 +479,10 @@ export class WPUpdateCommand extends JoltCommand {
         const newVersion = await this.hasCoreUpdate();
         if (!newVersion) {
             stdout.write(ansis.dim('  WordPress core is up to date\n'));
-            return false;
+            return { updated: false };
         }
+        // Get current version before updating
+        const currentVersion = await this.getCurrentCoreVersion();
         stdout.write(ansis.green(`  Updating WordPress core to ${newVersion}\n`));
         const shouldStash = await this.hasGitChanges(wpConfig.wpRoot);
         if (shouldStash) {
@@ -460,7 +492,13 @@ export class WPUpdateCommand extends JoltCommand {
         try {
             await this.doCoreUpdate(wpConfig.wpRoot, newVersion, wpConfig, branchRef);
             stdout.write(ansis.green(`    Updated WordPress core to ${newVersion}\n`));
-            return true;
+            return {
+                updated: true,
+                details: {
+                    fromVersion: currentVersion || 'unknown',
+                    toVersion: newVersion,
+                },
+            };
         }
         finally {
             if (shouldStash) {
@@ -469,22 +507,23 @@ export class WPUpdateCommand extends JoltCommand {
             }
         }
     }
+    async getCurrentCoreVersion() {
+        try {
+            const result = await this.executeWpCli(['core', 'version'], { silent: true });
+            return result.stdout ? result.stdout.trim() : null;
+        }
+        catch (_a) {
+            return null;
+        }
+    }
     async hasCoreUpdate() {
         var _a;
-        const { config } = this;
         try {
-            const yarnCommand = await config.command('yarn');
-            const coreResult = await execC(yarnCommand, ['jolt', 'wp', 'cli', 'core', 'check-update', '--json'], {
-                reject: false,
-            });
-            if (!coreResult || coreResult.exitCode !== 0) {
-                return false;
-            }
-            const stdoutStr = String(coreResult.stdout || '');
-            if (!stdoutStr.trim() || stdoutStr.trim() === '[]') {
+            const result = await this.executeWpCli(['core', 'check-update', '--json'], { silent: true });
+            if (!result.stdout || !result.stdout.trim() || result.stdout.trim() === '[]') {
                 return false;
             }
-            const trimmed = stdoutStr.substring(stdoutStr.indexOf('[{'));
+            const trimmed = result.stdout.substring(result.stdout.indexOf('[{'));
             const parsed = JSON.parse(trimmed);
             return ((_a = parsed[0]) === null || _a === void 0 ? void 0 : _a.version) || false;
         }
@@ -493,11 +532,10 @@ export class WPUpdateCommand extends JoltCommand {
         }
     }
     async hasGitChanges(path) {
-        const { config, context } = this;
+        const { config } = this;
         try {
             const gitCommand = await config.command('git');
             const result = await execC(gitCommand, ['status', '--porcelain=v1', '--', path], {
-                context,
                 reject: false,
             });
             return String(result.stdout || '').trim() !== '';
@@ -507,36 +545,124 @@ export class WPUpdateCommand extends JoltCommand {
         }
     }
     async stashChanges() {
-        const { config, context } = this;
+        const { config } = this;
         const date = new Date().toISOString();
         const gitCommand = await config.command('git');
-        await execC(gitCommand, ['add', '.'], { context });
+        await execC(gitCommand, ['add', '.']);
         await execC(gitCommand, ['stash', 'save', '--', `Automated stash by Jolt WP Updater at ${date}`], {
-            context,
             shell: false,
         });
     }
     async unstashChanges() {
-        const { config, context } = this;
+        const { config } = this;
         const gitCommand = await config.command('git');
-        await execC(gitCommand, ['stash', 'pop'], { context });
-        await execC(gitCommand, ['reset', 'HEAD', '--'], { context });
+        await execC(gitCommand, ['stash', 'pop']);
+        await execC(gitCommand, ['reset', 'HEAD', '--']);
     }
     async doCoreUpdate(path, version, wpConfig, branchRef) {
-        const { config, context } = this;
+        const { config } = this;
         // Ensure branch is created before making our first commit
         await this.ensureBranchCreated(wpConfig, branchRef);
         const gitCommand = await config.command('git');
-        const yarnCommand = await config.command('yarn');
-        await execC(yarnCommand, ['jolt', 'wp', 'cli', 'core', 'update'], { context, reject: false });
-        await execC(gitCommand, ['add', path], { context });
+        await this.executeWpCli(['core', 'update'], { silent: true });
+        await execC(gitCommand, ['add', path]);
         const commitMessage = this.sanitizeCommitMessage(`Update WordPress to ${version}`);
         await execC(gitCommand, ['commit', '-m', commitMessage], {
-            context,
             shell: false,
             env: { SKIP: 'prepare-commit-msg' },
         });
     }
+    async maybeUpdateTranslations(branchRef) {
+        const { config, context: { stdout, stderr }, } = this;
+        try {
+            let hasUpdates = false;
+            // Helper to check and update translations for a specific type
+            const updateTranslationType = async (type, command) => {
+                stdout.write(`  Checking ${type} translations...`);
+                const result = await this.executeWpCli(command, { silent: true });
+                if (result.exitCode === 0 && result.stdout) {
+                    if (result.stdout.includes('Updated') || result.stdout.includes('updated')) {
+                        hasUpdates = true;
+                        stdout.write(ansis.green(' updated\n'));
+                    }
+                    else {
+                        stdout.write(ansis.dim(' up to date\n'));
+                    }
+                }
+                else {
+                    stdout.write(ansis.dim(' skipped (not available)\n'));
+                }
+            };
+            // Update different translation types
+            await updateTranslationType('core', ['language', 'core', 'update']);
+            await updateTranslationType('plugin', ['language', 'plugin', 'update', '--all']);
+            await updateTranslationType('theme', ['language', 'theme', 'update', '--all']);
+            // If we have translation updates, commit them
+            if (hasUpdates) {
+                const wpConfig = await config.loadWordPressConfig();
+                if (!wpConfig) {
+                    stderr.write(ansis.red('Failed to load WordPress configuration\n'));
+                    return false;
+                }
+                // Create or ensure we're on the update branch
+                await this.ensureBranchCreated(wpConfig, branchRef);
+                const gitCommand = await config.command('git');
+                // Add all language files that might have been updated
+                await execC(gitCommand, ['add', wpConfig.wpRoot]);
+                // Check if there are any changes to commit
+                const statusResult = await execC(gitCommand, ['diff', '--cached', '--exit-code'], {
+                    reject: false,
+                });
+                if (statusResult.exitCode !== 0) {
+                    // There are changes to commit
+                    await execC(gitCommand, ['commit', '-m', 'Update translations'], {
+                        shell: false,
+                        env: { SKIP: 'prepare-commit-msg' },
+                    });
+                    stdout.write(ansis.green('    Committed translation updates\n'));
+                    return true;
+                }
+                stdout.write(ansis.dim('    No translation files changed\n'));
+            }
+            return false;
+        }
+        catch (error) {
+            stderr.write(ansis.red(`Error updating translations: ${error}\n`));
+            return false;
+        }
+    }
+    /**
+     * Update Redis drop-in from plugin files if WP-CLI fails
+     */
+    async updateRedisDropinFromPlugin(item, wpConfig, itemConfig) {
+        const pluginBase = path.join(itemConfig.getFolder(wpConfig), item.name);
+        const candidatePaths = [
+            path.join(pluginBase, 'object-cache.php'),
+            path.join(pluginBase, 'includes', 'object-cache.php'),
+            path.join(pluginBase, 'drop-in', 'object-cache.php'),
+        ];
+        const wpContentDir = path.join(wpConfig.wpRoot, 'wp-content');
+        const dropinDestLocal = path.join(wpContentDir, 'object-cache.php');
+        const { config } = this;
+        for (const candidate of candidatePaths) {
+            if (!(await fileExists(candidate))) {
+                continue;
+            }
+            try {
+                const contents = String(await fs.readFile(candidate));
+                if (!/Redis Object Cache|Redis\b/i.test(contents)) {
+                    break;
+                }
+                await fs.copyFile(candidate, dropinDestLocal);
+                const gitCommand = await config.command('git');
+                await execC(gitCommand, ['add', dropinDestLocal]);
+                break;
+            }
+            catch (_a) {
+                break;
+            }
+        }
+    }
 }
 WPUpdateCommand.paths = [['wp', 'update']];
 export class WPUpdateMergeCommand extends JoltCommand {
@@ -720,6 +846,9 @@ export class WPUpdateModifyCommand extends JoltCommand {
     constructor() {
         super(...arguments);
         this.requiredCommands = ['git'];
+        this.autostash = Option.Boolean('--autostash', false, {
+            description: 'Automatically stash and unstash changes before and after the rebase',
+        });
     }
     async command() {
         const { config, context, context: { stdout, stderr }, logo, } = this;
@@ -732,7 +861,7 @@ export class WPUpdateModifyCommand extends JoltCommand {
         try {
             const gitCommand = await config.command('git');
             // Get current branch
-            const currentBranchResult = await execC(gitCommand, ['branch', '--show-current'], { context });
+            const currentBranchResult = await execC(gitCommand, ['branch', '--show-current']);
             const currentBranch = String(currentBranchResult.stdout || '').trim();
             if (!currentBranch.startsWith('joltWpUpdate/')) {
                 stderr.write(ansis.red('Not currently on a WordPress update branch\n'));
@@ -741,7 +870,6 @@ export class WPUpdateModifyCommand extends JoltCommand {
             // Count commits since branching from main
             const branchName = (await config.get('branch')) || 'master';
             const commitCountResult = await execC(gitCommand, ['rev-list', '--count', `${branchName}..HEAD`], {
-                context,
                 reject: false,
             });
             if (commitCountResult.exitCode !== 0) {
@@ -755,7 +883,11 @@ export class WPUpdateModifyCommand extends JoltCommand {
             }
             stdout.write(ansis.cyan(`📋 Starting interactive rebase for ${commitCount} commits...\n`));
             // Run interactive rebase
-            const rebaseResult = await execC(gitCommand, ['rebase', '-i', `HEAD~${commitCount}`], {
+            const rebaseArgs = ['rebase', '-i', `HEAD~${commitCount}`];
+            if (this.autostash) {
+                rebaseArgs.push('--autostash');
+            }
+            const rebaseResult = await execC(gitCommand, rebaseArgs, {
                 context,
                 reject: false,
             });