@wordpress-flow/cli 1.1.1 → 1.1.3

package/dist/index.js

@@ -85232,7 +85232,7 @@ class DatabaseClient {
       if (post.tags) {
         await this.updatePostTerms(id, post.tags, "post_tag");
       }
-      logger.success(`Post ${id} updated successfully in database`);
+      logger.debug(`Post ${id} updated in database`);
       const updatedPost = await this.getPost(id);
       if (!updatedPost) {
         throw new Error(`Failed to retrieve updated post ${id}`);
@@ -112942,11 +112942,9 @@ class OfficialMDXRenderer {
   createComponents() {
     const components = {};
     for (const [name2, component] of this.componentMap.entries()) {
-      logger.info(`[DEBUG] Processing component: ${name2}, type: ${typeof component}`);
       const parts = name2.split(".");
       const componentName = parts.length === 2 ? parts[1] : name2;
       components[componentName] = component;
-      logger.info(`[DEBUG] Added component: ${componentName} (from ${name2})`);
     }
     return components;
   }
@@ -112966,26 +112964,66 @@ class OfficialMDXRenderer {
       }
       logger.debug("React tree created successfully, starting SSR rendering...");
       let html5;
+      const originalConsoleError = console.error;
+      const suppressedWarnings = [];
+      console.error = (...args) => {
+        const msg = args[0]?.toString() || "";
+        if (msg.includes("React.jsx: type is invalid") || msg.includes("Warning:")) {
+          suppressedWarnings.push(msg);
+          return;
+        }
+        originalConsoleError.apply(console, args);
+      };
       try {
         html5 = $renderToString(reactTree);
         logger.debug("React SSR rendering completed successfully");
       } catch (ssrError) {
-        logger.error("React SSR rendering failed:", ssrError);
-        logger.error("SSR Error details:");
-        logger.error(`  Message: ${ssrError.message}`);
-        logger.error(`  Stack: ${ssrError.stack}`);
-        logger.error(`  Component type: ${typeof MDXComponent}`);
-        logger.error(`  Has components: ${!!components}`);
-        logger.error(`  Component keys: ${Object.keys(components).join(", ")}`);
-        throw new Error(`React SSR failed: ${ssrError.message}`);
+        const errorMsg = ssrError.message;
+        if (errorMsg.includes("Element type is invalid") && errorMsg.includes("undefined")) {
+          const availableComponents = Object.keys(components);
+          const helpMsg = this.createUndefinedComponentError(mdxContent, availableComponents, suppressedWarnings);
+          throw new Error(helpMsg);
+        }
+        throw new Error(`SSR render failed: ${errorMsg}`);
+      } finally {
+        console.error = originalConsoleError;
       }
       logger.debug(`Official MDX rendering completed, HTML length: ${html5.length}`);
       return html5;
     } catch (error) {
-      logger.error("Failed to render MDX to HTML:", error);
-      throw new Error(`MDX to HTML conversion failed: ${error.message}`);
+      const msg = error.message;
+      if (msg.startsWith("Missing component") || msg.startsWith("A component returned") || msg.startsWith("SSR render failed")) {
+        throw error;
+      }
+      throw new Error(`MDX render failed: ${msg}`);
     }
   }
+  createUndefinedComponentError(mdxContent, availableComponents, suppressedWarnings = []) {
+    for (const warning of suppressedWarnings) {
+      if (warning.includes("Check the render method of")) {
+        const match3 = warning.match(/Check the render method of `(\w+)`/);
+        if (match3) {
+          return `Component "${match3[1]}" uses an undefined component. Check its imports and child components.`;
+        }
+      }
+    }
+    const componentPattern = /<([A-Z][a-zA-Z0-9]*)/g;
+    const usedComponents = new Set;
+    let match2;
+    while ((match2 = componentPattern.exec(mdxContent)) !== null) {
+      usedComponents.add(match2[1]);
+    }
+    const missingComponents = [];
+    for (const comp of usedComponents) {
+      if (!availableComponents.includes(comp)) {
+        missingComponents.push(comp);
+      }
+    }
+    if (missingComponents.length > 0) {
+      return `Missing component(s): ${missingComponents.join(", ")}. Not built or not exported.`;
+    }
+    return `A block component uses an undefined import. Check that all imports in your block files exist and are exported correctly.`;
+  }
   postProcessHTML(html5) {
     return html5.replace(/<wp-block-comment[^>]*>([\s\S]*?)<\/wp-block-comment>/g, "$1");
   }
@@ -112997,8 +113035,7 @@ class OfficialMDXRenderer {
       logger.debug("Official MDX to Gutenberg conversion completed");
       return cleanHTML;
     } catch (error) {
-      logger.error("Failed to convert MDX to Gutenberg:", error);
-      throw new Error(`MDX to Gutenberg conversion failed: ${error.message}`);
+      throw error;
     }
   }
 }
@@ -113032,14 +113069,7 @@ class BlockRenderer {
       logger.debug("MDX content to HTML rendering completed");
       return html5;
     } catch (error) {
-      logger.error("Failed to render MDX content to HTML:", error);
-      logger.error("Error message:", error.message);
-      logger.error("Error name:", error.name);
-      if (error.stack) {
-        logger.error("Error stack trace:");
-        console.error(error.stack);
-      }
-      throw new Error(`Official MDX rendering failed: ${error.message}`);
+      throw error;
     }
   }
 }
@@ -113377,6 +113407,67 @@ class PushCommand {
     }
     return result2;
   }
+  async executeQuiet(options) {
+    try {
+      await this.blockRegistry.loadBuiltBlocks();
+    } catch {}
+    const config2 = this.configManager.getConfig();
+    const connection = await this.connectionManager.createConnection(config2.wordpress);
+    const result2 = {
+      success: false,
+      operation: {
+        type: "push",
+        source: {
+          type: "local",
+          identifier: "multiple",
+          lastModified: new Date
+        },
+        target: {
+          type: "wordpress",
+          identifier: config2.wordpress.wordpressUrl,
+          lastModified: new Date
+        },
+        timestamp: new Date,
+        status: "in-progress"
+      },
+      filesProcessed: 0,
+      errors: [],
+      conflicts: []
+    };
+    try {
+      const mdxFiles = await this.findMDXFiles(options.files, config2.paths.mdxOutputDir);
+      if (mdxFiles.length === 0) {
+        result2.operation.status = "completed";
+        result2.success = true;
+        return result2;
+      }
+      for (const filePath2 of mdxFiles) {
+        try {
+          await this.processFileQuiet(filePath2, options, connection, result2);
+          result2.filesProcessed++;
+        } catch (error) {
+          result2.errors.push({
+            source: filePath2,
+            error: error.message,
+            recoverable: true
+          });
+        }
+      }
+      result2.operation.status = "completed";
+      result2.success = result2.errors.length === 0 || result2.errors.every((e) => e.recoverable);
+    } catch (error) {
+      result2.operation.status = "failed";
+      result2.errors.push({
+        source: "Push operation",
+        error: error.message,
+        recoverable: false
+      });
+      throw error;
+    } finally {
+      await this.connectionManager.closeConnection();
+    }
+    return result2;
+  }
   async findMDXFiles(specifiedFiles, baseDir) {
     if (specifiedFiles && specifiedFiles.length > 0) {
       return specifiedFiles.map((file) => path6.resolve(file));
@@ -113436,12 +113527,48 @@ ${"=".repeat(80)}`);
     if (isUpdate) {
       updatedPost = await connection.updatePost(mdxFile.frontmatter.postId, postData);
       logger.debug(`Updated post: ${updatedPost.title.rendered} (ID: ${updatedPost.id})`);
+      await this.updateMDXAfterPush(filePath2, updatedPost);
     } else {
       updatedPost = await connection.createPost(postData);
       logger.info(`Created new post: ${updatedPost.title.rendered} (ID: ${updatedPost.id})`);
-      await this.updateMDXWithPostId(filePath2, updatedPost.id);
+      await this.updateMDXAfterPush(filePath2, updatedPost);
     }
   }
+  async processFileQuiet(filePath2, options, connection, result2) {
+    const mdxFile = await this.parseFile(filePath2);
+    const isUpdate = !!mdxFile.frontmatter.postId;
+    if (isUpdate && !options.force) {
+      const conflict = await this.checkForConflicts(mdxFile, connection);
+      if (conflict) {
+        result2.conflicts.push(conflict);
+        return;
+      }
+    }
+    if (options.dryRun) {
+      return;
+    }
+    const htmlContent = await this.getBlockRenderer().renderMDXContentToHTML(mdxFile.content);
+    const pathParts = filePath2.split(path6.sep);
+    const postType = pathParts[pathParts.length - 2];
+    const postData = {
+      title: { raw: mdxFile.frontmatter.title },
+      content: { raw: htmlContent },
+      excerpt: mdxFile.frontmatter.excerpt ? { raw: mdxFile.frontmatter.excerpt } : undefined,
+      status: mdxFile.frontmatter.status,
+      type: postType,
+      slug: mdxFile.frontmatter.slug,
+      categories: mdxFile.frontmatter.categories,
+      tags: mdxFile.frontmatter.tags,
+      meta: mdxFile.frontmatter.meta
+    };
+    let updatedPost;
+    if (isUpdate) {
+      updatedPost = await connection.updatePost(mdxFile.frontmatter.postId, postData);
+    } else {
+      updatedPost = await connection.createPost(postData);
+    }
+    await this.updateMDXAfterPush(filePath2, updatedPost);
+  }
   async checkForConflicts(mdxFile, connection) {
     if (!mdxFile.frontmatter.postId) {
       return null;
@@ -113458,15 +113585,18 @@ ${"=".repeat(80)}`);
         };
       }
       const wpModified = new Date(wpPost.modified);
-      const localModified = mdxFile.frontmatter.modified ? new Date(mdxFile.frontmatter.modified) : new Date;
-      if (wpModified > localModified) {
-        return {
-          postId: mdxFile.frontmatter.postId,
-          localPath: mdxFile.path,
-          wordpressPost: wpPost,
-          localFile: mdxFile,
-          conflictType: "wordpress-newer"
-        };
+      const lastPushed = mdxFile.frontmatter.lastPushed ? new Date(mdxFile.frontmatter.lastPushed) : null;
+      if (lastPushed && wpModified > lastPushed) {
+        const tolerance = 5000;
+        if (wpModified.getTime() - lastPushed.getTime() > tolerance) {
+          return {
+            postId: mdxFile.frontmatter.postId,
+            localPath: mdxFile.path,
+            wordpressPost: wpPost,
+            localFile: mdxFile,
+            conflictType: "wordpress-newer"
+          };
+        }
       }
       return null;
     } catch (error) {
@@ -113490,22 +113620,43 @@ ${"=".repeat(80)}`);
       }
     }
   }
-  async updateMDXWithPostId(filePath2, postId) {
+  async updateMDXAfterPush(filePath2, wpPost) {
     try {
       const content4 = fs5.readFileSync(filePath2, "utf8");
       const frontmatterMatch = content4.match(/^---\n([\s\S]*?)\n---/);
-      if (frontmatterMatch) {
-        const frontmatter = frontmatterMatch[1];
-        const updatedFrontmatter = frontmatter.includes("postId:") ? frontmatter.replace(/postId:\s*\d*/, `postId: ${postId}`) : `${frontmatter}
+      if (!frontmatterMatch) {
+        logger.warn(`Could not find frontmatter in ${filePath2}`);
+        return;
+      }
+      let frontmatter = frontmatterMatch[1];
+      const postId = wpPost.id;
+      const modified = wpPost.modified || new Date().toISOString();
+      const lastPushed = new Date().toISOString();
+      if (frontmatter.includes("postId:")) {
+        frontmatter = frontmatter.replace(/postId:\s*\d*/, `postId: ${postId}`);
+      } else {
+        frontmatter = `${frontmatter}
 postId: ${postId}`;
-        const updatedContent = content4.replace(/^---\n([\s\S]*?)\n---/, `---
-${updatedFrontmatter}
----`);
-        fs5.writeFileSync(filePath2, updatedContent, "utf8");
-        logger.debug(`Updated ${filePath2} with post ID: ${postId}`);
       }
+      if (frontmatter.includes("modified:")) {
+        frontmatter = frontmatter.replace(/modified:\s*"[^"]*"/, `modified: "${modified}"`);
+      } else {
+        frontmatter = `${frontmatter}
+modified: "${modified}"`;
+      }
+      if (frontmatter.includes("lastPushed:")) {
+        frontmatter = frontmatter.replace(/lastPushed:\s*"[^"]*"/, `lastPushed: "${lastPushed}"`);
+      } else {
+        frontmatter = `${frontmatter}
+lastPushed: "${lastPushed}"`;
+      }
+      const updatedContent = content4.replace(/^---\n([\s\S]*?)\n---/, `---
+${frontmatter}
+---`);
+      fs5.writeFileSync(filePath2, updatedContent, "utf8");
+      logger.debug(`Updated ${filePath2} with sync timestamps`);
     } catch (error) {
-      logger.warn(`Failed to update MDX file with post ID: ${error.message}`);
+      logger.warn(`Failed to update MDX file after push: ${error.message}`);
     }
   }
 }
@@ -113896,30 +114047,10 @@ class DevModeUI {
     this.setupEventListeners();
   }
   setupEventListeners() {
-    this.scheduler.on("taskStart", (task) => {
-      this.onTaskStart(task);
-    });
-    this.scheduler.on("taskComplete", (task, success) => {
-      this.onTaskComplete(task, success);
-    });
     this.scheduler.on("queueChange", () => {
       this.scheduleRender();
     });
   }
-  onTaskStart(task) {
-    const icon = this.getTaskIcon(task.type);
-    const name2 = this.formatTaskName(task);
-    logger.info(`${icon} Building: ${name2}`);
-  }
-  onTaskComplete(task, success) {
-    const duration = task.completedAt && task.startedAt ? ((task.completedAt - task.startedAt) / 1000).toFixed(1) : "?";
-    const name2 = this.formatTaskName(task);
-    if (success) {
-      logger.success(`✓ ${name2} (${duration}s)`);
-    } else {
-      logger.error(`✗ ${name2} failed: ${task.error || "Unknown error"}`);
-    }
-  }
   getTaskIcon(type) {
     switch (type) {
       case "block-build":
@@ -114737,6 +114868,7 @@ var $watch = watch;
 // src/dev/dev-mode-orchestrator.ts
 import * as path16 from "path";
 import * as fs14 from "fs";
+import { fileURLToPath as fileURLToPath4 } from "url";
 
 // src/build/block-scanner.ts
 import * as fs7 from "fs";
@@ -115730,8 +115862,15 @@ export {};
     return result2;
   }
   convertSingleAttribute(attr) {
-    const type = attr.type || "any";
     const optional = attr.default !== undefined;
+    if (attr.__tsType) {
+      return {
+        type: attr.__tsType,
+        description: attr.__tsDescription,
+        optional
+      };
+    }
+    const type = attr.type || "any";
     switch (type) {
       case "string":
         return { type: "string", optional };
@@ -115742,21 +115881,11 @@ export {};
       case "array":
         return { type: "any[]", optional };
       case "object":
-        if (this.isMediaObject(attr)) {
-          return {
-            type: "{ id?: number; url: string; alt?: string; width?: number; height?: number }",
-            description: "Media object with image details",
-            optional
-          };
-        }
         return { type: "{ [key: string]: any }", optional };
       default:
         return { type: "any", optional };
     }
   }
-  isMediaObject(attr) {
-    return attr.default && (typeof attr.default === "object" && Object.keys(attr.default).length === 0);
-  }
   async extractBlocksFromDist(distDir) {
     const blocks = [];
     if (!fs12.existsSync(distDir)) {
@@ -115880,7 +116009,7 @@ add_action('enqueue_block_assets', 'wordpress_flow_enqueue_block_scripts');
 // package.json
 var package_default = {
   name: "@wordpress-flow/cli",
-  version: "1.1.1",
+  version: "1.1.3",
   type: "module",
   description: "TypeScript-based WordPress block creation system",
   main: "dist/index.js",
@@ -115932,6 +116061,9 @@ var package_default = {
 };
 
 // src/dev/dev-mode-orchestrator.ts
+var __filename2 = fileURLToPath4(import.meta.url);
+var __dirname2 = path16.dirname(__filename2);
+
 class DevModeOrchestrator {
   configManager;
   connectionManager;
@@ -115960,6 +116092,8 @@ class DevModeOrchestrator {
   scriptsPath;
   blockFilePaths = new Map;
   importToBlock = new Map;
+  ignoredFiles = new Set;
+  ignoreTimeout = 2000;
   constructor(options = {}) {
     this.options = {
       fresh: false,
@@ -116015,7 +116149,7 @@ class DevModeOrchestrator {
     if (config2.build?.webpackConfig) {
       this.webpackConfig = this.configManager.resolvePath(config2.build.webpackConfig);
     } else {
-      this.webpackConfig = path16.join(import.meta.dirname, "..", "..", "webpack.config.cjs");
+      this.webpackConfig = path16.join(__dirname2, "..", "webpack.config.cjs");
     }
     this.scriptsPath = config2.build?.scriptsPath ? this.configManager.resolvePath(config2.build.scriptsPath) : undefined;
     this.contentDir = this.configManager.resolvePath(config2.paths.mdxOutputDir);
@@ -116096,15 +116230,16 @@ class DevModeOrchestrator {
       this.ui.showInitialBuildComplete(blocks.length, blocks.length, 0, Date.now() - startTime);
       return;
     }
+    console.log(`\uD83D\uDCE6 Blocks to build: ${blocksToRebuild.map((b) => b.name).join(", ")}`);
     let successCount = 0;
     let failCount = 0;
     const blockScripts = new Map;
     const results = await this.workerPool.buildAll(blocksToRebuild, (completed, total, blockName, success) => {
       if (success) {
-        logger.success(`✅ Built: ${blockName} [${completed}/${total}]`);
+        console.log(`   ✅ ${blockName} [${completed}/${total}]`);
         successCount++;
       } else {
-        logger.error(`❌ Failed: ${blockName} [${completed}/${total}]`);
+        console.log(`   ❌ ${blockName} failed [${completed}/${total}]`);
         failCount++;
       }
     });
@@ -116212,6 +116347,10 @@ class DevModeOrchestrator {
   }
   handlePageFileEvent(eventType, filePath2) {
     const fullPath = path16.resolve(this.contentDir, filePath2);
+    if (this.ignoredFiles.has(fullPath)) {
+      logger.debug(`Ignoring self-triggered change: ${filePath2}`);
+      return;
+    }
     this.changeQueue.queuePageChange(fullPath, eventType);
     if (eventType === "unlink") {
       this.dependencyTracker.removeFile(fullPath);
@@ -116219,13 +116358,18 @@ class DevModeOrchestrator {
       this.dependencyTracker.updateFileDependencies(fullPath, "page");
     }
   }
+  ignoreFileTemporarily(filePath2) {
+    this.ignoredFiles.add(filePath2);
+    setTimeout(() => {
+      this.ignoredFiles.delete(filePath2);
+    }, this.ignoreTimeout);
+  }
   async rescanBlocks() {
     const blocks = await this.scanBlocks();
     logger.debug(`Re-scanned: ${blocks.length} blocks`);
   }
   async processBatch(batch) {
     const blockNames = Array.from(batch.blocks.keys());
-    this.ui.showBatchStart(blockNames.length, batch.templates.length, batch.pages.length);
     if (batch.deletedBlocks.length > 0) {
       await this.deletionHandler.handleMultipleDeletions(batch.deletedBlocks);
     }
@@ -116260,25 +116404,29 @@ class DevModeOrchestrator {
       const taskId = this.taskScheduler.scheduleBlockBuild(block.name);
       taskIds.push(taskId);
     }
-    const results = await this.workerPool.buildAll(blocksToRebuild);
-    for (const result2 of results) {
-      const taskId = taskIds.find((id) => id.includes(result2.blockName));
+    for (const block of blocksToRebuild) {
+      const taskId = taskIds.find((id) => id.includes(block.name));
+      const startTime = Date.now();
+      process.stdout.write(`\uD83D\uDD28 ${block.name} → `);
+      const results = await this.workerPool.buildAll([block]);
+      const result2 = results[0];
+      const duration = `${((Date.now() - startTime) / 1000).toFixed(1)}s`;
       if (result2.aborted) {
+        console.log(`⏹️ aborted`);
         if (taskId)
           this.taskScheduler.abortTask(taskId);
         continue;
       }
       if (result2.success) {
-        const block = blocksToRebuild.find((b) => b.name === result2.blockName);
-        if (block) {
-          const hash = this.hashManager.calculateSourceHash(block.filePath);
-          this.hashManager.storeHash(block.name, hash);
-        }
+        const hash = this.hashManager.calculateSourceHash(block.filePath);
+        this.hashManager.storeHash(block.name, hash);
         await this.componentRegistry.reloadBlock(result2.blockName);
+        console.log(`✅ (${duration})`);
         if (taskId) {
           this.taskScheduler.completeTask(taskId, true, result2);
         }
       } else {
+        console.log(`❌ ${result2.error || "failed"}`);
         if (taskId) {
           this.taskScheduler.completeTask(taskId, false, null, result2.error);
         }
@@ -116315,15 +116463,27 @@ class DevModeOrchestrator {
       return;
     for (const pagePath of pagePaths) {
       const taskId = this.taskScheduler.schedulePagePush(pagePath, []);
+      const fileName = path16.basename(pagePath);
+      const startTime = Date.now();
+      this.ignoreFileTemporarily(pagePath);
       try {
-        await this.pushCommand.execute({
+        await this.pushCommand.executeQuiet({
           files: [pagePath],
           force: false,
           dryRun: false
         });
+        const duration = ((Date.now() - startTime) / 1000).toFixed(1);
+        console.log(`\uD83D\uDE80 ${fileName} → ✅ (${duration}s)`);
         this.taskScheduler.completeTask(taskId, true);
       } catch (error) {
-        this.taskScheduler.completeTask(taskId, false, null, error.message);
+        const errorMsg = error.message;
+        if (errorMsg.length > 60) {
+          console.log(`\uD83D\uDE80 ${fileName} → ❌`);
+          console.log(`   ${errorMsg}`);
+        } else {
+          console.log(`\uD83D\uDE80 ${fileName} → ❌ ${errorMsg}`);
+        }
+        this.taskScheduler.completeTask(taskId, false, null, errorMsg);
       }
     }
   }
@@ -116400,6 +116560,7 @@ class DevCommand {
 
 // src/commands/build-command.ts
 import * as path21 from "path";
+import { fileURLToPath as fileURLToPath5 } from "url";
 
 // src/build/block-builder.ts
 import * as fs17 from "fs";
@@ -116971,6 +117132,9 @@ class WorkerPool {
 }
 
 // src/commands/build-command.ts
+var __filename3 = fileURLToPath5(import.meta.url);
+var __dirname3 = path21.dirname(__filename3);
+
 class BuildCommand {
   configManager;
   blockScanner;
@@ -116998,7 +117162,7 @@ class BuildCommand {
       } else if (config2.build?.webpackConfig) {
         webpackConfig = this.configManager.resolvePath(config2.build.webpackConfig);
       } else {
-        webpackConfig = path21.join(import.meta.dirname, "..", "webpack.config.cjs");
+        webpackConfig = path21.join(__dirname3, "..", "webpack.config.cjs");
       }
       const scriptsPath = config2.build?.scriptsPath ? this.configManager.resolvePath(config2.build.scriptsPath) : undefined;
       logger.info(`Scanning blocks in: ${blocksDir}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wordpress-flow/cli",
-  "version": "1.1.1",
+  "version": "1.1.3",
   "type": "module",
   "description": "TypeScript-based WordPress block creation system",
   "main": "dist/index.js",