@loopress/cli 0.22.0 → 0.24.0

package/dist/commands/app/remove.js

@@ -0,0 +1,42 @@
+import { confirm } from '@inquirer/prompts';
+import { Args } from '@oclif/core';
+import { LoopressCommand } from '../../lib/base.js';
+import { guardProductionPush } from '../../lib/guard-production-push.js';
+import { isInteractive } from '../../lib/interactive.js';
+export default class Remove extends LoopressCommand {
+    static args = {
+        name: Args.string({ description: 'App to remove from WordPress', required: true }),
+    };
+    static description = 'Remove a single-page app from WordPress: deletes its bundle from wp-content/loopress/apps/ and unregisters the shortcode. Local files are left untouched.';
+    static enableJsonFlag = true;
+    static examples = ['$ lps app remove search'];
+    static flags = {
+        ...LoopressCommand.dryRunFlag,
+        ...LoopressCommand.yesFlag,
+    };
+    async run() {
+        const { args } = await this.parse(Remove);
+        const { name } = args;
+        const { url } = this.siteConfig;
+        if (this.dryRun) {
+            this.log(`[dry-run] Would delete app "${name}" from ${url}`);
+            return { deleted: false, name, status: 'dry-run' };
+        }
+        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 app "${name}" from ${url}?` });
+            if (!isProceed) {
+                this.log('Aborted.');
+                return { deleted: false, name, status: 'aborted' };
+            }
+        }
+        await this.wp.delete(`loopress/v1/apps/${name}`);
+        this.log(`Removed app "${name}" from ${url}`);
+        return { deleted: true, name, status: 'success' };
+    }
+}

package/dist/commands/composer/pull.js

@@ -1,23 +1,13 @@
 import { writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { LoopressCommand } from '../../lib/base.js';
-import { isNotFoundError } from '../../lib/wp-client.js';
-// Narrower than isNotFoundError(): a bare 404 also covers the route being absent (plugin not
-// installed, or an edition/version predating Composer support), which must still surface the
-// normal "is the plugin installed?" guidance rather than being read as "no lock yet".
+import { isApplicative404 } from '../../lib/wp-client.js';
+// A site that never had Composer dependencies pushed has no composer.lock yet: the Loopress
+// controller answers that specific 404 with `{"error": "composer.lock not found"}`. Any other
+// 404 (route absent because the plugin isn't installed or predates Composer support) must
+// still surface the normal "is the plugin installed?" guidance instead of being swallowed.
 function isMissingComposerLock(error) {
-    if (!isNotFoundError(error))
-        return false;
-    const body = error.cause?.response?.body;
-    if (!body)
-        return false;
-    try {
-        const parsed = JSON.parse(body);
-        return parsed.error === 'composer.lock not found';
-    }
-    catch {
-        return false;
-    }
+    return isApplicative404(error, 'composer.lock not found');
 }
 export default class ComposerPull extends LoopressCommand {
     static description = 'Pull composer.json and composer.lock from WordPress';

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

@@ -9,6 +9,7 @@ export default class ComposerPush extends PushCommand {
     static enableJsonFlag: boolean;
     static examples: string[];
     static flags: {
+        force: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         yes: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };

package/dist/commands/composer/push.js

@@ -1,53 +1,77 @@
+import { Flags } from '@oclif/core';
 import { existsSync } from 'node:fs';
 import { readFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { PushCommand } from '../../lib/push-command.js';
 import { isTimeoutError } from '../../lib/wp-client.js';
-// A cold composer install easily exceeds the global 30s timeout of WpClient.
-const COMPOSER_SYNC_TIMEOUT_MS = 600_000;
+import { parseCollisions, SYNC_TIMEOUT_MS } from '../../utils/plugin-sync.js';
+// Split a composer.json `require` map into the three intent namespaces the sync endpoint
+// understands. `composer/installers` is owned by the server scaffold, never sent.
+function toIntent(require) {
+    const intent = { libraries: {}, plugins: {}, themes: {} };
+    for (const [name, constraint] of Object.entries(require)) {
+        if (name === 'composer/installers')
+            continue;
+        if (name.startsWith('wpackagist-plugin/')) {
+            intent.plugins[name.slice('wpackagist-plugin/'.length)] = constraint;
+        }
+        else if (name.startsWith('wpackagist-theme/')) {
+            intent.themes[name.slice('wpackagist-theme/'.length)] = constraint;
+        }
+        else {
+            intent.libraries[name] = constraint;
+        }
+    }
+    return intent;
+}
 export default class ComposerPush extends PushCommand {
-    static description = 'Push composer.json and composer.lock to WordPress and run composer install';
+    static description = 'Push composer.json (and composer.lock, if present) to WordPress and run Composer';
     static enableJsonFlag = true;
     static examples = ['$ lps composer push', '$ lps composer push --dry-run'];
     static flags = {
         ...PushCommand.dryRunFlag,
         ...PushCommand.yesFlag,
+        force: Flags.boolean({ default: false, description: 'Allow downgrades and take over plugins/themes installed outside Loopress' }),
     };
     async run() {
         const { url } = this.siteConfig;
+        const { flags } = await this.parse(ComposerPush);
+        const { force } = flags;
         const composerJsonPath = join(process.cwd(), this.rootDir, 'composer.json');
         const composerLockPath = join(process.cwd(), this.rootDir, 'composer.lock');
         if (!existsSync(composerJsonPath)) {
-            this.error(`No composer.json found at ${composerJsonPath}`);
+            this.error(`No composer.json found at ${composerJsonPath}. Run \`lps composer init\` first.`);
         }
-        const composerJsonRaw = await readFile(composerJsonPath, 'utf8');
-        const parsed = JSON.parse(composerJsonRaw);
-        const packageCount = Object.keys(parsed.require ?? {}).length;
+        const parsed = JSON.parse(await readFile(composerJsonPath, 'utf8'));
+        const require = parsed.require ?? {};
+        const packageCount = Object.keys(require).length;
+        const intent = toIntent(require);
         const hasLock = existsSync(composerLockPath);
-        const composerLockRaw = hasLock ? await readFile(composerLockPath, 'utf8') : null;
+        const lock = hasLock ? await readFile(composerLockPath, 'utf8') : null;
         this.log(`Pushing composer.json (${packageCount} ${packageCount === 1 ? 'package' : 'packages'}) to ${url}`);
-        if (composerLockRaw) {
+        if (lock)
             this.log('  + composer.lock included (reproducible install)');
-        }
-        else {
+        else
             this.warn('No composer.lock found. The server will resolve versions freely.');
-        }
         if (this.dryRun)
             return { hasLock, packageCount, status: 'dry-run' };
-        this.log('Running composer install on the server, this can take a few minutes...');
+        this.log('Running Composer on the server, this can take a few minutes...');
+        let response;
         try {
-            await this.wp.post('loopress/v1/composer/sync', {
-                composerJson: composerJsonRaw,
-                composerLock: composerLockRaw,
-            }, { timeoutMs: COMPOSER_SYNC_TIMEOUT_MS });
+            response = await this.wp.post('loopress/v1/composer/sync', { force, intent, lock }, { timeoutMs: SYNC_TIMEOUT_MS });
         }
         catch (error) {
+            if (parseCollisions(error)) {
+                this.error('Plugins or themes are installed outside Loopress. Re-run with --force to take them over.');
+            }
             if (isTimeoutError(error)) {
-                this.error(`${error.message} The composer install may still be running on the server.`);
+                this.error(`${error.message} The Composer run may still be in progress on the server.`);
             }
             throw error;
         }
-        this.log('composer install completed on the server.');
+        if (response.output.trim())
+            this.log(response.output.trim());
+        this.log('Composer run completed on the server.');
         await this.recordSuccess();
         return { hasLock, packageCount, status: 'success' };
     }

package/dist/commands/dev.js

@@ -9,7 +9,7 @@ const DEBOUNCE_MS = 400;
 const IGNORED = /(?:(^|[/\\])(\.git|node_modules|\.DS_Store)(?:[/\\]|$))|(?:\.swp$)/;
 export default class Dev extends Command {
     static description = 'Watch project files and push changes to the local WordPress instance as they happen. Always targets the "local" environment, run `lps snippet push` etc. directly for any other environment.';
-    static examples = ['$ lps dev', '$ lps dev --only=snippets,pages', '$ lps dev --skip=plugins'];
+    static examples = ['$ lps dev', '$ lps dev --only=snippets,api', '$ lps dev --skip=plugins'];
     static flags = {
         only: Flags.string({ description: `Only watch these resource types (comma-separated): ${RESOURCE_TYPES.join(', ')}` }),
         skip: Flags.string({ description: `Skip these resource types (comma-separated): ${RESOURCE_TYPES.join(', ')}` }),

package/dist/commands/diff.d.ts

@@ -0,0 +1,13 @@
+import { DiffCommand, type DiffJson } from '../lib/diff-command.js';
+export default class Diff extends DiffCommand {
+    static description: string;
+    static enableJsonFlag: boolean;
+    static examples: string[];
+    static flags: {
+        only: import("@oclif/core/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        skip: import("@oclif/core/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        against: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<DiffJson>;
+    private selectResources;
+}

package/dist/commands/diff.js

@@ -0,0 +1,42 @@
+import { Flags } from '@oclif/core';
+import { DiffCommand } from '../lib/diff-command.js';
+import { RESOURCE_STATE_PROVIDERS } from '../lib/resource-state.js';
+// Everything `lps diff` can compare, in report order. Composer isn't a directory-backed
+// provider (see resource-state.ts) so it's named here explicitly.
+const RESOURCES = [...RESOURCE_STATE_PROVIDERS.map((provider) => provider.resource), 'composer'];
+export default class Diff extends DiffCommand {
+    static description = [
+        'Show what differs between your local tracked files and a WordPress environment, or between two environments.',
+        'Covers snippets, forms, ACF, API routes, Hooks, SEO, and Composer. Plugins and themes have their own `lps plugin status` / `lps theme status`.',
+        'Exit code: 0 in sync, 1 on drift, 2 when a resource could not be compared, so it doubles as a CI drift gate.',
+    ].join(' ');
+    static enableJsonFlag = true;
+    static examples = [
+        '$ lps diff',
+        '$ lps diff --env staging',
+        '$ lps diff --env staging --against production',
+        '$ lps diff --only snippet --only acf',
+        '$ lps diff --skip composer',
+    ];
+    static flags = {
+        ...DiffCommand.againstFlag,
+        only: Flags.string({ description: 'Only compare these resources', multiple: true, options: [...RESOURCES] }),
+        skip: Flags.string({ description: 'Compare every resource except these', multiple: true, options: [...RESOURCES] }),
+    };
+    async run() {
+        const { flags } = await this.parse(Diff);
+        const sides = this.resolveSides(flags.against);
+        const selected = this.selectResources(flags.only, flags.skip);
+        const targets = [
+            ...RESOURCE_STATE_PROVIDERS.filter((provider) => selected.has(provider.resource)).map((provider) => this.providerTarget(provider, sides)),
+            ...(selected.has('composer') ? [this.composerTarget(sides)] : []),
+        ];
+        return this.report(targets, sides);
+    }
+    // `--only` narrows the default set, `--skip` then removes from whatever that set is, same
+    // precedence a combined `--only=a,b --skip=b` reads as (mirrors dev-watch's resolveResourceTypes).
+    selectResources(only, skip) {
+        const base = only && only.length > 0 ? only : RESOURCES;
+        return new Set(base.filter((resource) => !(skip ?? []).includes(resource)));
+    }
+}

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

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

package/dist/commands/form/diff.js

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

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

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

package/dist/commands/hook/diff.js

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

package/dist/commands/hook/list.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("../../lib/php-files-command.js").CommandClass<import("../../lib/php-files-command.js").ListFilesCommand>;
+export default _default;

package/dist/commands/hook/list.js

@@ -0,0 +1,2 @@
+import { HOOK_FILES_RESOURCE, resourceListCommand } from '../../lib/php-files-command.js';
+export default resourceListCommand(HOOK_FILES_RESOURCE);

package/dist/commands/hook/pull.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("../../lib/php-files-command.js").CommandClass<import("../../lib/php-files-command.js").PullFilesCommand>;
+export default _default;

package/dist/commands/hook/pull.js

@@ -0,0 +1,2 @@
+import { HOOK_FILES_RESOURCE, resourcePullCommand } from '../../lib/php-files-command.js';
+export default resourcePullCommand(HOOK_FILES_RESOURCE);

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

@@ -0,0 +1,2 @@
+declare const _default: import("../../lib/php-files-command.js").CommandClass<import("../../lib/php-files-command.js").PushFilesCommand>;
+export default _default;

package/dist/commands/hook/push.js

@@ -0,0 +1,2 @@
+import { HOOK_FILES_RESOURCE, resourcePushCommand } from '../../lib/php-files-command.js';
+export default resourcePushCommand(HOOK_FILES_RESOURCE);

package/dist/commands/init.js

@@ -16,8 +16,9 @@ const FEATURES = [
     { dir: 'acf', key: 'acfDir', label: 'ACF' },
     { dir: 'seo', key: 'seoDir', label: 'SEO' },
     { dir: 'forms', key: 'formDir', label: 'Forms' },
-    { dir: 'pages', key: 'pageDir', label: 'Pages' },
     { dir: 'api', key: 'apiDir', label: 'Custom API routes' },
+    { dir: 'hooks', key: 'hooksDir', label: 'Hooks (actions, filters, cron)' },
+    { dir: 'apps', key: 'appsDir', label: 'Single-page apps' },
 ];
 export default class Init extends Command {
     static description = 'Initialize a loopress.json config file in the current directory';

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

@@ -0,0 +1,15 @@
+import { LoopressCommand } from '../../lib/base.js';
+import { type LocalOption } from '../../utils/option-format.js';
+export default class Add 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: {
+        path: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<LocalOption>;
+}

package/dist/commands/option/add.js

@@ -0,0 +1,47 @@
+import { Args, Flags } from '@oclif/core';
+import { mkdir, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { LoopressCommand } from '../../lib/base.js';
+import { isNotFoundError } from '../../lib/wp-client.js';
+import { defaultReadonlyFor, isReservedOptionName, optionEndpoint, optionFileName, } from '../../utils/option-format.js';
+export default class Add extends LoopressCommand {
+    static args = {
+        name: Args.string({ description: 'Option name to start tracking (see `lps option list`)', required: true }),
+    };
+    static description = 'Fetch a WordPress option by name and start tracking it locally. Run `lps option list` first to find the name: ' +
+        'this copies a raw value across environments, verify it does not embed post/user IDs before pushing it elsewhere.';
+    static enableJsonFlag = true;
+    static examples = ['$ lps option add wpseo_titles', '$ lps option add siteurl'];
+    static flags = {
+        ...LoopressCommand.dryRunFlag,
+        path: Flags.string({ description: 'Path to options directory (overrides project config)' }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(Add);
+        const { name } = args;
+        const dir = this.resolveOptionsPath(flags.path);
+        if (isReservedOptionName(name)) {
+            this.error(`"${name}" is managed by \`lps plugin\`/\`lps theme\`, not \`lps option\`.`);
+        }
+        let remote;
+        try {
+            remote = await this.wp.get(optionEndpoint(name));
+        }
+        catch (error) {
+            if (isNotFoundError(error)) {
+                this.error(`Option "${name}" was not found on ${this.siteConfig.url}. Run \`lps option list\` to see available names.`);
+            }
+            throw error;
+        }
+        const local = { ...remote, readonly: defaultReadonlyFor(name) };
+        const file = join(dir, optionFileName(name));
+        if (this.dryRun) {
+            this.log(`[dry-run] Would track "${name}" at ${file}`);
+            return local;
+        }
+        await mkdir(dir, { recursive: true });
+        await writeFile(file, JSON.stringify(local, null, 2) + '\n');
+        this.log(`Tracking "${name}"${local.readonly ? ' (readonly: push will skip it, see the file to override)' : ''} at ${file}`);
+        return local;
+    }
+}

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

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

package/dist/commands/option/diff.js

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

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

@@ -1,7 +1,11 @@
 import { LoopressCommand } from '../../lib/base.js';
+import { type ListedOption } from '../../utils/option-format.js';
 export default class List extends LoopressCommand {
     static description: string;
     static enableJsonFlag: boolean;
     static examples: string[];
-    run(): Promise<Array<Record<string, unknown>>>;
+    static flags: {
+        'no-core': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<ListedOption[]>;
 }

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/option/pull.d.ts

@@ -0,0 +1,16 @@
+import { LoopressCommand } from '../../lib/base.js';
+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>>;
+    };
+    static description: string;
+    static enableJsonFlag: boolean;
+    static examples: string[];
+    static flags: {
+        yes: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<LocalOption[]>;
+    private pullOption;
+}