@loopress/cli 0.3.0 → 0.5.0

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

@@ -1,8 +1,8 @@
 import { Args, Flags } from '@oclif/core';
 import got from 'got';
-import { LoopressCommand } from '../../lib/base.js';
+import { PushCommand } from '../../lib/push-command.js';
 import { getSnippetPlugin } from '../../utils/snippet-plugin.js';
-export default class Push extends LoopressCommand {
+export default class Push extends PushCommand {
     static args = {
         path: Args.string({ description: 'Path to snippets directory (overrides project config)' }),
     };
@@ -14,68 +14,86 @@ export default class Push extends LoopressCommand {
         '$ lps snippets push --plugin wpcode',
     ];
     static flags = {
-        ...LoopressCommand.baseFlags,
+        ...PushCommand.baseFlags,
         dryRun: Flags.boolean({ char: 'd', description: 'Dry run - show what would happen without making changes' }),
         plugin: Flags.string({
             char: 'p',
-            default: 'code-snippets',
-            description: 'WordPress snippet plugin to target',
+            description: 'WordPress snippet plugin to target (overrides loopress.json)',
             options: ['code-snippets', 'wpcode'],
         }),
     };
     async run() {
         const { args, flags } = await this.parse(Push);
         const { dryRun, plugin } = flags;
+        this.dryRun = dryRun;
         const { url } = this.siteConfig;
         const path = await this.resolveSnippetsPath(args.path);
-        this.log(`🚀 Pushing snippets to ${url} via ${plugin}`);
+        const resolvedPlugin = await this.resolveSnippetPlugin(plugin);
+        this.log(`🚀 Pushing snippets to ${url} via ${resolvedPlugin}`);
         this.log(`📂 From snippet path: ${path}`);
         this.log(`🔄 Dry run: ${dryRun ? 'yes' : 'no'}`);
+        let snippets = [];
         try {
-            const snippets = await this.loadSnippets(path);
+            snippets = await this.loadSnippets(path);
             this.log(`✅ Found ${snippets.length} snippets to push`);
             const headers = await this.buildAuthHeaders();
-            const adapter = getSnippetPlugin(plugin);
+            const adapter = getSnippetPlugin(resolvedPlugin);
             for (const snippet of snippets) {
-                await this.pushSnippet(snippet, url, headers, dryRun, adapter);
+                await this.pushSnippet(snippet, { adapter, dryRun, headers, url });
             }
+            await this.recordSuccess();
             this.log('🎉 All snippets pushed successfully!');
         }
         catch (error) {
             this.error(error.message);
         }
     }
-    async injectIdIntoFile(filePath, content, id) {
+    async injectIdIntoMeta(filePath, 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}`);
+        const metaPath = filePath.replace(/\.[^.]+$/, '.json');
+        let meta = {};
+        try {
+            const existing = await fs.readFile(metaPath, 'utf8');
+            meta = JSON.parse(existing);
         }
-        else {
-            return;
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
         }
-        await fs.writeFile(filePath, updated);
+        meta.id = id;
+        await fs.writeFile(metaPath, JSON.stringify(meta, null, 2) + '\n');
     }
     async loadSnippets(path) {
         const fs = await import('node:fs/promises');
         const snippets = [];
+        const SNIPPET_EXTENSIONS = new Set(['.css', '.html', '.js', '.php', '.txt']);
         try {
             const files = await fs.readdir(path);
             for (const file of files) {
-                if (file.endsWith('.php')) {
-                    const filePath = `${path}/${file}`;
-                    const content = await fs.readFile(filePath, 'utf8');
-                    const meta = this.parseMetaFromContent(content);
-                    snippets.push({
-                        code: content,
-                        id: meta.id,
-                        name: meta.name ?? file.replace('.php', ''),
-                        path: filePath,
-                    });
+                const ext = file.slice(file.lastIndexOf('.'));
+                if (!SNIPPET_EXTENSIONS.has(ext))
+                    continue;
+                const filePath = `${path}/${file}`;
+                const metaPath = filePath.slice(0, filePath.lastIndexOf('.')) + '.json';
+                const content = await fs.readFile(filePath, 'utf8');
+                let id;
+                let name;
+                try {
+                    const metaContent = await fs.readFile(metaPath, 'utf8');
+                    const meta = JSON.parse(metaContent);
+                    id = meta.id ? Number(meta.id) : undefined;
+                    name = meta.name ? String(meta.name) : undefined;
+                }
+                catch (error) {
+                    if (error.code !== 'ENOENT')
+                        throw error;
                 }
+                snippets.push({
+                    code: content,
+                    id,
+                    name: name ?? file.slice(0, file.lastIndexOf('.')),
+                    path: filePath,
+                });
             }
         }
         catch (error) {
@@ -83,15 +101,8 @@ 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) {
+    async pushSnippet(snippet, ctx) {
+        const { adapter, dryRun, headers, url } = ctx;
         if (dryRun) {
             this.log(`📝 [DRY RUN] Would push snippet: ${snippet.name}`);
             this.log(`📄 Code preview: ${snippet.code.slice(0, 100)}...`);
@@ -109,7 +120,7 @@ export default class Push extends LoopressCommand {
             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);
+            await this.injectIdIntoMeta(snippet.path, created.id);
             this.log(`✅ Created: ${snippet.name} (id: ${created.id})`);
         }
         catch (error) {

package/dist/config/auth.manager.js

@@ -30,10 +30,10 @@ export class AuthManager {
         }
     }
     getAuthFilePath() {
-        return join(this.homeDir, '.lps', 'auth.json');
+        return join(this.homeDir, '.loopress', 'auth.json');
     }
     setAuth(auth) {
-        const dir = join(this.homeDir, '.lps');
+        const dir = join(this.homeDir, '.loopress');
         if (!existsSync(dir))
             mkdirSync(dir, { recursive: true });
         const filePath = this.getAuthFilePath();

package/dist/config/project-config.manager.js

@@ -14,13 +14,13 @@ export class ProjectConfigManager {
         return ProjectConfigManager.instance;
     }
     ensureConfigDir() {
-        const dir = join(this.homeDir, '.lps');
+        const dir = join(this.homeDir, '.loopress');
         if (!existsSync(dir)) {
             mkdirSync(dir, { recursive: true });
         }
     }
     getConfigFilePath() {
-        return join(this.homeDir, '.lps', 'config.json');
+        return join(this.homeDir, '.loopress', 'config.json');
     }
     getCurrentEnv() {
         const project = this.getCurrentProject();

package/dist/lib/base.d.ts

@@ -9,6 +9,6 @@ export declare abstract class LoopressCommand extends Command {
     protected siteConfig: EnvironmentConfig;
     buildAuthHeaders(): Promise<Record<string, string>>;
     init(): Promise<void>;
+    protected resolveSnippetPlugin(flag?: string): Promise<'code-snippets' | 'wpcode'>;
     protected resolveSnippetsPath(override?: string): Promise<string>;
-    protected resolveStylesPath(override?: string): Promise<string>;
 }

package/dist/lib/base.js

@@ -27,6 +27,18 @@ export class LoopressCommand extends Command {
     }
     async init() {
         await super.init();
+        const localConfig = await readLocalConfig();
+        if (localConfig.projectId) {
+            const project = configManager.getProject(localConfig.projectId);
+            if (!project) {
+                this.error(`Project "${localConfig.projectId}" (from loopress.json) not found. Run \`lps project config\` to configure it.`);
+            }
+            if (!project.currentEnv || !project.environments[project.currentEnv]) {
+                this.error(`Project "${localConfig.projectId}" has no active environment. Run \`lps project config\` to configure one.`);
+            }
+            this.siteConfig = project.environments[project.currentEnv];
+            return;
+        }
         const env = configManager.getCurrentEnv();
         if (env) {
             this.siteConfig = env;
@@ -34,16 +46,16 @@ export class LoopressCommand extends Command {
         }
         this.error('No environment configured. Run `lps project config` first.');
     }
-    async resolveSnippetsPath(override) {
-        if (override)
-            return override;
+    async resolveSnippetPlugin(flag) {
+        if (flag)
+            return flag;
         const config = await readLocalConfig();
-        return join(config.rootDir ?? '.', config.snippets ?? 'snippets');
+        return config.snippetPlugin ?? 'wpcode';
     }
-    async resolveStylesPath(override) {
+    async resolveSnippetsPath(override) {
         if (override)
             return override;
         const config = await readLocalConfig();
-        return join(config.rootDir ?? '.', config.styles ?? 'styles');
+        return join(config.rootDir ?? '.', config.snippetsDir ?? 'snippets');
     }
 }

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

@@ -0,0 +1,7 @@
+import { LoopressCommand } from './base.js';
+export declare abstract class PushCommand extends LoopressCommand {
+    protected dryRun: boolean;
+    catch(err: Error): Promise<void>;
+    protected recordDeployment(status: 'failure' | 'success'): Promise<void>;
+    protected recordSuccess(): Promise<void>;
+}

package/dist/lib/push-command.js

@@ -0,0 +1,32 @@
+import got from 'got';
+import { authManager } from '../config/auth.manager.js';
+import { LoopressCommand } from './base.js';
+const API_URL = process.env.LPS_API_URL ?? 'https://api.loopress.dev';
+export class PushCommand extends LoopressCommand {
+    dryRun = false;
+    async catch(err) {
+        if (!this.dryRun && this.siteConfig) {
+            await this.recordDeployment('failure');
+        }
+        return super.catch(err);
+    }
+    async recordDeployment(status) {
+        const token = process.env.LPS_TOKEN ?? authManager.getAuth()?.token ?? null;
+        if (!token)
+            return;
+        try {
+            await got.post(`${API_URL}/deployments`, {
+                headers: { Authorization: `Bearer ${token}` },
+                json: { status, url: this.siteConfig.url },
+                timeout: { request: 3000 },
+            });
+        }
+        catch {
+            // non-blocking: recording must never interrupt the push flow
+        }
+    }
+    async recordSuccess() {
+        if (!this.dryRun)
+            await this.recordDeployment('success');
+    }
+}

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,9 @@
 export interface LoopressLocalConfig {
+    plugins?: Record<string, string>;
+    projectId?: string;
     rootDir?: string;
-    snippets?: string;
-    styles?: string;
+    snippetPlugin?: 'code-snippets' | 'wpcode';
+    snippetsDir?: 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 };
+}

package/dist/utils/snippet-plugin.js

@@ -31,7 +31,7 @@ class CodeSnippetsPlugin {
     }
     toPayload(name, code, path) {
         return {
-            code,
+            code: code.replace(/^<\?php\s*/i, ''),
             desc: `Imported from ${path}`,
             name,
             tags: ['cli-import'],