wordpress-agent-kit 0.2.1 → 0.3.0

package/dist/lib/api.js

@@ -0,0 +1,511 @@
+/**
+ * Programmatic API for WordPress Agent Kit.
+ * Can be imported directly by agents/scripts: `import { installKit } from 'wordpress-agent-kit/api'`
+ */
+import { spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import { ExitCode, withExitCode } from '../utils/exit-codes.js';
+import { OutputFormatter } from '../utils/output.js';
+import { PACKAGE_ROOT } from '../utils/paths.js';
+import { installKit } from './installer.js';
+import { computeChanges, isKitInstalled } from './updater.js';
+/**
+ * Install the WordPress Agent Kit programmatically.
+ */
+export async function installKitApi(options) {
+    const startTime = Date.now();
+    const formatter = new OutputFormatter('json', 'install', '0.0.0');
+    try {
+        const { targetDir, platform, force = false, dryRun = false, safe = true, backup = true, } = options;
+        if (dryRun) {
+            return dryRunInstall(targetDir, platform, { force, safe, backup });
+        }
+        await withExitCode(async () => {
+            installKit(targetDir, platform, { force, safe, backup });
+            return { success: true };
+        });
+        const filesCreated = getInstalledFiles(targetDir, platform);
+        const durationMs = Date.now() - startTime;
+        return formatter.success({
+            targetDir,
+            platform,
+            filesCreated,
+            filesSkipped: [],
+            errors: [],
+            durationMs,
+            isUpdate: isKitInstalled(targetDir, platform),
+            backupDir: null,
+        });
+    }
+    catch (error) {
+        const err = error;
+        return formatter.fail({
+            code: err.code || 'INSTALL_FAILED',
+            message: err.message || 'Installation failed',
+            exitCode: err.exitCode ?? ExitCode.ERROR,
+            details: { platform: options.platform, targetDir: options.targetDir },
+        });
+    }
+}
+/**
+ * Dry-run preview for install.
+ */
+function dryRunInstall(targetDir, platform, options) {
+    const { force = false, safe = true } = options;
+    const platformFolder = getPlatformFolder(platform);
+    const formatter = new OutputFormatter('json', 'install', '0.0.0');
+    // Use change-computation for safe updates on existing installations
+    if (safe && isKitInstalled(targetDir, platform)) {
+        const changes = computeChanges(targetDir, platform, force);
+        const actions = changes.map((c) => {
+            const target = path.join(targetDir, platformFolder, c.relativePath);
+            return {
+                type: c.action === 'created' ? 'create' : c.action === 'updated' ? 'update' : 'skip',
+                target,
+                description: `${c.action}: ${c.relativePath}${c.reason ? ` (${c.reason})` : ''}`,
+            };
+        });
+        // AGENTS.md check
+        const targetAgents = path.join(targetDir, 'AGENTS.md');
+        if (!fs.existsSync(targetAgents)) {
+            actions.push({
+                type: 'create',
+                target: targetAgents,
+                description: 'Create AGENTS.md from template',
+            });
+        }
+        else {
+            actions.push({
+                type: 'skip',
+                target: targetAgents,
+                description: 'AGENTS.md exists (preserved)',
+            });
+        }
+        return formatter.success({
+            wouldExecute: true,
+            actions,
+            summary: {
+                targetDir,
+                platform,
+                filesCreated: changes
+                    .filter((c) => c.action === 'created')
+                    .map((c) => path.join(platformFolder, c.relativePath)),
+                filesSkipped: changes
+                    .filter((c) => c.action === 'skipped' || c.action === 'conflict')
+                    .map((c) => `${path.join(platformFolder, c.relativePath)} (${c.reason})`),
+                errors: [],
+                durationMs: 0,
+                isUpdate: true,
+                backupDir: null,
+                conflicts: changes
+                    .filter((c) => c.action === 'conflict')
+                    .map((c) => path.join(platformFolder, c.relativePath)),
+            },
+        });
+    }
+    // Legacy dry-run for fresh installs
+    const actions = [];
+    const sourceGithub = path.join(PACKAGE_ROOT, '.github');
+    const targetPlatform = path.join(targetDir, platformFolder);
+    const templatePath = path.join(PACKAGE_ROOT, 'AGENTS.template.md');
+    const targetAgentsTemplate = path.join(targetDir, 'AGENTS.template.md');
+    const targetAgents = path.join(targetDir, 'AGENTS.md');
+    if (fs.existsSync(sourceGithub)) {
+        if (fs.existsSync(targetPlatform) && !force) {
+            actions.push({
+                type: 'update',
+                target: targetPlatform,
+                description: `Would update ${platformFolder} (use --force to overwrite)`,
+            });
+        }
+        else {
+            actions.push({
+                type: 'copy',
+                source: sourceGithub,
+                target: targetPlatform,
+                description: `Copy ${platformFolder} from kit`,
+            });
+        }
+    }
+    if (fs.existsSync(templatePath)) {
+        actions.push({
+            type: 'copy',
+            source: templatePath,
+            target: targetAgentsTemplate,
+            description: 'Copy AGENTS.template.md',
+        });
+    }
+    if (!fs.existsSync(targetAgents) || force) {
+        if (fs.existsSync(templatePath)) {
+            actions.push({
+                type: 'copy',
+                source: templatePath,
+                target: targetAgents,
+                description: 'Create AGENTS.md from template',
+            });
+        }
+    }
+    else {
+        actions.push({
+            type: 'update',
+            target: targetAgents,
+            description: 'AGENTS.md exists (use --force to overwrite)',
+        });
+    }
+    return formatter.success({
+        wouldExecute: true,
+        actions,
+        summary: {
+            targetDir,
+            platform,
+            filesCreated: actions.filter((a) => a.type === 'copy').map((a) => a.target),
+            filesSkipped: actions.filter((a) => a.type === 'update').map((a) => a.target),
+            errors: [],
+            durationMs: 0,
+            isUpdate: false,
+            backupDir: null,
+        },
+    });
+}
+/**
+ * Sync skills from WordPress/agent-skills programmatically.
+ */
+export async function syncSkillsApi(options = {}) {
+    const startTime = Date.now();
+    const formatter = new OutputFormatter('json', 'sync-skills', '0.0.0');
+    const targetDir = options.targetDir || process.cwd();
+    const ref = options.ref || 'trunk';
+    if (options.dryRun) {
+        return dryRunSyncSkills(targetDir, ref);
+    }
+    try {
+        const result = await withExitCode(async () => {
+            const repoRoot = targetDir;
+            const submodulePath = path.join('vendor', 'wp-agent-skills');
+            const vendorSkillsDir = path.join(repoRoot, submodulePath);
+            const submoduleGitDir = path.join(vendorSkillsDir, '.git');
+            // Clone or update
+            if (!fs.existsSync(submoduleGitDir)) {
+                fs.mkdirSync(path.join(repoRoot, 'vendor'), { recursive: true });
+                const cloneResult = spawnSync('git', ['clone', 'https://github.com/WordPress/agent-skills.git', submodulePath], {
+                    cwd: repoRoot,
+                    encoding: 'utf-8',
+                });
+                if (cloneResult.status !== 0) {
+                    throw new Error(`Git clone failed: ${cloneResult.stderr?.toString()}`);
+                }
+            }
+            else {
+                const fetchResult = spawnSync('git', ['fetch', '--all', '--tags'], {
+                    cwd: vendorSkillsDir,
+                    encoding: 'utf-8',
+                });
+                if (fetchResult.status !== 0) {
+                    throw new Error(`Git fetch failed: ${fetchResult.stderr?.toString()}`);
+                }
+            }
+            // Checkout ref
+            const checkoutResult = spawnSync('git', ['checkout', ref], {
+                cwd: vendorSkillsDir,
+                encoding: 'utf-8',
+            });
+            if (checkoutResult.status !== 0) {
+                throw new Error(`Git checkout failed: ${checkoutResult.stderr?.toString()}`);
+            }
+            const pullResult = spawnSync('git', ['pull', 'origin', ref], {
+                cwd: vendorSkillsDir,
+                encoding: 'utf-8',
+            });
+            if (pullResult.status !== 0) {
+                throw new Error(`Git pull failed: ${pullResult.stderr?.toString()}`);
+            }
+            const targetSkills = path.join(repoRoot, '.github', 'skills');
+            const upstreamBuildScript = path.join(vendorSkillsDir, 'shared', 'scripts', 'skillpack-build.mjs');
+            const upstreamInstallScript = path.join(vendorSkillsDir, 'shared', 'scripts', 'skillpack-install.mjs');
+            let method = 'direct-copy';
+            let skillsSynced = 0;
+            if (fs.existsSync(upstreamBuildScript) && fs.existsSync(upstreamInstallScript)) {
+                if (fs.existsSync(targetSkills)) {
+                    fs.rmSync(targetSkills, { recursive: true, force: true });
+                }
+                fs.mkdirSync(path.join(repoRoot, '.github'), { recursive: true });
+                const buildResult = spawnSync('node', ['shared/scripts/skillpack-build.mjs', '--clean', '--targets=vscode'], {
+                    cwd: vendorSkillsDir,
+                    encoding: 'utf-8',
+                });
+                if (buildResult.status !== 0) {
+                    throw new Error(`Skillpack build failed: ${buildResult.stderr?.toString()}`);
+                }
+                const installResult = spawnSync('node', [
+                    'shared/scripts/skillpack-install.mjs',
+                    `--dest=${repoRoot}`,
+                    '--targets=vscode',
+                    '--from=dist',
+                    '--mode=replace',
+                ], { cwd: vendorSkillsDir, encoding: 'utf-8' });
+                if (installResult.status !== 0) {
+                    throw new Error(`Skillpack install failed: ${installResult.stderr?.toString()}`);
+                }
+                method = 'skillpack';
+                if (fs.existsSync(targetSkills)) {
+                    skillsSynced = fs.readdirSync(targetSkills).length;
+                }
+            }
+            else {
+                const sourceSkills = path.join(vendorSkillsDir, '.github', 'skills');
+                if (!fs.existsSync(sourceSkills)) {
+                    throw new Error(`Upstream skills not found at ${sourceSkills}`);
+                }
+                if (fs.existsSync(targetSkills)) {
+                    fs.rmSync(targetSkills, { recursive: true, force: true });
+                }
+                fs.mkdirSync(path.join(repoRoot, '.github'), { recursive: true });
+                fs.cpSync(sourceSkills, targetSkills, { recursive: true });
+                skillsSynced = fs.readdirSync(targetSkills).length;
+            }
+            return { success: true, skillsSynced, method };
+        });
+        return formatter.success({
+            targetDir,
+            skillsSynced: result.skillsSynced,
+            sourceUrl: 'https://github.com/WordPress/agent-skills.git',
+            ref,
+            durationMs: Date.now() - startTime,
+            method: result.method,
+        });
+    }
+    catch (error) {
+        const err = error;
+        return formatter.fail({
+            code: err.code || 'SYNC_FAILED',
+            message: err.message || 'Sync failed',
+            exitCode: err.exitCode ?? ExitCode.ERROR,
+            details: { ref, targetDir },
+        });
+    }
+}
+/**
+ * Dry-run preview for sync-skills.
+ */
+function dryRunSyncSkills(targetDir, ref) {
+    const actions = [];
+    const targetSkills = path.join(targetDir, '.github', 'skills');
+    const vendorDir = path.join(targetDir, 'vendor', 'wp-agent-skills');
+    actions.push({
+        type: 'mkdir',
+        target: path.join(targetDir, 'vendor'),
+        description: 'Create vendor directory',
+    });
+    if (!fs.existsSync(vendorDir)) {
+        actions.push({
+            type: 'create',
+            target: vendorDir,
+            description: 'Clone WordPress/agent-skills repository',
+        });
+    }
+    else {
+        actions.push({
+            type: 'update',
+            target: vendorDir,
+            description: `Fetch and checkout ${ref}`,
+        });
+    }
+    if (fs.existsSync(targetSkills)) {
+        actions.push({
+            type: 'delete',
+            target: targetSkills,
+            description: 'Remove existing skills directory',
+        });
+    }
+    actions.push({
+        type: 'create',
+        target: targetSkills,
+        description: 'Install synced skills',
+    });
+    return new OutputFormatter('json', 'sync-skills', '0.0.0').success({
+        wouldExecute: true,
+        actions,
+        summary: {
+            targetDir,
+            skillsSynced: 0,
+            sourceUrl: 'https://github.com/WordPress/agent-skills.git',
+            ref,
+            durationMs: 0,
+            method: 'skillpack',
+        },
+    });
+}
+/**
+ * Run project triage detection programmatically.
+ */
+export async function runTriageApi(options) {
+    const formatter = new OutputFormatter('json', 'triage', '0.0.0');
+    const { targetDir, platform = 'github' } = options;
+    try {
+        const platformFolder = getPlatformFolder(platform);
+        const triageScriptPaths = [
+            path.join(targetDir, platformFolder, 'skills/wp-project-triage/scripts/detect_wp_project.mjs'),
+            path.join(PACKAGE_ROOT, 'vendor/wp-agent-skills/skills/wp-project-triage/scripts/detect_wp_project.mjs'),
+        ];
+        const triageScriptPath = triageScriptPaths.find((p) => fs.existsSync(p));
+        if (!triageScriptPath) {
+            return formatter.fail({
+                code: 'TRIAGE_NOT_FOUND',
+                message: 'Project triage script not found. Run sync-skills first.',
+                exitCode: ExitCode.NOT_FOUND,
+            });
+        }
+        const result = spawnSync('node', [triageScriptPath], {
+            cwd: targetDir,
+            encoding: 'utf-8',
+        });
+        if (result.status !== 0) {
+            return formatter.fail({
+                code: 'TRIAGE_FAILED',
+                message: result.stderr?.toString() || 'Triage script failed',
+                exitCode: ExitCode.ERROR,
+            });
+        }
+        const triageResult = JSON.parse(result.stdout.trim());
+        return formatter.success(triageResult);
+    }
+    catch (error) {
+        const err = error;
+        return formatter.fail({
+            code: 'TRIAGE_ERROR',
+            message: err.message || 'Triage failed',
+            exitCode: ExitCode.ERROR,
+        });
+    }
+}
+/**
+ * Configure AGENTS.md with project details programmatically.
+ */
+export async function configureAgentsMdApi(options) {
+    const formatter = new OutputFormatter('json', 'configure', '0.0.0');
+    const { targetDir, platform, config, dryRun = false } = options;
+    try {
+        const platformFolder = getPlatformFolder(platform);
+        const agentsPath = path.join(targetDir, 'AGENTS.md');
+        const platformInstructionsPath = path.join(targetDir, platformFolder, 'instructions', 'wordpress-workflow.instructions.md');
+        if (dryRun) {
+            const actions = [];
+            if (fs.existsSync(agentsPath)) {
+                actions.push({
+                    type: 'update',
+                    target: agentsPath,
+                    description: `Update AGENTS.md with project type: ${config.projectType}, tech: ${config.techStack.join(', ')}`,
+                });
+            }
+            else {
+                actions.push({
+                    type: 'create',
+                    target: agentsPath,
+                    description: 'Create AGENTS.md with project configuration',
+                });
+            }
+            if (fs.existsSync(platformInstructionsPath)) {
+                actions.push({
+                    type: 'update',
+                    target: platformInstructionsPath,
+                    description: 'Workflow instructions available for customization',
+                });
+            }
+            return formatter.success({
+                wouldExecute: true,
+                actions,
+                summary: {
+                    targetDir,
+                    modified: [agentsPath],
+                    skipped: [],
+                    dryRun: true,
+                },
+            });
+        }
+        const modified = [];
+        const skipped = [];
+        // Update AGENTS.md
+        if (fs.existsSync(agentsPath)) {
+            let agentsContent = fs.readFileSync(agentsPath, 'utf-8');
+            const pm = config.packageManager || 'npm/pnpm';
+            agentsContent = agentsContent.replace(/\*\*Tooling\*\*: .*/, `**Tooling**: ${config.techStack.includes('composer') ? 'Composer for PHP' : ''}${config.techStack.includes('npm') ? `, ${pm} for JS` : ''}.`);
+            fs.writeFileSync(agentsPath, agentsContent, 'utf-8');
+            modified.push(agentsPath);
+        }
+        else {
+            skipped.push(agentsPath);
+        }
+        // Note workflow instructions
+        if (fs.existsSync(platformInstructionsPath)) {
+            modified.push(platformInstructionsPath);
+        }
+        else {
+            skipped.push(platformInstructionsPath);
+        }
+        return formatter.success({
+            targetDir,
+            modified,
+            skipped,
+            dryRun: false,
+        });
+    }
+    catch (error) {
+        const err = error;
+        return formatter.fail({
+            code: 'CONFIGURE_FAILED',
+            message: err.message || 'Configuration failed',
+            exitCode: ExitCode.ERROR,
+        });
+    }
+}
+/**
+ * Get platform folder name.
+ */
+function getPlatformFolder(platform) {
+    const folders = {
+        github: '.github',
+        cursor: '.cursor',
+        claude: '.claude',
+        agent: '.agent',
+        pi: '.pi/agent',
+    };
+    return folders[platform];
+}
+/**
+ * Get list of files that would be/are installed.
+ */
+function getInstalledFiles(targetDir, platform) {
+    const platformFolder = getPlatformFolder(platform);
+    const files = [];
+    const targetPlatform = path.join(targetDir, platformFolder);
+    if (fs.existsSync(targetPlatform)) {
+        function walk(dir, prefix = '') {
+            const entries = fs.readdirSync(dir);
+            for (const entry of entries) {
+                const fullPath = path.join(dir, entry);
+                const relPath = path.join(prefix, entry);
+                const stat = fs.statSync(fullPath);
+                if (stat.isDirectory()) {
+                    walk(fullPath, relPath);
+                }
+                else {
+                    files.push(path.join(platformFolder, relPath));
+                }
+            }
+        }
+        walk(targetPlatform);
+    }
+    const agentsPath = path.join(targetDir, 'AGENTS.md');
+    if (fs.existsSync(agentsPath)) {
+        files.push('AGENTS.md');
+    }
+    const agentsTemplatePath = path.join(targetDir, 'AGENTS.template.md');
+    if (fs.existsSync(agentsTemplatePath)) {
+        files.push('AGENTS.template.md');
+    }
+    return files;
+}
+export { ExitCode } from '../utils/exit-codes.js';
+export { OutputFormatter, createFormatter, parseOutputFormat } from '../utils/output.js';
+export { computeChanges, isKitInstalled, loadManifest, updateKit } from './updater.js';

package/dist/lib/installer.js

@@ -1,6 +1,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { PACKAGE_ROOT } from '../utils/paths.js';
+import { updateKit } from './updater.js';
 /**
  * Platform-specific folder names
  */
@@ -13,13 +14,36 @@ export const PLATFORM_FOLDERS = {
 };
 /**
  * Installs the WordPress Agent Kit into the specified directory for a given platform.
- * Copies the platform-specific folder and AGENTS.md template.
+ * If the kit is already installed, uses safe update logic to preserve user modifications.
  *
- * @param {string} targetDir - The directory where the kit should be installed.
- * @param {Platform} platform - The target platform (github, cursor, claude, agent)
- * @returns {Promise<void>}
+ * @param targetDir - The directory where the kit should be installed.
+ * @param platform - The target platform (github, cursor, claude, agent, pi)
+ * @returns InstallKitResult with details of what was created/skipped
  */
-export async function installKit(targetDir, platform = 'github') {
+export function installKit(targetDir, platform = 'github', options = {}) {
+    const { force = false, backup = true, safe = true } = options;
+    // Check if kit is already installed
+    const isInstalled = isKitAlreadyInstalled(targetDir, platform);
+    // Use safe update for existing installations
+    if (isInstalled && safe) {
+        return safeUpdateInstall(targetDir, platform, { force, backup });
+    }
+    // Fresh install or fallback to full replacement
+    return fullInstall(targetDir, platform, force);
+}
+/**
+ * Check if kit is already installed for a platform.
+ */
+function isKitAlreadyInstalled(targetDir, platform) {
+    const platformFolder = PLATFORM_FOLDERS[platform];
+    const targetPlatform = path.join(targetDir, platformFolder);
+    return fs.existsSync(targetPlatform);
+}
+/**
+ * Full install (fresh or force-replace).
+ * Only used when no existing installation is detected or safe=false.
+ */
+function fullInstall(targetDir, platform, _force) {
     const platformFolder = PLATFORM_FOLDERS[platform];
     console.log(`Installing WordPress Agent Kit (${platform}) into: ${targetDir}`);
     if (!fs.existsSync(targetDir)) {
@@ -28,6 +52,8 @@ export async function installKit(targetDir, platform = 'github') {
     const templatePath = path.join(PACKAGE_ROOT, 'AGENTS.template.md');
     const agentsPath = path.join(PACKAGE_ROOT, 'AGENTS.md');
     const sourceGithub = path.join(PACKAGE_ROOT, '.github');
+    const filesCreated = [];
+    const filesSkipped = [];
     // Copy platform-specific folder
     const targetPlatform = path.join(targetDir, platformFolder);
     if (fs.existsSync(targetPlatform)) {
@@ -39,18 +65,100 @@ export async function installKit(targetDir, platform = 'github') {
     else {
         throw new Error('Could not find source .github directory.');
     }
-    // Copy AGENTS.md
+    // Collect created files
+    const collectFiles = (dir, prefix) => {
+        if (!fs.existsSync(dir))
+            return;
+        const entries = fs.readdirSync(dir);
+        for (const entry of entries) {
+            const fullPath = path.join(dir, entry);
+            const stat = fs.statSync(fullPath);
+            if (stat.isDirectory()) {
+                collectFiles(fullPath, path.join(prefix, entry));
+            }
+            else {
+                filesCreated.push(path.join(prefix, entry));
+            }
+        }
+    };
+    collectFiles(targetPlatform, platformFolder);
+    // Copy AGENTS.md template
     const targetAgentsTemplate = path.join(targetDir, 'AGENTS.template.md');
     if (fs.existsSync(templatePath)) {
         fs.copyFileSync(templatePath, targetAgentsTemplate);
+        filesCreated.push('AGENTS.template.md');
     }
+    // Copy AGENTS.md (only if it doesn't already exist)
     const targetAgents = path.join(targetDir, 'AGENTS.md');
     if (!fs.existsSync(targetAgents)) {
         if (fs.existsSync(templatePath)) {
             fs.copyFileSync(templatePath, targetAgents);
+            filesCreated.push('AGENTS.md');
         }
         else if (fs.existsSync(agentsPath)) {
             fs.copyFileSync(agentsPath, targetAgents);
+            filesCreated.push('AGENTS.md');
         }
     }
+    else {
+        filesSkipped.push('AGENTS.md (already exists, preserved)');
+    }
+    return {
+        targetDir,
+        platform,
+        filesCreated,
+        filesSkipped,
+        errors: [],
+        isUpdate: false,
+        backupDir: null,
+    };
+}
+/**
+ * Safe update install using the updater module.
+ */
+function safeUpdateInstall(targetDir, platform, options) {
+    console.log(`Updating WordPress Agent Kit (${platform}) in: ${targetDir}`);
+    const updateOptions = {
+        targetDir,
+        platform,
+        force: options.force ?? false,
+        backup: options.backup ?? true,
+    };
+    const result = updateKit(updateOptions);
+    // Handle AGENTS.md separately (not part of the platform folder)
+    const filesSkipped = [];
+    const filesCreated = [...result.created];
+    const templatePath = path.join(PACKAGE_ROOT, 'AGENTS.template.md');
+    const targetAgentsTemplate = path.join(targetDir, 'AGENTS.template.md');
+    if (fs.existsSync(templatePath)) {
+        fs.copyFileSync(templatePath, targetAgentsTemplate);
+        // Don't add template to created list as it's always overwritten
+    }
+    const targetAgents = path.join(targetDir, 'AGENTS.md');
+    if (!fs.existsSync(targetAgents)) {
+        fs.copyFileSync(templatePath, targetAgents);
+        filesCreated.push('AGENTS.md (from template)');
+    }
+    else {
+        filesSkipped.push('AGENTS.md (preserved)');
+    }
+    return {
+        targetDir,
+        platform,
+        filesCreated: [...result.created, ...result.updated].map((f) => path.join(PLATFORM_FOLDERS[platform], f)),
+        filesSkipped: [
+            ...filesSkipped,
+            ...result.skipped.map((f) => {
+                const filePath = path.join(PLATFORM_FOLDERS[platform], f);
+                return `${filePath} (skipped - not tracked or user modified)`;
+            }),
+        ],
+        conflicts: result.conflicts.map((f) => {
+            const filePath = path.join(PLATFORM_FOLDERS[platform], f);
+            return `${filePath} (conflict - user modified, use --force to overwrite)`;
+        }),
+        errors: [],
+        isUpdate: true,
+        backupDir: result.backupDir,
+    };
 }