@loopress/cli 0.2.0 → 0.4.0

package/dist/commands/plugin/push.js

@@ -0,0 +1,111 @@
+import { confirm } from '@inquirer/prompts';
+import { Flags } from '@oclif/core';
+import got from 'got';
+import { LoopressCommand } from '../../lib/base.js';
+import { readLocalConfig } from '../../utils/loopress-config.js';
+import { diffPlugins } from '../../utils/plugins.js';
+export default class Push extends LoopressCommand {
+    static description = 'Sync plugins on WordPress to match loopress.json';
+    static examples = ['$ lps plugins push', '$ lps plugins push --dry-run'];
+    static flags = {
+        ...LoopressCommand.baseFlags,
+        'dry-run': Flags.boolean({ char: 'd', description: 'Show what would change without making changes' }),
+    };
+    async run() {
+        const { flags } = await this.parse(Push);
+        const dryRun = flags['dry-run'];
+        const { url } = this.siteConfig;
+        const localConfig = await readLocalConfig();
+        const manifest = localConfig.plugins;
+        if (!manifest || Object.keys(manifest).length === 0) {
+            this.error('No plugins found in loopress.json. Run `lps plugins pull` first.');
+        }
+        this.log(`Pushing plugins to ${url}`);
+        const headers = await this.buildAuthHeaders();
+        const installed = await got.get(`${url}/wp-json/loopress/v1/plugins`, { headers }).json();
+        const { drifted, toActivate, toInstall } = diffPlugins(manifest, installed);
+        if (toInstall.length === 0 && toActivate.length === 0 && drifted.length === 0) {
+            this.log('Everything is already in sync.');
+            return;
+        }
+        if (toInstall.length > 0) {
+            this.log(`\nTo install (${toInstall.length}):`);
+            for (const a of toInstall)
+                this.log(`  + ${a.slug} @ ${a.targetVersion}`);
+        }
+        if (toActivate.length > 0) {
+            this.log(`\nTo activate (${toActivate.length}):`);
+            for (const a of toActivate)
+                this.log(`  ↑ ${a.slug}`);
+        }
+        if (drifted.length > 0) {
+            this.log(`\nVersion mismatch (${drifted.length}):`);
+            for (const a of drifted) {
+                this.log(`  ~ ${a.slug}: site has ${a.currentVersion}, manifest wants ${a.targetVersion}`);
+            }
+        }
+        if (dryRun)
+            return;
+        // Install missing plugins and activate them.
+        for (const action of toInstall) {
+            this.log(`\nInstalling ${action.slug} @ ${action.targetVersion}...`);
+            try {
+                const result = await got
+                    .post(`${url}/wp-json/loopress/v1/plugins/install`, {
+                    headers,
+                    json: { slug: action.slug, version: action.targetVersion },
+                })
+                    .json();
+                this.log(`  ✓ ${result.message}`);
+            }
+            catch (error) {
+                this.warn(`  Failed to install ${action.slug}: ${error.message}`);
+                continue;
+            }
+            await this.activatePlugin(url, headers, action.slug);
+        }
+        // Activate installed-but-inactive plugins without prompting.
+        for (const action of toActivate) {
+            this.log(`\nActivating ${action.slug}...`);
+            await this.activatePlugin(url, headers, action.slug);
+        }
+        // Prompt per drifted plugin before syncing.
+        for (const action of drifted) {
+            this.log('');
+            const proceed = await confirm({
+                default: false,
+                message: `${action.slug} is at ${action.currentVersion} on the site but manifest wants ${action.targetVersion}. Sync to ${action.targetVersion}?`,
+            });
+            if (!proceed) {
+                this.log(`  Skipped ${action.slug}`);
+                continue;
+            }
+            this.log(`  Syncing ${action.slug} to ${action.targetVersion}...`);
+            try {
+                const result = await got
+                    .post(`${url}/wp-json/loopress/v1/plugins/install`, {
+                    headers,
+                    json: { slug: action.slug, version: action.targetVersion },
+                })
+                    .json();
+                this.log(`  ✓ ${result.message}`);
+            }
+            catch (error) {
+                this.warn(`  Failed to sync ${action.slug}: ${error.message}`);
+                continue;
+            }
+            await this.activatePlugin(url, headers, action.slug);
+        }
+    }
+    async activatePlugin(url, headers, slug) {
+        try {
+            const result = await got
+                .post(`${url}/wp-json/loopress/v1/plugins/activate`, { headers, json: { slug } })
+                .json();
+            this.log(`  ✓ ${result.message}`);
+        }
+        catch (error) {
+            this.warn(`  Failed to activate ${slug}: ${error.message}`);
+        }
+    }
+}

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

@@ -0,0 +1,17 @@
+import { LoopressCommand } from '../../lib/base.js';
+export declare function resolvePluginVersion(slug: string, version: string): Promise<string>;
+export default class Require extends LoopressCommand {
+    static args: {
+        slug: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+        version: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        password: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        url: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        user: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/plugin/require.js

@@ -0,0 +1,74 @@
+import { Args, Flags } from '@oclif/core';
+import got from 'got';
+import { LoopressCommand } from '../../lib/base.js';
+import { readLocalConfig, writeLocalConfig } from '../../utils/loopress-config.js';
+const WP_ORG_API = 'https://api.wordpress.org/plugins/info/1.2/';
+export async function resolvePluginVersion(slug, version) {
+    if (version !== 'latest')
+        return version;
+    let info;
+    try {
+        info = await got
+            .get(WP_ORG_API, {
+            searchParams: {
+                action: 'plugin_information',
+                'request[slug]': slug,
+            },
+        })
+            .json();
+    }
+    catch {
+        throw new Error(`Plugin "${slug}" not found on WordPress.org.`);
+    }
+    if (info.error)
+        throw new Error(`Plugin "${slug}" not found on WordPress.org.`);
+    return info.version;
+}
+export default class Require extends LoopressCommand {
+    static args = {
+        slug: Args.string({ description: 'Plugin slug (WordPress.org)', required: true }),
+        version: Args.string({ description: 'Version to pin (default: latest)' }),
+    };
+    static description = 'Add a plugin to loopress.json, resolving its latest version from WordPress.org';
+    static examples = [
+        '$ lps plugins require woocommerce',
+        '$ lps plugins require woocommerce 8.9.1',
+        '$ lps plugins require contact-form-7 --dry-run',
+    ];
+    static flags = {
+        ...LoopressCommand.baseFlags,
+        'dry-run': Flags.boolean({ char: 'd', description: 'Show what would be written without making changes' }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(Require);
+        const dryRun = flags['dry-run'];
+        const { slug } = args;
+        const requestedVersion = args.version ?? 'latest';
+        this.log(`Resolving ${slug}@${requestedVersion}...`);
+        let resolvedVersion;
+        try {
+            resolvedVersion = await resolvePluginVersion(slug, requestedVersion);
+        }
+        catch (error) {
+            this.error(error.message);
+        }
+        this.log(`Resolved: ${slug}@${resolvedVersion}`);
+        const localConfig = await readLocalConfig();
+        const existing = localConfig.plugins ?? {};
+        if (existing[slug] === resolvedVersion) {
+            this.log(`${slug}@${resolvedVersion} is already in loopress.json — nothing to do.`);
+            return;
+        }
+        const updated = existing[slug] !== undefined;
+        const label = updated ? `${existing[slug]} → ${resolvedVersion}` : resolvedVersion;
+        if (dryRun) {
+            this.log(`[dry-run] Would ${updated ? 'update' : 'add'} ${slug}: ${label}`);
+            return;
+        }
+        await writeLocalConfig({
+            ...localConfig,
+            plugins: { ...existing, [slug]: resolvedVersion },
+        });
+        this.log(`${updated ? 'Updated' : 'Added'} ${slug}: ${label}`);
+    }
+}

package/dist/commands/{snippets → snippet}/pull.js

@@ -13,6 +13,7 @@ const EXTENSIONS = {
 const sanitize = (value) => value.replaceAll(/\s*\n\s*/g, ' ').trim();
 function buildMetaLines(snippet) {
     return [
+        `id: ${snippet.id}`,
         `name: ${sanitize(snippet.name)}`,
         ...(snippet.description ? [`description: ${sanitize(snippet.description)}`] : []),
         `type: ${snippet.type}`,

package/dist/commands/{snippets → snippet}/push.d.ts

@@ -13,6 +13,8 @@ export default class Push extends LoopressCommand {
         user: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
     };
     run(): Promise<void>;
+    private injectIdIntoFile;
     private loadSnippets;
+    private parseMetaFromContent;
     private pushSnippet;
 }

package/dist/commands/{snippets → snippet}/push.js

@@ -45,6 +45,20 @@ export default class Push extends LoopressCommand {
             this.error(error.message);
         }
     }
+    async injectIdIntoFile(filePath, content, id) {
+        const fs = await import('node:fs/promises');
+        let updated;
+        if (content.includes('/**')) {
+            updated = content.replace('/**', `/**\n * id: ${id}`);
+        }
+        else if (content.includes('<!--')) {
+            updated = content.replace('<!--', `<!--\n  id: ${id}`);
+        }
+        else {
+            return;
+        }
+        await fs.writeFile(filePath, updated);
+    }
     async loadSnippets(path) {
         const fs = await import('node:fs/promises');
         const snippets = [];
@@ -54,9 +68,11 @@ export default class Push extends LoopressCommand {
                 if (file.endsWith('.php')) {
                     const filePath = `${path}/${file}`;
                     const content = await fs.readFile(filePath, 'utf8');
+                    const meta = this.parseMetaFromContent(content);
                     snippets.push({
                         code: content,
-                        name: file.replace('.php', ''),
+                        id: meta.id,
+                        name: meta.name ?? file.replace('.php', ''),
                         path: filePath,
                     });
                 }
@@ -67,6 +83,14 @@ export default class Push extends LoopressCommand {
         }
         return snippets;
     }
+    parseMetaFromContent(content) {
+        const idMatch = content.match(/[\s*]*id:\s*(\d+)/);
+        const nameMatch = content.match(/[\s*]*name:\s*(.+)/);
+        return {
+            id: idMatch ? Number(idMatch[1]) : undefined,
+            name: nameMatch ? nameMatch[1].trim() : undefined,
+        };
+    }
     async pushSnippet(snippet, url, headers, dryRun, adapter) {
         if (dryRun) {
             this.log(`📝 [DRY RUN] Would push snippet: ${snippet.name}`);
@@ -75,20 +99,18 @@ export default class Push extends LoopressCommand {
         }
         try {
             const endpoint = adapter.endpoint(url);
-            const remoteList = await got.get(endpoint, { headers }).json();
-            const existing = remoteList
-                .map((r) => adapter.fromRemote(r))
-                .find((s) => s.name === snippet.name);
             const payload = adapter.toPayload(snippet.name, snippet.code, snippet.path);
-            if (existing) {
-                this.log(`🔄 Updating existing snippet: ${snippet.name}`);
-                await got.put(`${endpoint}/${existing.id}`, { headers, json: payload });
-            }
-            else {
-                this.log(`➕ Creating new snippet: ${snippet.name}`);
-                await got.post(endpoint, { headers, json: payload });
+            if (snippet.id) {
+                this.log(`🔄 Updating snippet by id (${snippet.id}): ${snippet.name}`);
+                await got.put(`${endpoint}/${snippet.id}`, { headers, json: payload });
+                this.log(`✅ Updated: ${snippet.name}`);
+                return;
             }
-            this.log(`✅ ${existing ? 'Updated' : 'Created'}: ${snippet.name}`);
+            this.log(`➕ Creating new snippet: ${snippet.name}`);
+            const response = await got.post(endpoint, { headers, json: payload }).json();
+            const created = adapter.fromRemote(response);
+            await this.injectIdIntoFile(snippet.path, snippet.code, created.id);
+            this.log(`✅ Created: ${snippet.name} (id: ${created.id})`);
         }
         catch (error) {
             this.error(`❌ Error pushing snippet ${snippet.name}: ${error.message}`);

package/dist/types/plugin.d.ts

@@ -0,0 +1,15 @@
+export interface InstalledPlugin {
+    active: boolean;
+    file: string;
+    name: string;
+    slug: string;
+    version: string;
+}
+export interface InstallResult {
+    message: string;
+    version: string;
+}
+export interface ActivateResult {
+    message: string;
+}
+export type PluginManifest = Record<string, string>;

package/dist/types/plugin.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/loopress-config.d.ts

@@ -1,6 +1,8 @@
 export interface LoopressLocalConfig {
+    plugins?: Record<string, string>;
     rootDir?: string;
     snippets?: string;
     styles?: string;
 }
 export declare function readLocalConfig(): Promise<LoopressLocalConfig>;
+export declare function writeLocalConfig(config: LoopressLocalConfig): Promise<void>;

package/dist/utils/loopress-config.js

@@ -1,14 +1,19 @@
 import { existsSync } from 'node:fs';
+import { readFile, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
 export async function readLocalConfig() {
-    const configPath = join(process.cwd(), 'loopress.config.js');
+    const configPath = join(process.cwd(), 'loopress.json');
     if (!existsSync(configPath))
         return {};
     try {
-        const mod = await import(configPath);
-        return mod.default ?? {};
+        const content = await readFile(configPath, 'utf8');
+        return JSON.parse(content);
     }
     catch {
         return {};
     }
 }
+export async function writeLocalConfig(config) {
+    const configPath = join(process.cwd(), 'loopress.json');
+    await writeFile(configPath, JSON.stringify(config, null, 2) + '\n', 'utf8');
+}

package/dist/utils/plugins.d.ts

@@ -0,0 +1,27 @@
+import { InstalledPlugin, PluginManifest } from '../types/plugin.js';
+export interface PluginDiff {
+    drifted: Array<{
+        currentVersion: string;
+        slug: string;
+        targetVersion: string;
+    }>;
+    toActivate: Array<{
+        slug: string;
+    }>;
+    toInstall: Array<{
+        slug: string;
+        targetVersion: string;
+    }>;
+    upToDate: string[];
+}
+export interface MergeResult {
+    added: string[];
+    merged: PluginManifest;
+    updated: Array<{
+        from: string;
+        slug: string;
+        to: string;
+    }>;
+}
+export declare function mergePluginManifest(existing: PluginManifest, incoming: PluginManifest): MergeResult;
+export declare function diffPlugins(manifest: PluginManifest, installed: InstalledPlugin[]): PluginDiff;

package/dist/utils/plugins.js

@@ -0,0 +1,34 @@
+export function mergePluginManifest(existing, incoming) {
+    const merged = { ...existing, ...incoming };
+    const added = Object.keys(incoming).filter((s) => !(s in existing));
+    const updated = Object.keys(incoming)
+        .filter((s) => s in existing && existing[s] !== incoming[s])
+        .map((s) => ({ from: existing[s], slug: s, to: incoming[s] }));
+    return { added, merged, updated };
+}
+export function diffPlugins(manifest, installed) {
+    const installedMap = new Map(installed.map((p) => [p.slug, p]));
+    const toInstall = [];
+    const toActivate = [];
+    const drifted = [];
+    const upToDate = [];
+    for (const [slug, targetVersion] of Object.entries(manifest)) {
+        const live = installedMap.get(slug);
+        if (!live) {
+            toInstall.push({ slug, targetVersion });
+            continue;
+        }
+        if (live.version === targetVersion) {
+            if (live.active) {
+                upToDate.push(slug);
+            }
+            else {
+                toActivate.push({ slug });
+            }
+        }
+        else {
+            drifted.push({ currentVersion: live.version, slug, targetVersion });
+        }
+    }
+    return { drifted, toActivate, toInstall, upToDate };
+}