@loopress/cli 0.23.0 → 0.24.0

package/dist/commands/option/list.js

@@ -0,0 +1,151 @@
+import { Flags, ux } from '@oclif/core';
+import ttyTable from 'tty-table';
+import { LoopressCommand } from '../../lib/base.js';
+import { OPTIONS_ENDPOINT } from '../../utils/option-format.js';
+import { pluralize } from '../../utils/pluralize.js';
+// Same green/yellow pairing drives both SOURCE? and PLUGIN, so a row's whole "where did this come
+// from" story reads as one color at a glance instead of requiring the "?" to be spotted in text.
+function confidenceColor(option) {
+    if (!option.guess)
+        return undefined;
+    return option.confirmed ? 'green' : 'yellow';
+}
+function colorize(color, text) {
+    return color ? ux.colorize(color, text) : text;
+}
+// SOURCE? is a best-effort guess, kept visually uncertain with a trailing "?" unless `confirmed`
+// (the guessed plugin's own source was found to reference the name), which drops the "?".
+function sourceCell(option) {
+    if (!option.guess)
+        return '';
+    return colorize(confidenceColor(option), option.confirmed ? option.guess : `${option.guess}?`);
+}
+function pluginCell(option) {
+    return option.pluginName ? colorize(confidenceColor(option), option.pluginName) : '';
+}
+function coreCell(option) {
+    return option.core ? ux.colorize('cyan', 'yes') : '';
+}
+// Spells out what the colors mean once, up front, rather than leaving green/yellow (and cyan when
+// CORE is shown) to be decoded from the table alone.
+function renderLegend(includeCore) {
+    const items = [`${ux.colorize('green', '■')} confirmed`, `${ux.colorize('yellow', '■')} guessed, unconfirmed (?)`];
+    if (includeCore)
+        items.push(`${ux.colorize('cyan', '■')} WordPress core`);
+    return items.join(' '.repeat(3));
+}
+// AUTOLOAD/CORE deliberately get no `width` below, leaving them 'auto' (content-sized): tty-table
+// has a real bug in its fixed-width path (confirmed against its own source, format.js's
+// getColumnWidths) where `result = column.width; result = result + config.GUTTER` string-
+// concatenates a width like "11" with the gutter number instead of adding them ("11" + 1 ===
+// "111"), massively overshooting. 'auto' does the arithmetic correctly and is exactly what these
+// two columns need anyway: their own header ("AUTOLOAD"/"CORE") is the longest thing they ever
+// have to display, at 11 and 7 chars respectively (text + 2 padding + 1 gutter).
+const AUTO_COLUMN_CHARS = { autoload: 11, core: 7 };
+// Relative weights, not literal percentages (normalized below): NAME varies most (plugin slugs
+// and cache keys can run long) so it gets the largest share of whatever's left once AUTOLOAD/CORE
+// take their fixed chars.
+const COLUMN_WEIGHT = { name: 40, plugin: 24, source: 28 };
+// Each percentage column also costs 2 chars of padding + 1 gutter beyond its own percentage share
+// (tty-table adds those on top, not out of it); NAME/SOURCE?/PLUGIN are always all three present.
+const PERCENTAGE_COLUMN_OVERHEAD = 3 * 3;
+// Columns stay content-sized by default (tty-table only shrinks to fit, never grows), which left
+// the table narrow with a lot of unused terminal width. Assigning NAME/SOURCE?/PLUGIN an explicit
+// percentage of the terminal forces them to fill it instead. The percentage has to be computed
+// against the actual available width, not a flat constant: a flat "88%" left enough room at a
+// wide terminal but, combined with AUTOLOAD/CORE's own fixed chars and the padding/gutter overhead
+// above, overran an ordinary ~100-column one, and tty-table's shrink-to-fit response shrank
+// AUTOLOAD/CORE below their own header text, truncating "AUTOLOAD" to "AUTOL…" (found testing at
+// exactly that width).
+function fillPercent(width, includeCore) {
+    const reserved = AUTO_COLUMN_CHARS.autoload + (includeCore ? AUTO_COLUMN_CHARS.core : 0) + PERCENTAGE_COLUMN_OVERHEAD + 4; // +4: slim right margin
+    return Math.max(50, ((width - reserved) / width) * 100);
+}
+function columnWidth(weight, width, includeCore) {
+    const total = COLUMN_WEIGHT.name + COLUMN_WEIGHT.source + COLUMN_WEIGHT.plugin;
+    return `${Math.round((weight / total) * fillPercent(width, includeCore))}%`;
+}
+// tty-table sizes columns against process.stdout.columns when present (a real terminal, correctly
+// left alone: a genuinely narrow window should wrap). Piped/redirected output and this process
+// itself (no TTY) has neither that nor $COLUMNS, so the library falls back to a hardcoded 80 and
+// squeezes every cell into broken multi-line wrapping regardless of any width option passed in,
+// confirmed against its own source (getAvailableWidth() in format.js only reads config.width at
+// all when one of the two is set). A generous $COLUMNS makes that fallback path wide instead.
+const NON_TTY_FALLBACK_COLUMNS = 300;
+// Bordered table via tty-table (an oclif-recommended table library, see
+// https://oclif.io/docs/user_experience). CORE is a fact (matched against WordPress's own
+// install-time defaults), hidden entirely under --no-core rather than left as an all-blank
+// column. See confidenceColor() above for SOURCE?/PLUGIN's shared sûr/pas sûr color coding.
+function renderTable(rows, { includeCore }) {
+    const previousColumns = process.env.COLUMNS;
+    if (!process.stdout.columns)
+        process.env.COLUMNS = String(NON_TTY_FALLBACK_COLUMNS);
+    // Mirrors tty-table's own getAvailableWidth(): its column-width percentages are computed against
+    // this same number, so fillPercent() above needs it too to reserve the right amount for AUTOLOAD/CORE.
+    const width = (process.stdout.columns || Number(process.env.COLUMNS) || NON_TTY_FALLBACK_COLUMNS) - 2;
+    const header = [
+        { align: 'left', headerAlign: 'left', value: 'NAME', width: columnWidth(COLUMN_WEIGHT.name, width, includeCore) },
+        { align: 'left', headerAlign: 'left', value: 'AUTOLOAD' },
+    ];
+    if (includeCore)
+        header.push({ align: 'left', headerAlign: 'left', value: 'CORE' });
+    header.push({ align: 'left', headerAlign: 'left', value: 'SOURCE?', width: columnWidth(COLUMN_WEIGHT.source, width, includeCore) }, { align: 'left', headerAlign: 'left', value: 'PLUGIN', width: columnWidth(COLUMN_WEIGHT.plugin, width, includeCore) });
+    const body = rows.map((row) => {
+        const cells = [row.name, row.autoload];
+        if (includeCore)
+            cells.push(coreCell(row));
+        cells.push(sourceCell(row), pluginCell(row));
+        return cells;
+    });
+    try {
+        // truncate (rather than the default wrap) so an oversized cell, like a WPForms cache key
+        // seen live running ~140 chars, ellipsizes on one line instead of blowing up the row height.
+        return ttyTable(header, body, { borderStyle: 'solid', compact: true, truncate: '…' }).render();
+    }
+    finally {
+        if (previousColumns === undefined)
+            delete process.env.COLUMNS;
+        else
+            process.env.COLUMNS = previousColumns;
+    }
+}
+export default class List extends LoopressCommand {
+    static description = 'List WordPress option names currently on the site (names and autoload only, never values). ' +
+        'CORE flags a WordPress-native default (certain); SOURCE? is a best-effort guessed plugin slug, found by name or by ' +
+        'scanning active plugins\' own PHP source (uncertain unless confirmed, occasionally wrong or blank, never trust it over CORE); ' +
+        'PLUGIN is that slug\'s own declared display name, a label only, no confidence of its own. ' +
+        'Use this to find the name of the option you want, then `lps option add <name>` to track it.';
+    static enableJsonFlag = true;
+    static examples = ['$ lps option list', '$ lps option list --no-core'];
+    static flags = {
+        'no-core': Flags.boolean({
+            description: 'Exclude WordPress-native default options and the CORE column from the output, including --json',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(List);
+        // Every call scans active plugins' own PHP source for names the naming guess missed (not
+        // opt-in, roughly 1-3s on a real site once vendor/tests/languages are pruned from the scan;
+        // see OptionsService::listOptionNames() server-side), hence the spinner unconditionally.
+        ux.action.start('Fetching and verifying options');
+        let options;
+        try {
+            options = await this.wp.get(OPTIONS_ENDPOINT);
+        }
+        finally {
+            ux.action.stop();
+        }
+        if (flags['no-core'])
+            options = options.filter((option) => !option.core);
+        if (options.length === 0) {
+            this.log('No options found');
+            return options;
+        }
+        const includeCore = !flags['no-core'];
+        this.log(`Found ${pluralize(options.length, 'option')}:\n`);
+        this.log(renderLegend(includeCore));
+        this.log('');
+        this.log(renderTable(options, { includeCore }));
+        return options;
+    }
+}

package/dist/commands/{page → option}/pull.d.ts

@@ -1,14 +1,5 @@
 import { LoopressCommand } from '../../lib/base.js';
-type PulledPage = {
-    id: number;
-    title: string;
-};
-type PullResult = {
-    orphans: string[];
-    pulled: PulledPage[];
-    skipped: number;
-    status: 'dry-run' | 'success';
-};
+import { type LocalOption } from '../../utils/option-format.js';
 export default class Pull extends LoopressCommand {
     static args: {
         path: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
@@ -20,6 +11,6 @@ export default class Pull extends LoopressCommand {
         yes: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
-    run(): Promise<PullResult>;
+    run(): Promise<LocalOption[]>;
+    private pullOption;
 }
-export {};

package/dist/commands/option/pull.js

@@ -0,0 +1,75 @@
+import { Args } from '@oclif/core';
+import { writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { LoopressCommand } from '../../lib/base.js';
+import { loadFiles } from '../../lib/load-files.js';
+import { isNotFoundError } from '../../lib/wp-client.js';
+import { optionEndpoint, optionFileName, parseLocalOption } from '../../utils/option-format.js';
+import { pluralize } from '../../utils/pluralize.js';
+export default class Pull extends LoopressCommand {
+    static args = {
+        path: Args.string({ description: 'Path to options directory (overrides project config)' }),
+    };
+    static description = 'Refresh locally tracked options from WordPress. Options not yet tracked are never pulled, run `lps option add <name>` for those first.';
+    static enableJsonFlag = true;
+    static examples = ['$ lps option pull'];
+    static flags = {
+        ...LoopressCommand.dryRunFlag,
+        ...LoopressCommand.yesFlag,
+    };
+    async run() {
+        const { args } = await this.parse(Pull);
+        const dir = this.resolveOptionsPath(args.path);
+        const { url } = this.siteConfig;
+        this.log(`Pulling tracked options from ${url}`);
+        this.log(`Options path: ${dir}`);
+        const tracked = await loadFiles(dir, {
+            extension: '.json',
+            onSkip: (message) => {
+                this.warn(message);
+            },
+            parse: parseLocalOption,
+        });
+        if (tracked.length === 0) {
+            this.log('Nothing tracked locally. Run `lps option add <name>` first.');
+            return [];
+        }
+        if (this.dryRun) {
+            this.log(`[dry-run] Would refresh ${pluralize(tracked.length, 'option')}: ${tracked.map((option) => option.name).join(', ')}`);
+            return tracked;
+        }
+        const refreshed = [];
+        const orphans = [];
+        for (const option of tracked) {
+            const result = await this.pullOption(dir, option);
+            if (result === null) {
+                orphans.push(optionFileName(option.name));
+            }
+            else {
+                refreshed.push(result);
+                this.log(`Pulled: ${option.name}`);
+            }
+        }
+        await this.removeOrphanedFiles(dir, orphans, 'no longer exist on WordPress');
+        this.log(`Pulled ${pluralize(refreshed.length, 'option')}`);
+        return refreshed;
+    }
+    // Returns the refreshed option (and writes it to disk), or null when the tracked name is a
+    // 404 on this environment: absent, not a failure (see the orphan reconciliation in run()).
+    // readonly is a local policy flag with no WordPress counterpart, always preserved from the
+    // existing file rather than overwritten by the pulled value.
+    async pullOption(dir, option) {
+        let remote;
+        try {
+            remote = await this.wp.get(optionEndpoint(option.name));
+        }
+        catch (error) {
+            if (isNotFoundError(error))
+                return null;
+            throw error;
+        }
+        const local = { ...remote, readonly: option.readonly };
+        await writeFile(join(dir, optionFileName(option.name)), JSON.stringify(local, null, 2) + '\n');
+        return local;
+    }
+}

package/dist/commands/{page → option}/push.d.ts

@@ -1,10 +1,7 @@
 import { PushCommand } from '../../lib/push-command.js';
-type PushedPage = {
-    id: null | number;
-    title: string;
-};
 type PushResult = {
-    pushed: PushedPage[];
+    pushed: string[];
+    skipped: string[];
     status: 'dry-run' | 'success';
 };
 export default class Push extends PushCommand {
@@ -19,8 +16,6 @@ export default class Push extends PushCommand {
         'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<PushResult>;
-    private ensureCanonicalFilename;
-    private loadFiles;
-    private pushPage;
+    private pushOption;
 }
 export {};

package/dist/commands/option/push.js

@@ -0,0 +1,66 @@
+import { Args } from '@oclif/core';
+import { loadFiles } from '../../lib/load-files.js';
+import { PushCommand } from '../../lib/push-command.js';
+import { optionEndpoint, parseLocalOption, partitionByReadonly } from '../../utils/option-format.js';
+import { pluralize } from '../../utils/pluralize.js';
+export default class Push extends PushCommand {
+    static args = {
+        path: Args.string({ description: 'Path to options directory (overrides project config)' }),
+    };
+    static description = 'Push locally tracked, non-readonly options to WordPress (upsert only, never deletes an untracked option). ' +
+        'Options marked "readonly": true in their local file are skipped, edit the file to override.';
+    static enableJsonFlag = true;
+    static examples = ['$ lps option push'];
+    static flags = {
+        ...PushCommand.dryRunFlag,
+        ...PushCommand.yesFlag,
+    };
+    async run() {
+        const { args } = await this.parse(Push);
+        const dir = this.resolveOptionsPath(args.path);
+        const { url } = this.siteConfig;
+        this.log(`Pushing tracked options to ${url}`);
+        this.log(`Options path: ${dir}`);
+        const tracked = await loadFiles(dir, {
+            extension: '.json',
+            onSkip: (message) => {
+                this.warn(message);
+            },
+            parse: parseLocalOption,
+        });
+        const { skipped, writable } = partitionByReadonly(tracked);
+        if (skipped.length > 0) {
+            this.log(`Skipping ${pluralize(skipped.length, 'readonly option')}: ${skipped.map((option) => option.name).join(', ')}`);
+        }
+        this.log(`Found ${pluralize(writable.length, 'option')} to push`);
+        const pushed = [];
+        await this.runPushTasks(writable, (option) => option.name, async (option, task) => {
+            await this.pushOption(option, task);
+            pushed.push(option.name);
+        });
+        if (this.failedCount > 0) {
+            this.error(`${pluralize(this.failedCount, 'option')} failed to push.`);
+        }
+        const skippedNames = skipped.map((option) => option.name);
+        if (this.dryRun)
+            return { pushed, skipped: skippedNames, status: 'dry-run' };
+        await this.recordSuccess();
+        this.log('All options pushed.');
+        return { pushed, skipped: skippedNames, status: 'success' };
+    }
+    async pushOption(option, task) {
+        if (this.dryRun) {
+            if (task)
+                task.output = `[dry-run] Would push: ${option.name}`;
+            return;
+        }
+        try {
+            await this.wp.put(optionEndpoint(option.name), { autoload: option.autoload, value: option.value });
+            if (task)
+                task.output = `Pushed: ${option.name}`;
+        }
+        catch (error) {
+            this.reportTaskFailure(`Failed to push ${option.name}: ${error.message}`, error, task);
+        }
+    }
+}

package/dist/commands/option/remove.d.ts

@@ -0,0 +1,22 @@
+import { LoopressCommand } from '../../lib/base.js';
+type RemoveResult = {
+    deletedRemote: boolean;
+    name: string;
+    status: 'aborted' | 'dry-run' | 'success';
+};
+export default class Remove extends LoopressCommand {
+    static args: {
+        name: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static enableJsonFlag: boolean;
+    static examples: string[];
+    static flags: {
+        'local-only': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        path: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        yes: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<RemoveResult>;
+}
+export {};

package/dist/commands/option/remove.js

@@ -0,0 +1,69 @@
+import { confirm } from '@inquirer/prompts';
+import { Args, Flags } from '@oclif/core';
+import { rm } from 'node:fs/promises';
+import { join } from 'node:path';
+import { LoopressCommand } from '../../lib/base.js';
+import { guardProductionPush } from '../../lib/guard-production-push.js';
+import { isInteractive } from '../../lib/interactive.js';
+import { isNotFoundError } from '../../lib/wp-client.js';
+import { optionEndpoint, optionFileName } from '../../utils/option-format.js';
+export default class Remove extends LoopressCommand {
+    static args = {
+        name: Args.string({ description: 'Option name to stop tracking', required: true }),
+    };
+    static description = 'Stop tracking an option locally and delete it from WordPress. Local untracking always happens (git-reversible); ' +
+        'pass --local-only to skip the WordPress delete and only stop tracking.';
+    static enableJsonFlag = true;
+    static examples = ['$ lps option remove wpseo_titles', '$ lps option remove wpseo_titles --local-only'];
+    static flags = {
+        ...LoopressCommand.dryRunFlag,
+        ...LoopressCommand.yesFlag,
+        'local-only': Flags.boolean({ description: 'Untrack locally without deleting the option on WordPress' }),
+        path: Flags.string({ description: 'Path to options directory (overrides project config)' }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(Remove);
+        const { name } = args;
+        const dir = this.resolveOptionsPath(flags.path);
+        const { url } = this.siteConfig;
+        const file = join(dir, optionFileName(name));
+        const localOnly = flags['local-only'];
+        if (this.dryRun) {
+            const andDelete = localOnly ? '' : ` and delete it from ${url}`;
+            this.log(`[dry-run] Would untrack "${name}" locally${andDelete}`);
+            return { deletedRemote: false, name, status: 'dry-run' };
+        }
+        if (localOnly) {
+            await rm(file, { force: true });
+            this.log(`Untracked "${name}" locally (left untouched on ${url})`);
+            return { deletedRemote: false, name, status: 'success' };
+        }
+        await guardProductionPush({
+            dryRun: this.dryRun,
+            error: (message) => this.error(message),
+            siteConfig: this.siteConfig,
+            yes: this.yes,
+        });
+        if (!this.yes && isInteractive()) {
+            const isProceed = await confirm({ default: false, message: `Delete option "${name}" from ${url}? (local tracking also stops)` });
+            if (!isProceed) {
+                this.log('Aborted.');
+                return { deletedRemote: false, name, status: 'aborted' };
+            }
+        }
+        let deletedRemote = true;
+        try {
+            await this.wp.delete(optionEndpoint(name));
+        }
+        catch (error) {
+            if (!isNotFoundError(error))
+                throw error;
+            deletedRemote = false;
+        }
+        await rm(file, { force: true });
+        this.log(deletedRemote
+            ? `Removed "${name}" from ${url} and untracked it locally`
+            : `"${name}" was already absent on ${url}; untracked it locally`);
+        return { deletedRemote, name, status: 'success' };
+    }
+}

package/dist/commands/plugin/push.d.ts

@@ -19,7 +19,6 @@ export default class Push extends PushCommand {
     };
     run(): Promise<PushResult>;
     private activate;
-    private confirmRemovals;
     private deactivate;
     private deactivateEndangered;
     private fetchInstanceLock;

package/dist/commands/plugin/push.js

@@ -1,8 +1,7 @@
-import { confirm } from '@inquirer/prompts';
 import { Flags } from '@oclif/core';
 import { existsSync } from 'node:fs';
 import { join } from 'node:path';
-import { isInteractive } from '../../lib/interactive.js';
+import { confirmUninstall } from '../../lib/interactive.js';
 import { PushCommand } from '../../lib/push-command.js';
 import { isNotFoundError } from '../../lib/wp-client.js';
 import { isDowngrade, parseCollisions, SYNC_TIMEOUT_MS } from '../../utils/plugin-sync.js';
@@ -55,7 +54,8 @@ export default class Push extends PushCommand {
         if (this.dryRun) {
             return this.result(diff, { includeCollisions: true, pruned: toPrune, removed: diff.toRemove, status: 'dry-run' });
         }
-        await this.confirmRemovals(diff.toRemove);
+        if (!(await confirmUninstall(diff.toRemove, this.yes)))
+            this.error('Aborted.');
         const deactivated = await this.deactivateEndangered(installed, diff, force);
         // Plugins that must end up active: the ones we deactivated for the file swap (minus any
         // being uninstalled) plus the ones the manifest wants active but that are inactive today.
@@ -92,13 +92,6 @@ export default class Push extends PushCommand {
             await this.wp.put(`wp/v2/plugins/${plugin.file}`, { status: 'active' });
         }
     }
-    async confirmRemovals(toRemove) {
-        if (toRemove.length === 0 || this.yes || !isInteractive())
-            return;
-        const ok = await confirm({ default: false, message: `Uninstall ${toRemove.join(', ')} from the site?` });
-        if (!ok)
-            this.error('Aborted.');
-    }
     async deactivate(plugins) {
         for (const plugin of plugins) {
             this.log(`  ⊘ deactivating ${plugin.slug}`);

package/dist/commands/pull.js

@@ -8,13 +8,14 @@ const PULL_TARGETS = [
     { commandId: 'plugin:pull', label: 'plugins' },
     { commandId: 'acf:pull', label: 'ACF', supportsYes: true },
     { commandId: 'api:pull', label: 'API routes', supportsYes: true },
+    { commandId: 'hook:pull', label: 'hooks', supportsYes: true },
     { commandId: 'form:pull', label: 'forms', supportsYes: true },
-    { commandId: 'page:pull', label: 'pages', supportsYes: true },
     { commandId: 'seo:pull', label: 'SEO', supportsYes: true },
+    { commandId: 'option:pull', label: 'options', supportsYes: true },
     { commandId: 'snippet:pull', label: 'snippets', supportsYes: true },
 ];
 export default class Pull extends LoopressCommand {
-    static description = 'Pull all content, plugins, composer dependencies, ACF, API routes, forms, pages, SEO, and snippets, from WordPress';
+    static description = 'Pull all content, plugins, composer dependencies, ACF, API routes, hooks, forms, SEO, options, and snippets, from WordPress';
     static examples = ['$ lps pull', '$ lps pull --env staging', '$ lps pull --dry-run'];
     static flags = {
         ...LoopressCommand.dryRunFlag,

package/dist/commands/push.js

@@ -8,13 +8,14 @@ const PUSH_TARGETS = [
     { commandId: 'composer:push', label: 'composer' },
     { commandId: 'acf:push', label: 'ACF' },
     { commandId: 'api:push', label: 'API routes' },
+    { commandId: 'hook:push', label: 'hooks' },
     { commandId: 'form:push', label: 'forms' },
-    { commandId: 'page:push', label: 'pages' },
     { commandId: 'seo:push', label: 'SEO' },
+    { commandId: 'option:push', label: 'options' },
     { commandId: 'snippet:push', label: 'snippets' },
 ];
 export default class Push extends LoopressCommand {
-    static description = 'Push all local content, plugins, composer dependencies, ACF, API routes, forms, pages, SEO, and snippets, to WordPress';
+    static description = 'Push all local content, plugins, composer dependencies, ACF, API routes, hooks, forms, SEO, options, and snippets, to WordPress';
     static examples = ['$ lps push', '$ lps push --env staging', '$ lps push --dry-run'];
     static flags = {
         ...LoopressCommand.dryRunFlag,
@@ -42,7 +43,7 @@ export default class Push extends LoopressCommand {
     }
     // Every delegated push always gets --yes: either this command's own guard already confirmed
     // production once above, or the target isn't production and there's nothing to confirm.
-    // Without this, each of the 8 delegated commands would re-run its own production guard.
+    // Without this, each delegated command would re-run its own production guard.
     buildArgv() {
         const argv = ['--env', this.siteConfig.name, '--yes'];
         if (this.dryRun)

package/dist/commands/seo/diff.d.ts

@@ -0,0 +1,2 @@
+declare const _default: typeof import("../../lib/diff-command.js").DiffCommand;
+export default _default;

package/dist/commands/seo/diff.js

@@ -0,0 +1,5 @@
+import { resourceDiffCommand } from '../../lib/diff-command.js';
+export default resourceDiffCommand('seo', {
+    description: 'Show what differs in SEO settings, post meta, and redirects between your local files and a WordPress environment, or between two environments',
+    pathNoun: 'SEO directory',
+});

package/dist/commands/snippet/diff.d.ts

@@ -0,0 +1,2 @@
+declare const _default: typeof import("../../lib/diff-command.js").DiffCommand;
+export default _default;

package/dist/commands/snippet/diff.js

@@ -0,0 +1,5 @@
+import { resourceDiffCommand } from '../../lib/diff-command.js';
+export default resourceDiffCommand('snippet', {
+    description: 'Show what differs in snippets between your local files and a WordPress environment, or between two environments',
+    pathNoun: 'snippets directory',
+});

package/dist/commands/theme/push.d.ts

@@ -15,7 +15,6 @@ export default class Push extends PushCommand {
         'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<PushResult>;
-    private confirmRemovals;
     private fetchInstanceLock;
     private guardForce;
     private sync;

package/dist/commands/theme/push.js

@@ -1,8 +1,7 @@
-import { confirm } from '@inquirer/prompts';
 import { Flags } from '@oclif/core';
 import { existsSync } from 'node:fs';
 import { join } from 'node:path';
-import { isInteractive } from '../../lib/interactive.js';
+import { confirmUninstall } from '../../lib/interactive.js';
 import { PushCommand } from '../../lib/push-command.js';
 import { isNotFoundError } from '../../lib/wp-client.js';
 import { isDowngrade, parseCollisions, SYNC_TIMEOUT_MS } from '../../utils/plugin-sync.js';
@@ -65,7 +64,8 @@ export default class Push extends PushCommand {
             this.log(`  ! ${c.slug} (take over)`);
         if (this.dryRun)
             return result(diff, 'dry-run', diff.toRemove, true);
-        await this.confirmRemovals(diff.toRemove);
+        if (!(await confirmUninstall(diff.toRemove, this.yes)))
+            this.error('Aborted.');
         const response = await this.sync(manifest, force);
         if (response.output.trim())
             this.log(response.output.trim());
@@ -73,13 +73,6 @@ export default class Push extends PushCommand {
         await this.recordSuccess();
         return result(diff, 'success', response.removed ?? diff.toRemove, force);
     }
-    async confirmRemovals(toRemove) {
-        if (toRemove.length === 0 || this.yes || !isInteractive())
-            return;
-        const ok = await confirm({ default: false, message: `Uninstall ${toRemove.join(', ')} from the site?` });
-        if (!ok)
-            this.error('Aborted.');
-    }
     async fetchInstanceLock() {
         try {
             const { composerLock } = await this.wp.get('loopress/v1/composer/lock');

package/dist/lib/base.d.ts

@@ -35,7 +35,8 @@ export declare abstract class LoopressCommand extends Command {
     protected resolveApiPath(override?: string): string;
     protected resolveAppsPath(override?: string): string;
     protected resolveFormPath(override?: string): string;
-    protected resolvePagePath(override?: string): string;
+    protected resolveHooksPath(override?: string): string;
+    protected resolveOptionsPath(override?: string): string;
     protected resolveSeoPath(override?: string): string;
     protected resolveSnippetsPath(override?: string): string;
     private pickEnvironment;