@loopress/cli 0.23.0 → 0.24.0

package/dist/lib/base.js

@@ -6,6 +6,7 @@ import { join } from 'node:path';
 import { configManager } from '../config/project-config.manager.js';
 import { readLocalConfig } from '../utils/loopress-config.js';
 import { pluralize } from '../utils/pluralize.js';
+import { resolveResourceDir } from '../utils/resource-dirs.js';
 import { isInteractive } from './interactive.js';
 import { isAppPasswordStale, rotateAppPassword } from './rotate-app-password.js';
 import { WpClient } from './wp-client.js';
@@ -132,39 +133,28 @@ export class LoopressCommand extends Command {
         }
     }
     resolveAcfPath(override) {
-        if (override)
-            return override;
-        return join(this.rootDir, this.localConfig.acfDir ?? 'acf');
+        return resolveResourceDir('acf', this.localConfig, override);
     }
     resolveApiPath(override) {
-        if (override)
-            return override;
-        return join(this.rootDir, this.localConfig.apiDir ?? 'api');
+        return resolveResourceDir('api', this.localConfig, override);
     }
     resolveAppsPath(override) {
-        if (override)
-            return override;
-        return join(this.rootDir, this.localConfig.appsDir ?? 'apps');
+        return resolveResourceDir('apps', this.localConfig, override);
     }
     resolveFormPath(override) {
-        if (override)
-            return override;
-        return join(this.rootDir, this.localConfig.formDir ?? 'forms');
+        return resolveResourceDir('form', this.localConfig, override);
     }
-    resolvePagePath(override) {
-        if (override)
-            return override;
-        return join(this.rootDir, this.localConfig.pageDir ?? 'pages');
+    resolveHooksPath(override) {
+        return resolveResourceDir('hooks', this.localConfig, override);
+    }
+    resolveOptionsPath(override) {
+        return resolveResourceDir('options', this.localConfig, override);
     }
     resolveSeoPath(override) {
-        if (override)
-            return override;
-        return join(this.rootDir, this.localConfig.seoDir ?? 'seo');
+        return resolveResourceDir('seo', this.localConfig, override);
     }
     resolveSnippetsPath(override) {
-        if (override)
-            return override;
-        return join(this.rootDir, this.localConfig.snippetsDir ?? 'snippets');
+        return resolveResourceDir('snippets', this.localConfig, override);
     }
     pickEnvironment(project, envName) {
         const env = project.environments[envName];

package/dist/lib/dev-watch.d.ts

@@ -1,5 +1,5 @@
 import { type LoopressLocalConfig } from '../utils/loopress-config.js';
-export type ResourceType = 'api' | 'pages' | 'plugins' | 'snippets';
+export type ResourceType = 'api' | 'plugins' | 'snippets';
 export declare const RESOURCE_TYPES: ResourceType[];
 export type WatchTarget = {
     commandId: string;

package/dist/lib/dev-watch.js

@@ -1,6 +1,6 @@
 import { existsSync } from 'node:fs';
 import { join, sep } from 'node:path';
-export const RESOURCE_TYPES = ['snippets', 'pages', 'api', 'plugins'];
+export const RESOURCE_TYPES = ['snippets', 'api', 'plugins'];
 // `only` narrows the default set, `skip` then removes from whatever that set is, same
 // precedence a combined `--only=a,b --skip=b` reads as: watch a, b, then drop b.
 export function resolveResourceTypes(only, skip = []) {
@@ -15,7 +15,6 @@ export function buildWatchTargets(types, localConfig, cwd) {
     const rootDir = join(cwd, localConfig.rootDir ?? '.');
     const candidates = {
         api: { commandId: 'api:push', path: join(rootDir, localConfig.apiDir ?? 'api'), type: 'api' },
-        pages: { commandId: 'page:push', path: join(rootDir, localConfig.pageDir ?? 'pages'), type: 'pages' },
         plugins: { commandId: 'plugin:push', path: join(cwd, 'loopress.json'), type: 'plugins' },
         snippets: { commandId: 'snippet:push', path: join(rootDir, localConfig.snippetsDir ?? 'snippets'), type: 'snippets' },
     };

package/dist/lib/diff-command.d.ts

@@ -0,0 +1,47 @@
+import { LoopressCommand } from './base.js';
+import { type ResourceState, type StateChange } from './diff-state.js';
+import { type ResourceStateProvider } from './resource-state.js';
+import { WpClient } from './wp-client.js';
+export type ResourceDiffJson = {
+    added: string[];
+    changed: StateChange[];
+    error?: string;
+    removed: string[];
+};
+export type DiffJson = {
+    drift: boolean;
+    left: string;
+    resources: Record<string, ResourceDiffJson>;
+    right: string;
+};
+export type DiffTarget = {
+    left: () => Promise<ResourceState>;
+    resource: string;
+    right: () => Promise<ResourceState>;
+    title: string;
+};
+type DiffSides = {
+    againstWp: undefined | WpClient;
+    leftLabel: string;
+    rightLabel: string;
+    warn: (message: string) => void;
+};
+export declare abstract class DiffCommand extends LoopressCommand {
+    static againstFlag: {
+        against: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    protected composerTarget(sides: DiffSides): DiffTarget;
+    protected providerTarget(provider: ResourceStateProvider, sides: DiffSides, dirOverride?: string): DiffTarget;
+    protected report(targets: DiffTarget[], sides: DiffSides): Promise<DiffJson>;
+    protected resolveSides(against: string | undefined): DiffSides;
+    abstract run(): Promise<DiffJson>;
+    private computeResource;
+    private out;
+    private renderSection;
+    private wpForEnvironment;
+}
+export declare function resourceDiffCommand(resource: string, options: {
+    description: string;
+    pathNoun: string;
+}): typeof DiffCommand;
+export {};

package/dist/lib/diff-command.js

@@ -0,0 +1,180 @@
+import { Args, Flags, ux } from '@oclif/core';
+import { resolve } from 'node:path';
+import { configManager } from '../config/project-config.manager.js';
+import { resolveResourceDir } from '../utils/resource-dirs.js';
+import { LoopressCommand } from './base.js';
+import { compareStates, isEmptyDiff } from './diff-state.js';
+import { composerLocalState, composerRemoteState, getResourceStateProvider } from './resource-state.js';
+import { WpClient } from './wp-client.js';
+const c = ux.colorize;
+// Shared machinery for `lps diff` and the per-resource `lps <resource> diff` commands: the
+// `--against` flag, resolving the two sides, turning a provider into a comparison target, and
+// running + rendering the comparison with a CI-friendly exit code.
+export class DiffCommand extends LoopressCommand {
+    // Spread into each concrete command's `static flags`, same pattern as PushCommand.dryRunFlag.
+    static againstFlag = {
+        against: Flags.string({
+            description: 'Compare the primary environment against this second environment instead of against local files',
+        }),
+    };
+    composerTarget(sides) {
+        // resolve(), not join(): an absolute `rootDir` in loopress.json must stay absolute rather
+        // than being prefixed with the cwd, so Composer is read from the same place as the
+        // file-backed resources.
+        const localRoot = resolve(process.cwd(), this.rootDir);
+        return {
+            left: async () => composerRemoteState(this.wp),
+            resource: 'composer',
+            right: sides.againstWp ? async () => composerRemoteState(sides.againstWp) : async () => composerLocalState(localRoot),
+            title: 'Composer',
+        };
+    }
+    // Turns a directory-backed provider into a target; `dirOverride` is the optional `[PATH]`
+    // arg the per-resource commands accept.
+    providerTarget(provider, sides, dirOverride) {
+        if (dirOverride !== undefined && sides.againstWp) {
+            this.error('A [PATH] argument cannot be combined with --against: --against compares two environments, not local files.');
+        }
+        const dir = resolveResourceDir(provider.dirKind, this.localConfig, dirOverride);
+        return {
+            left: async () => provider.remote(this.wp, sides.warn, dir),
+            resource: provider.resource,
+            right: sides.againstWp ? async () => provider.remote(sides.againstWp, sides.warn, dir) : async () => provider.local(dir, sides.warn),
+            title: provider.title,
+        };
+    }
+    // Runs every target (concurrently), prints a git-style section per resource in target order,
+    // a tally, and the verdict, then returns the structured result. Exit code: 1 on drift, 2
+    // when a resource could not be compared (inconclusive), so the command doubles as a CI gate.
+    async report(targets, sides) {
+        this.out(`Comparing ${c('bold', sides.leftLabel)} ${c('dim', '→')} ${c('bold', sides.rightLabel)}\n`);
+        const results = await Promise.all(targets.map(async (target) => this.computeResource(target, sides)));
+        const resources = {};
+        let drift = false;
+        let failed = false;
+        let compared = 0;
+        let added = 0;
+        let removed = 0;
+        let changed = 0;
+        for (const result of results) {
+            resources[result.resource] = result.json;
+            if (result.json.error !== undefined) {
+                failed = true;
+                const errorLabel = c('red', `error: ${result.json.error}`);
+                this.out(`${c('bold', result.title)}  ${errorLabel}`);
+                continue;
+            }
+            compared += 1;
+            added += result.json.added.length;
+            removed += result.json.removed.length;
+            changed += result.json.changed.length;
+            if (result.stateDiff)
+                this.renderSection(result.title, result.stateDiff);
+            if (result.drift)
+                drift = true;
+        }
+        this.out(`\n${compared} compared: ${changed} changed, ${added} added, ${removed} removed`);
+        if (failed)
+            this.out(c('red', 'Some resources could not be compared; this run is inconclusive.'));
+        else
+            this.out(drift ? c('yellow', 'Drift detected.') : c('green', 'Everything is in sync.'));
+        if (failed)
+            process.exitCode = 2;
+        else if (drift)
+            process.exitCode = 1;
+        return { drift, left: sides.leftLabel, resources, right: sides.rightLabel };
+    }
+    resolveSides(against) {
+        if (against === this.siteConfig.name) {
+            this.error('--against must be a different environment from the one being compared.');
+        }
+        return {
+            againstWp: against ? this.wpForEnvironment(against) : undefined,
+            leftLabel: this.siteConfig.name,
+            rightLabel: against ?? 'local',
+            warn: (message) => {
+                this.warn(message);
+            },
+        };
+    }
+    // Fetches and compares one target. No output (so targets can run concurrently); `report`
+    // renders `stateDiff` afterwards in a fixed order.
+    async computeResource(target, sides) {
+        try {
+            const [leftState, rightState] = await Promise.all([target.left(), target.right()]);
+            const stateDiff = compareStates(leftState, rightState, { left: sides.leftLabel, right: sides.rightLabel });
+            return {
+                drift: !isEmptyDiff(stateDiff),
+                json: { added: stateDiff.added, changed: stateDiff.changed, removed: stateDiff.removed },
+                resource: target.resource,
+                stateDiff,
+                title: target.title,
+            };
+        }
+        catch (error) {
+            const { message } = error;
+            return { drift: false, json: { added: [], changed: [], error: message, removed: [] }, resource: target.resource, title: target.title };
+        }
+    }
+    out(message) {
+        if (!this.jsonEnabled())
+            this.log(message);
+    }
+    renderSection(title, stateDiff) {
+        if (isEmptyDiff(stateDiff)) {
+            this.out(`${c('bold', title)}  ${c('dim', 'in sync')}`);
+            return;
+        }
+        this.out(c('bold', title));
+        for (const id of stateDiff.added)
+            this.out(c('green', `  + ${id}`));
+        for (const id of stateDiff.removed)
+            this.out(c('red', `  - ${id}`));
+        for (const change of stateDiff.changed) {
+            this.out(c('yellow', `  ~ ${change.id}`));
+            this.out(indentPatch(change.patch));
+        }
+    }
+    wpForEnvironment(envName) {
+        const env = configManager.getEnvironment(this.projectId, envName);
+        if (!env) {
+            this.error(`Environment "${envName}" not found in this project.`);
+        }
+        if (!env.token) {
+            this.error(`No credentials configured for "${envName}". Run \`lps project config\` to add them.`);
+        }
+        return new WpClient(env.url, env.token);
+    }
+}
+// Builds the `lps <resource> diff` command class for one directory-backed resource. They differ
+// only in wording and which provider they target, so the whole body lives here.
+export function resourceDiffCommand(resource, options) {
+    class ResourceDiff extends DiffCommand {
+        static args = {
+            path: Args.string({ description: `Path to ${options.pathNoun} (overrides project config)` }),
+        };
+        static description = options.description;
+        static enableJsonFlag = true;
+        static examples = [
+            `$ lps ${resource} diff`,
+            `$ lps ${resource} diff --env staging`,
+            `$ lps ${resource} diff --env staging --against production`,
+        ];
+        static flags = { ...DiffCommand.againstFlag };
+        async run() {
+            const { args, flags } = await this.parse(ResourceDiff);
+            const sides = this.resolveSides(flags.against);
+            return this.report([this.providerTarget(getResourceStateProvider(resource), sides, args.path)], sides);
+        }
+    }
+    return ResourceDiff;
+}
+// Indents an already-formatted change block (a per-field list or a header-less unified diff)
+// so it sits visually under the `~ id` line.
+function indentPatch(patch) {
+    return patch
+        .split('\n')
+        .map((line) => (line === '' ? line : `    ${line}`))
+        .join('\n')
+        .trimEnd();
+}

package/dist/lib/diff-state.d.ts

@@ -0,0 +1,22 @@
+export type ResourceState = Map<string, unknown>;
+export type FieldChange = {
+    from?: unknown;
+    kind: 'added' | 'changed' | 'removed';
+    path: string;
+    to?: unknown;
+};
+export type StateChange = {
+    fields?: FieldChange[];
+    id: string;
+    patch: string;
+};
+export type StateDiff = {
+    added: string[];
+    changed: StateChange[];
+    removed: string[];
+};
+export declare function compareStates(left: ResourceState, right: ResourceState, labels: {
+    left: string;
+    right: string;
+}): StateDiff;
+export declare function isEmptyDiff(diff: StateDiff): boolean;

package/dist/lib/diff-state.js

@@ -0,0 +1,88 @@
+import { createTwoFilesPatch } from 'diff';
+import microdiff from 'microdiff';
+import { isDeepStrictEqual } from 'node:util';
+const MAX_VALUE_LENGTH = 200;
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+function formatValue(value) {
+    const text = JSON.stringify(value) ?? String(value);
+    return text.length > MAX_VALUE_LENGTH ? `${text.slice(0, MAX_VALUE_LENGTH - 1)}…` : text;
+}
+// createTwoFilesPatch treats a missing final newline as a "" hunk
+// line, noise when both sides lack it; normalize so only real differences surface.
+function ensureTrailingNewline(text) {
+    return text.endsWith('\n') ? text : `${text}\n`;
+}
+// Two strings (an API route file, a hook file, composer.json): a real line diff. Only the
+// `Index:` / `===` preamble createTwoFilesPatch emits is dropped; the `--- <left>` / `+++
+// <right>` lines are kept so each hunk still states its own direction.
+function renderTextChange(id, left, right, labels) {
+    const patch = createTwoFilesPatch(id, id, ensureTrailingNewline(left), ensureTrailingNewline(right), labels.left, labels.right);
+    const lines = patch.split('\n');
+    const start = lines.findIndex((line) => line.startsWith('--- '));
+    return (start === -1 ? lines : lines.slice(start)).join('\n').trimEnd();
+}
+// Two objects: microdiff walks them structurally and returns one entry per changed leaf, so
+// key ordering never matters and a big nested blob (a WPForms definition, an ACF group)
+// reduces to just the fields that moved.
+function objectFieldChanges(left, right) {
+    return microdiff(left, right, { cyclesFix: false }).map((change) => {
+        const path = change.path.join('.');
+        if (change.type === 'CREATE')
+            return { kind: 'added', path, to: change.value };
+        if (change.type === 'REMOVE')
+            return { from: change.oldValue, kind: 'removed', path };
+        return { from: change.oldValue, kind: 'changed', path, to: change.value };
+    });
+}
+function renderFieldChanges(changes) {
+    return changes
+        .map((change) => {
+        if (change.kind === 'added')
+            return `+ ${change.path}: ${formatValue(change.to)}`;
+        if (change.kind === 'removed')
+            return `- ${change.path}: ${formatValue(change.from)}`;
+        return `~ ${change.path}: ${formatValue(change.from)} → ${formatValue(change.to)}`;
+    })
+        .join('\n');
+}
+function changeFor(id, left, right, labels) {
+    if (typeof left === 'string' && typeof right === 'string') {
+        return { id, patch: renderTextChange(id, left, right, labels) };
+    }
+    if (isRecord(left) && isRecord(right)) {
+        const fields = objectFieldChanges(left, right);
+        return { fields, id, patch: renderFieldChanges(fields) };
+    }
+    // Type mismatch between the two sides (e.g. a field that was a string and is now an object).
+    return { id, patch: `~ ${formatValue(left)} → ${formatValue(right)}` };
+}
+// `left` is the reference, `right` is the subject. For `lps diff` with no env-vs-env args
+// that's remote (left) vs local (right), so `added` reads as "present locally, not on the
+// site" and `removed` as "on the site, not locally".
+export function compareStates(left, right, labels) {
+    const diff = { added: [], changed: [], removed: [] };
+    for (const id of right.keys()) {
+        if (!left.has(id))
+            diff.added.push(id);
+    }
+    for (const id of left.keys()) {
+        if (!right.has(id)) {
+            diff.removed.push(id);
+            continue;
+        }
+        const leftValue = left.get(id);
+        const rightValue = right.get(id);
+        if (isDeepStrictEqual(leftValue, rightValue))
+            continue;
+        diff.changed.push(changeFor(id, leftValue, rightValue, labels));
+    }
+    diff.added.sort((a, b) => a.localeCompare(b));
+    diff.removed.sort((a, b) => a.localeCompare(b));
+    diff.changed.sort((a, b) => a.id.localeCompare(b.id));
+    return diff;
+}
+export function isEmptyDiff(diff) {
+    return diff.added.length === 0 && diff.removed.length === 0 && diff.changed.length === 0;
+}

package/dist/lib/find-orphaned-files.js

@@ -1,7 +1,7 @@
 import { readdir } from 'node:fs/promises';
 import { extname, join } from 'node:path';
 // Same shape as load-files.ts's own walker, kept separate rather than shared: this one
-// filters against a list of extensions (page/snippet pull need more than one), that one
+// filters against a list of extensions (snippet pull needs more than one), that one
 // against a single extension, and reconciling the two would cost more than the ~15 duplicated
 // lines it would save.
 async function walk(dir, extensions) {

package/dist/lib/interactive.d.ts

@@ -1 +1,2 @@
 export declare function isInteractive(): boolean;
+export declare function confirmUninstall(toRemove: string[], yes: boolean): Promise<boolean>;

package/dist/lib/interactive.js

@@ -1,3 +1,4 @@
+import { confirm } from '@inquirer/prompts';
 // Whether prompts can be shown at all: a real terminal on both ends, and not a CI runner.
 // CI=1 with a pseudo-TTY still counts as non-interactive, which is what CI users expect.
 // Every command that prompts routes its decision through this so the CLI never hangs on a
@@ -5,3 +6,12 @@
 export function isInteractive() {
     return process.stdin.isTTY && process.stdout.isTTY && !process.env.CI;
 }
+// The "about to uninstall N plugins/themes from the site" gate shared by `plugin push` and
+// `theme push`. Returns whether the caller may proceed: nothing to remove, --yes, or a
+// non-interactive shell all pass straight through; otherwise the user is asked and a "no"
+// returns false so the caller can abort.
+export async function confirmUninstall(toRemove, yes) {
+    if (yes || toRemove.length === 0 || !isInteractive())
+        return true;
+    return confirm({ default: false, message: `Uninstall ${toRemove.join(', ')} from the site?` });
+}

package/dist/lib/php-files-command.d.ts

@@ -0,0 +1,54 @@
+import { type Config } from '@oclif/core';
+import { type EnvironmentConfig } from '../types/config.js';
+import { type ResourceDirKind } from '../utils/resource-dirs.js';
+import { LoopressCommand } from './base.js';
+import { PushCommand } from './push-command.js';
+export type PhpFilesResource = {
+    afterPush?: (context: {
+        filenames: string[];
+        siteConfig: EnvironmentConfig;
+    }) => Promise<void>;
+    cliName: string;
+    dirKind: ResourceDirKind;
+    emptyListMessage: string;
+    endpoint: string;
+    filenamePattern: RegExp;
+    invalidFilenameHint: string;
+    label: string;
+    listDescription: string;
+    noun: string;
+    orphanReason: string;
+    pathLabel: string;
+    pathNoun: string;
+    pullDescription: string;
+    pushDescription: string;
+};
+type PhpFile = {
+    content: string;
+    filename: string;
+};
+type PushResult = {
+    pushed: string[];
+    status: 'dry-run' | 'success';
+};
+type PullResult = {
+    orphans: string[];
+    pulled: string[];
+    status: 'dry-run' | 'success';
+};
+export type CommandClass<TInstance> = new (argv: string[], config: Config) => TInstance;
+export type PushFilesCommand = Omit<PushCommand, 'run'> & {
+    run(): Promise<PushResult>;
+};
+export type PullFilesCommand = Omit<LoopressCommand, 'run'> & {
+    run(): Promise<PullResult>;
+};
+export type ListFilesCommand = Omit<LoopressCommand, 'run'> & {
+    run(): Promise<PhpFile[]>;
+};
+export declare function resourcePushCommand(spec: PhpFilesResource): CommandClass<PushFilesCommand>;
+export declare function resourcePullCommand(spec: PhpFilesResource): CommandClass<PullFilesCommand>;
+export declare function resourceListCommand(spec: PhpFilesResource): CommandClass<ListFilesCommand>;
+export declare const API_FILES_RESOURCE: PhpFilesResource;
+export declare const HOOK_FILES_RESOURCE: PhpFilesResource;
+export {};