@wordpress-flow/cli 1.1.4 → 1.2.1

package/dist/build/block-build-worker.js

@@ -1837,7 +1837,7 @@ import * as fs from "fs";
 import * as esbuild from "esbuild";
 import { execSync } from "child_process";
 async function buildBlock() {
-  const { block, outputDir, webpackConfigPath, scriptsPath, tempDir } = workerData;
+  const { block, outputDir, scriptsOutputDir, webpackConfigPath, scriptsPath, tempDir } = workerData;
   try {
     fs.mkdirSync(tempDir, { recursive: true });
     const entryPoint = await generateEntryPoint(block, tempDir);
@@ -1845,7 +1845,7 @@ async function buildBlock() {
     fs.mkdirSync(blockOutputDir, { recursive: true });
     let scriptPaths = [];
     if (block.scripts && block.scripts.length > 0 && scriptsPath) {
-      scriptPaths = await buildBlockScripts(block.scripts, scriptsPath, outputDir);
+      scriptPaths = await buildBlockScripts(block.scripts, scriptsPath, scriptsOutputDir);
     }
     await generateBlockJson(block, blockOutputDir, tempDir);
     await generateSSRVersion(block, blockOutputDir);
@@ -1889,8 +1889,7 @@ if (document.readyState === 'loading') {
   fs.writeFileSync(entryPath, entryContent, "utf8");
   return entryPath;
 }
-async function buildBlockScripts(scripts, scriptsPath, outputDir) {
-  const scriptsOutputDir = path.join(path.dirname(outputDir), "scripts");
+async function buildBlockScripts(scripts, scriptsPath, scriptsOutputDir) {
   fs.mkdirSync(scriptsOutputDir, { recursive: true });
   const outputPaths = [];
   for (const script of scripts) {

package/dist/index.js

@@ -80897,13 +80897,33 @@ Conflict Resolution:`));
 // src/config/config-manager.ts
 import * as fs2 from "fs";
 import * as path2 from "path";
+var DEFAULTS = {
+  paths: {
+    theme: "./theme",
+    content: "./content",
+    plugins: "./plugins"
+  },
+  sync: {
+    excludePostTypes: [],
+    includedPostStatuses: ["publish", "draft"]
+  },
+  dev: {
+    port: 8888,
+    databasePort: 3306,
+    phpVersion: "8.2",
+    wordpressVersion: "latest",
+    plugins: []
+  }
+};
 
 class ConfigManager {
   static instance;
   config = null;
+  rawConfig = null;
   configPath;
   configDir;
   envPath;
+  runtimeDatabase = null;
   constructor() {
     this.configPath = path2.join(process.cwd(), "wordpress-flow.config.json");
     this.configDir = path2.dirname(this.configPath);
@@ -80945,24 +80965,147 @@ class ConfigManager {
     if (this.config) {
       return this.config;
     }
-    if (!fs2.existsSync(this.configPath)) {
-      throw new Error(`Configuration file not found at ${this.configPath}. Please run the setup wizard first.`);
+    let rawConfig = {};
+    if (fs2.existsSync(this.configPath)) {
+      try {
+        const configContent = fs2.readFileSync(this.configPath, "utf8");
+        rawConfig = JSON.parse(configContent);
+        if (this.isLegacyConfig(rawConfig)) {
+          rawConfig = this.migrateLegacyConfig(rawConfig);
+        }
+      } catch (error) {
+        throw new Error(`Failed to load configuration: ${error.message}`);
+      }
     }
-    try {
-      const configContent = fs2.readFileSync(this.configPath, "utf8");
-      const config = JSON.parse(configContent);
-      this.config = this.mergeWithEnvCredentials(config);
-      return this.config;
-    } catch (error) {
-      throw new Error(`Failed to load configuration: ${error.message}`);
+    this.rawConfig = rawConfig;
+    this.config = this.resolveConfig(rawConfig);
+    return this.config;
+  }
+  isLegacyConfig(config) {
+    return config.wordpress !== undefined || config.env !== undefined || config.build !== undefined;
+  }
+  migrateLegacyConfig(legacy) {
+    const newConfig = {};
+    if (legacy.env?.themeDir || legacy.paths?.mdxOutputDir || legacy.env?.pluginsDir) {
+      newConfig.paths = {
+        theme: legacy.env?.themeDir || legacy.build?.blocksDir?.replace("/blocks", "") || DEFAULTS.paths.theme,
+        content: legacy.paths?.mdxOutputDir || DEFAULTS.paths.content,
+        plugins: legacy.env?.pluginsDir || DEFAULTS.paths.plugins
+      };
+    }
+    if (legacy.sync?.excludePostTypes || legacy.sync?.includedPostStatuses) {
+      newConfig.sync = {
+        excludePostTypes: legacy.sync?.excludePostTypes,
+        includedPostStatuses: legacy.sync?.includedPostStatuses
+      };
     }
+    if (legacy.env) {
+      newConfig.dev = {
+        port: legacy.env.port,
+        databasePort: legacy.env.databasePort,
+        phpVersion: legacy.env.phpVersion,
+        wordpressVersion: legacy.env.wordpressVersion,
+        plugins: legacy.env.plugins,
+        sqlDump: legacy.env.sqlDump
+      };
+    }
+    return newConfig;
+  }
+  resolveConfig(raw) {
+    const theme = raw.paths?.theme || DEFAULTS.paths.theme;
+    const content2 = raw.paths?.content || DEFAULTS.paths.content;
+    const plugins = raw.paths?.plugins || DEFAULTS.paths.plugins;
+    const dist = `${theme}/dist`;
+    return {
+      paths: {
+        theme,
+        content: content2,
+        plugins,
+        blocks: `${theme}/blocks`,
+        dist,
+        blocksDist: `${dist}/blocks`,
+        scriptsDist: `${dist}/scripts`,
+        scripts: `${theme}/scripts`,
+        templates: `${content2}/templates`,
+        templateParts: `${content2}/parts`,
+        templatesOutput: `${theme}/templates`,
+        partsOutput: `${theme}/parts`
+      },
+      sync: {
+        excludePostTypes: raw.sync?.excludePostTypes || DEFAULTS.sync.excludePostTypes,
+        includedPostStatuses: raw.sync?.includedPostStatuses || DEFAULTS.sync.includedPostStatuses
+      },
+      dev: {
+        port: raw.dev?.port || DEFAULTS.dev.port,
+        databasePort: raw.dev?.databasePort || DEFAULTS.dev.databasePort,
+        phpVersion: raw.dev?.phpVersion || DEFAULTS.dev.phpVersion,
+        wordpressVersion: raw.dev?.wordpressVersion || DEFAULTS.dev.wordpressVersion,
+        plugins: raw.dev?.plugins || DEFAULTS.dev.plugins,
+        sqlDump: raw.dev?.sqlDump
+      },
+      database: this.runtimeDatabase || undefined
+    };
   }
   async saveConfig(config) {
-    const publicConfig = this.stripSensitiveData(config);
-    const envVars = this.extractEnvVars(config);
-    fs2.writeFileSync(this.configPath, JSON.stringify(publicConfig, null, 2));
-    await this.updateEnvFile(envVars);
-    this.config = config;
+    const minimalConfig = this.stripDefaults(config);
+    fs2.writeFileSync(this.configPath, JSON.stringify(minimalConfig, null, 2));
+    this.rawConfig = config;
+    this.config = this.resolveConfig(config);
+  }
+  stripDefaults(config) {
+    const result2 = {};
+    if (config.paths) {
+      const paths = {};
+      if (config.paths.theme && config.paths.theme !== DEFAULTS.paths.theme) {
+        paths.theme = config.paths.theme;
+      }
+      if (config.paths.content && config.paths.content !== DEFAULTS.paths.content) {
+        paths.content = config.paths.content;
+      }
+      if (config.paths.plugins && config.paths.plugins !== DEFAULTS.paths.plugins) {
+        paths.plugins = config.paths.plugins;
+      }
+      if (Object.keys(paths).length > 0) {
+        result2.paths = paths;
+      }
+    }
+    if (config.sync) {
+      const sync = {};
+      if (config.sync.excludePostTypes && config.sync.excludePostTypes.length > 0) {
+        sync.excludePostTypes = config.sync.excludePostTypes;
+      }
+      if (config.sync.includedPostStatuses && JSON.stringify(config.sync.includedPostStatuses) !== JSON.stringify(DEFAULTS.sync.includedPostStatuses)) {
+        sync.includedPostStatuses = config.sync.includedPostStatuses;
+      }
+      if (Object.keys(sync).length > 0) {
+        result2.sync = sync;
+      }
+    }
+    if (config.dev) {
+      const dev = {};
+      if (config.dev.port && config.dev.port !== DEFAULTS.dev.port) {
+        dev.port = config.dev.port;
+      }
+      if (config.dev.databasePort && config.dev.databasePort !== DEFAULTS.dev.databasePort) {
+        dev.databasePort = config.dev.databasePort;
+      }
+      if (config.dev.phpVersion && config.dev.phpVersion !== DEFAULTS.dev.phpVersion) {
+        dev.phpVersion = config.dev.phpVersion;
+      }
+      if (config.dev.wordpressVersion && config.dev.wordpressVersion !== DEFAULTS.dev.wordpressVersion) {
+        dev.wordpressVersion = config.dev.wordpressVersion;
+      }
+      if (config.dev.plugins && config.dev.plugins.length > 0) {
+        dev.plugins = config.dev.plugins;
+      }
+      if (config.dev.sqlDump) {
+        dev.sqlDump = config.dev.sqlDump;
+      }
+      if (Object.keys(dev).length > 0) {
+        result2.dev = dev;
+      }
+    }
+    return result2;
   }
   getConfig() {
     if (!this.config) {
@@ -80973,11 +81116,18 @@ class ConfigManager {
   hasConfig() {
     return fs2.existsSync(this.configPath);
   }
-  getWordPressConfig() {
-    return this.getConfig().wordpress;
+  setDatabaseConnection(connection) {
+    this.runtimeDatabase = connection;
+    if (this.config) {
+      this.config.database = connection;
+    }
   }
-  getSyncPaths() {
-    return this.getConfig().paths;
+  getDatabaseConnection() {
+    return this.config?.database;
+  }
+  getWordPressUrl() {
+    const port = this.config?.dev.port || DEFAULTS.dev.port;
+    return `http://localhost:${port}`;
   }
   resolvePath(relativePath) {
     if (path2.isAbsolute(relativePath)) {
@@ -80988,60 +81138,70 @@ class ConfigManager {
   getConfigDir() {
     return this.configDir;
   }
-  mergeWithEnvCredentials(config) {
-    const mergedConfig = { ...config };
-    if (mergedConfig.wordpress.type === "rest-api") {
-      const password = process.env.WP_APPLICATION_PASSWORD;
-      if (password && password !== "undefined") {
-        mergedConfig.wordpress.applicationPassword = password;
-      }
-    } else if (mergedConfig.wordpress.type === "database") {
-      const password = process.env.DB_PASSWORD;
-      if (password && password !== "undefined") {
-        mergedConfig.wordpress.database.password = password;
+  getLegacyConfig() {
+    const config = this.getConfig();
+    const dbConnection = config.database || {
+      host: "127.0.0.1",
+      port: config.dev.databasePort,
+      database: "wordpress",
+      username: "wordpress",
+      password: "wordpress"
+    };
+    return {
+      wordpress: {
+        type: "database",
+        wordpressUrl: this.getWordPressUrl(),
+        syncPath: config.paths.content,
+        postTypes: ["post", "page"],
+        database: dbConnection
+      },
+      paths: {
+        mdxOutputDir: config.paths.content,
+        postTypeMappings: {
+          post: `${config.paths.content}/post`,
+          page: `${config.paths.content}/page`
+        }
+      },
+      sync: {
+        watchForChanges: true,
+        conflictResolution: "manual",
+        excludePostTypes: config.sync.excludePostTypes,
+        includedPostStatuses: config.sync.includedPostStatuses
+      },
+      build: {
+        blocksDir: config.paths.blocks,
+        outputDir: config.paths.dist,
+        scriptsPath: config.paths.scripts
+      },
+      templates: {
+        templatesDir: config.paths.templates,
+        outputDir: config.paths.templatesOutput
+      },
+      templateParts: {
+        partsDir: config.paths.templateParts,
+        outputDir: config.paths.partsOutput
+      },
+      env: {
+        port: config.dev.port,
+        databasePort: config.dev.databasePort,
+        phpVersion: config.dev.phpVersion,
+        wordpressVersion: config.dev.wordpressVersion,
+        themeDir: config.paths.theme,
+        pluginsDir: config.paths.plugins,
+        plugins: config.dev.plugins,
+        sqlDump: config.dev.sqlDump,
+        volumes: {
+          database: true,
+          uploads: true
+        }
       }
-    }
-    return mergedConfig;
-  }
-  stripSensitiveData(config) {
-    const strippedConfig = JSON.parse(JSON.stringify(config));
-    if (strippedConfig.wordpress.type === "rest-api") {
-      delete strippedConfig.wordpress.applicationPassword;
-    } else if (strippedConfig.wordpress.type === "database") {
-      delete strippedConfig.wordpress.database.password;
-    }
-    return strippedConfig;
+    };
   }
-  extractEnvVars(config) {
-    const envVars = {};
-    if (config.wordpress.type === "rest-api") {
-      envVars.WP_APPLICATION_PASSWORD = config.wordpress.applicationPassword;
-    } else if (config.wordpress.type === "database") {
-      envVars.DB_PASSWORD = config.wordpress.database.password;
-    }
-    return envVars;
+  getWordPressConfig() {
+    return this.getLegacyConfig().wordpress;
   }
-  async updateEnvFile(newVars) {
-    let envContent = "";
-    if (fs2.existsSync(this.envPath)) {
-      envContent = fs2.readFileSync(this.envPath, "utf8");
-    }
-    const existingVars = {};
-    envContent.split(`
-`).forEach((line) => {
-      const trimmed = line.trim();
-      if (trimmed && !trimmed.startsWith("#")) {
-        const [key, ...valueParts] = trimmed.split("=");
-        if (key && valueParts.length > 0) {
-          existingVars[key.trim()] = valueParts.join("=");
-        }
-      }
-    });
-    const mergedVars = { ...existingVars, ...newVars };
-    const newEnvContent = Object.entries(mergedVars).map(([key, value]) => `${key}=${value}`).join(`
-`) + `
-`;
-    fs2.writeFileSync(this.envPath, newEnvContent);
+  getSyncPaths() {
+    return this.getLegacyConfig().paths;
   }
 }
 // src/config/logger.ts
@@ -84776,8 +84936,7 @@ class DatabaseClient {
       const perPage = params.per_page || 100;
       const page = params.page || 1;
       const offset = (page - 1) * perPage;
-      query += " LIMIT ? OFFSET ?";
-      queryParams.push(perPage, offset);
+      query += ` LIMIT ${Number(perPage)} OFFSET ${Number(offset)}`;
       logger.debug(`Executing query: ${query}`);
       logger.debug(`Query parameters: ${JSON.stringify(queryParams)}`);
       const [rows] = await this.connection.execute(query, queryParams);
@@ -85636,7 +85795,8 @@ class PullCommand {
   async execute(options) {
     logger.progress("Starting pull operation...");
     const config = this.configManager.getConfig();
-    const connection = await this.connectionManager.createConnection(config.wordpress);
+    const legacyConfig = this.configManager.getLegacyConfig();
+    const connection = await this.connectionManager.createConnection(legacyConfig.wordpress);
     const result2 = {
       success: false,
       operation: {
@@ -85648,7 +85808,7 @@ class PullCommand {
         },
         target: {
           type: "local",
-          identifier: options.outputDir || config.paths.mdxOutputDir,
+          identifier: options.outputDir || config.paths.content,
           lastModified: new Date
         },
         timestamp: new Date,
@@ -85658,8 +85818,8 @@ class PullCommand {
       errors: []
     };
     try {
-      const postTypes = options.postTypes || config.wordpress.postTypes || ["post", "page"];
-      const outputDir = options.outputDir || config.paths.mdxOutputDir;
+      const postTypes = options.postTypes || ["post", "page"];
+      const outputDir = options.outputDir || config.paths.content;
       fs3.mkdirSync(outputDir, { recursive: true });
       let totalProcessed = 0;
       for (const postType of postTypes) {
@@ -85734,13 +85894,7 @@ class PullCommand {
       title: post.title.rendered,
       slug: post.slug,
       postId: post.id,
-      status: post.status,
-      date: new Date(post.date).toISOString(),
-      modified: new Date(post.modified).toISOString(),
-      excerpt: post.excerpt.rendered || "",
-      categories: post.categories || [],
-      tags: post.tags || [],
-      meta: post.meta || {}
+      status: post.status
     };
     const mdxContent = this.generateMDX(blocks, frontmatter);
     fs3.writeFileSync(filePath2, mdxContent, "utf8");
@@ -112907,7 +113061,7 @@ class PushCommand {
       this.blockRegistry = blockRegistry;
     } else {
       const config = this.configManager.getConfig();
-      const buildOutputDir = this.configManager.resolvePath(config.build?.outputDir || "./theme/dist");
+      const buildOutputDir = this.configManager.resolvePath(config.paths.dist);
       this.blockRegistry = new BlockRegistry(buildOutputDir);
     }
   }
@@ -112985,7 +113139,8 @@ class PushCommand {
       logger.warn("Continuing with basic block rendering...");
     }
     const config = this.configManager.getConfig();
-    const connection = await this.connectionManager.createConnection(config.wordpress);
+    const legacyConfig = this.configManager.getLegacyConfig();
+    const connection = await this.connectionManager.createConnection(legacyConfig.wordpress);
     const result2 = {
       success: false,
       operation: {
@@ -112997,7 +113152,7 @@ class PushCommand {
         },
         target: {
           type: "wordpress",
-          identifier: config.wordpress.wordpressUrl,
+          identifier: this.configManager.getWordPressUrl(),
           lastModified: new Date
         },
         timestamp: new Date,
@@ -113008,7 +113163,7 @@ class PushCommand {
       conflicts: []
     };
     try {
-      const mdxFiles = await this.findMDXFiles(options.files, config.paths.mdxOutputDir);
+      const mdxFiles = await this.findMDXFiles(options.files, config.paths.content);
       if (mdxFiles.length === 0) {
         logger.warn("No MDX files found to push");
         result2.operation.status = "completed";
@@ -113067,11 +113222,12 @@ class PushCommand {
       await this.blockRegistry.loadBuiltBlocks();
     } catch {}
     const config = this.configManager.getConfig();
+    const legacyConfig = this.configManager.getLegacyConfig();
     let connection;
     if (this.connectionManager.hasConnection()) {
       connection = this.connectionManager.getConnection();
     } else {
-      connection = await this.connectionManager.createConnection(config.wordpress);
+      connection = await this.connectionManager.createConnection(legacyConfig.wordpress);
     }
     const result2 = {
       success: false,
@@ -113084,7 +113240,7 @@ class PushCommand {
         },
         target: {
           type: "wordpress",
-          identifier: config.wordpress.wordpressUrl,
+          identifier: this.configManager.getWordPressUrl(),
           lastModified: new Date
         },
         timestamp: new Date,
@@ -113095,7 +113251,7 @@ class PushCommand {
       conflicts: []
     };
     try {
-      const mdxFiles = await this.findMDXFiles(options.files, config.paths.mdxOutputDir);
+      const mdxFiles = await this.findMDXFiles(options.files, config.paths.content);
       if (mdxFiles.length === 0) {
         result2.operation.status = "completed";
         result2.success = true;
@@ -113242,20 +113398,6 @@ ${"=".repeat(80)}`);
           conflictType: "missing-source"
         };
       }
-      const wpModified = new Date(wpPost.modified);
-      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) {
       logger.warn(`Could not check for conflicts on post ${mdxFile.frontmatter.postId}: ${error.message}`);
@@ -113288,31 +113430,15 @@ ${"=".repeat(80)}`);
       }
       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 {
+      if (!frontmatter.includes("postId:")) {
         frontmatter = `${frontmatter}
 postId: ${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---/, `---
+        const updatedContent = content4.replace(/^---\n([\s\S]*?)\n---/, `---
 ${frontmatter}
 ---`);
-      fs5.writeFileSync(filePath2, updatedContent, "utf8");
-      logger.debug(`Updated ${filePath2} with sync timestamps`);
+        fs5.writeFileSync(filePath2, updatedContent, "utf8");
+        logger.debug(`Added postId to ${filePath2}`);
+      }
     } catch (error) {
       logger.warn(`Failed to update MDX file after push: ${error.message}`);
     }
@@ -115799,20 +115925,7 @@ class DockerEnvManager {
   constructor(options) {
     this.projectName = this.sanitizeProjectName(options.projectName);
     this.workspaceDir = options.workspaceDir;
-    this.config = {
-      port: options.config.port ?? 8888,
-      databasePort: options.config.databasePort,
-      phpVersion: options.config.phpVersion ?? "8.2",
-      wordpressVersion: options.config.wordpressVersion ?? "latest",
-      themeDir: options.config.themeDir ?? "./theme",
-      pluginsDir: options.config.pluginsDir,
-      plugins: options.config.plugins ?? [],
-      sqlDump: options.config.sqlDump ?? "",
-      volumes: {
-        database: options.config.volumes?.database ?? true,
-        uploads: options.config.volumes?.uploads ?? true
-      }
-    };
+    this.config = options.config;
     this.containerNames = {
       wordpress: `${this.projectName}-wordpress`,
       mysql: `${this.projectName}-mysql`
@@ -115872,7 +115985,7 @@ class DockerEnvManager {
       logger.info("\uD83D\uDC33 Docker containers already running");
     }
     await this.waitForWordPress();
-    const wordpressUrl = `http://localhost:${this.config.port}`;
+    const wordpressUrl = this.getWordPressUrl();
     return { wordpressUrl, isFirstRun };
   }
   async createContainers() {
@@ -115881,31 +115994,29 @@ class DockerEnvManager {
         stdio: "pipe"
       });
     } catch {}
-    const themeDir = path16.resolve(this.workspaceDir, this.config.themeDir);
+    const themeDir = path16.resolve(this.workspaceDir, this.config.paths.theme);
     const themeName = path16.basename(themeDir);
     logger.info("  Starting MySQL...");
-    const mysqlVolume = this.config.volumes.database ? `-v ${this.projectName}-mysql-data:/var/lib/mysql` : "";
-    const mysqlPort = this.config.databasePort ? `-p ${this.config.databasePort}:3306` : "";
+    const mysqlVolume = `-v ${this.projectName}-mysql-data:/var/lib/mysql`;
+    const mysqlPort = this.config.dev.databasePort ? `-p ${this.config.dev.databasePort}:3306` : "";
     execSync(`docker run -d         --name ${this.containerNames.mysql}         --network ${this.projectName}-network         ${mysqlVolume}         ${mysqlPort}         -e MYSQL_ROOT_PASSWORD=password         -e MYSQL_DATABASE=wordpress         -e MYSQL_USER=wordpress         -e MYSQL_PASSWORD=wordpress         mysql:8.0`, { stdio: "pipe" });
     await this.waitForMySQL();
     logger.info("  Starting WordPress...");
-    const uploadsVolume = this.config.volumes.uploads ? `-v ${this.projectName}-uploads:/var/www/html/wp-content/uploads` : "";
+    const uploadsVolume = `-v ${this.projectName}-uploads:/var/www/html/wp-content/uploads`;
     let pluginMounts = "";
-    if (this.config.pluginsDir) {
-      const pluginsDir = path16.resolve(this.workspaceDir, this.config.pluginsDir);
-      if (fs14.existsSync(pluginsDir)) {
-        const pluginFolders = fs14.readdirSync(pluginsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
-        for (const pluginName of pluginFolders) {
-          const pluginPath = path16.join(pluginsDir, pluginName);
-          pluginMounts += ` -v "${pluginPath}:/var/www/html/wp-content/plugins/${pluginName}"`;
-        }
-        if (pluginFolders.length > 0) {
-          logger.info(`  Mounting ${pluginFolders.length} local plugin(s): ${pluginFolders.join(", ")}`);
-        }
+    const pluginsDir = path16.resolve(this.workspaceDir, this.config.paths.plugins);
+    if (fs14.existsSync(pluginsDir)) {
+      const pluginFolders = fs14.readdirSync(pluginsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+      for (const pluginName of pluginFolders) {
+        const pluginPath = path16.join(pluginsDir, pluginName);
+        pluginMounts += ` -v "${pluginPath}:/var/www/html/wp-content/plugins/${pluginName}"`;
+      }
+      if (pluginFolders.length > 0) {
+        logger.info(`  Mounting ${pluginFolders.length} local plugin(s): ${pluginFolders.join(", ")}`);
       }
     }
-    const wpImage = this.config.wordpressVersion === "latest" ? `wordpress:php${this.config.phpVersion}` : `wordpress:${this.config.wordpressVersion}-php${this.config.phpVersion}`;
-    execSync(`docker run -d         --name ${this.containerNames.wordpress}         --network ${this.projectName}-network         -p ${this.config.port}:80         -v "${themeDir}:/var/www/html/wp-content/themes/${themeName}"         ${pluginMounts}         ${uploadsVolume}         -e WORDPRESS_DB_HOST=${this.containerNames.mysql}         -e WORDPRESS_DB_USER=wordpress         -e WORDPRESS_DB_PASSWORD=wordpress         -e WORDPRESS_DB_NAME=wordpress         ${wpImage}`, { stdio: "pipe" });
+    const wpImage = this.config.dev.wordpressVersion === "latest" ? `wordpress:php${this.config.dev.phpVersion}` : `wordpress:${this.config.dev.wordpressVersion}-php${this.config.dev.phpVersion}`;
+    execSync(`docker run -d         --name ${this.containerNames.wordpress}         --network ${this.projectName}-network         -p ${this.config.dev.port}:80         -v "${themeDir}:/var/www/html/wp-content/themes/${themeName}"         ${pluginMounts}         ${uploadsVolume}         -e WORDPRESS_DB_HOST=${this.containerNames.mysql}         -e WORDPRESS_DB_USER=wordpress         -e WORDPRESS_DB_PASSWORD=wordpress         -e WORDPRESS_DB_NAME=wordpress         ${wpImage}`, { stdio: "pipe" });
   }
   async startContainers() {
     execSync(`docker start ${this.containerNames.mysql}`, { stdio: "pipe" });
@@ -115959,7 +116070,7 @@ class DockerEnvManager {
     logger.info("  Waiting for WordPress...");
     while (attempts < maxAttempts) {
       try {
-        const response = execSync(`curl -s -o /dev/null -w "%{http_code}" http://localhost:${this.config.port}`, { encoding: "utf8", stdio: "pipe" }).trim();
+        const response = execSync(`curl -s -o /dev/null -w "%{http_code}" http://localhost:${this.config.dev.port}`, { encoding: "utf8", stdio: "pipe" }).trim();
         if (response.length > 0) {
           return;
         }
@@ -115998,8 +116109,8 @@ class DockerEnvManager {
   }
   async installWordPress() {
     logger.info("  Installing WordPress...");
-    const siteUrl = `http://localhost:${this.config.port}`;
-    const themeName = path16.basename(path16.resolve(this.workspaceDir, this.config.themeDir));
+    const siteUrl = this.getWordPressUrl();
+    const themeName = path16.basename(path16.resolve(this.workspaceDir, this.config.paths.theme));
     execSync(`docker exec ${this.containerNames.wordpress} wp core install         --url="${siteUrl}"         --title="Development Site"         --admin_user=admin         --admin_password=password         --admin_email=admin@example.com         --skip-email         --allow-root`, { stdio: "pipe" });
     logger.info(`  Activating theme: ${themeName}...`);
     try {
@@ -116010,10 +116121,10 @@ class DockerEnvManager {
     execSync(`docker exec ${this.containerNames.wordpress} wp rewrite structure '/%postname%/' --allow-root`, { stdio: "pipe" });
   }
   async installPlugins() {
-    if (this.config.plugins.length === 0)
+    if (this.config.dev.plugins.length === 0)
       return;
     logger.info("  Installing plugins...");
-    for (const plugin of this.config.plugins) {
+    for (const plugin of this.config.dev.plugins) {
       try {
         if (plugin.startsWith("./") || plugin.startsWith("/")) {
           const pluginPath = path16.resolve(this.workspaceDir, plugin);
@@ -116030,9 +116141,9 @@ class DockerEnvManager {
     }
   }
   async importSqlDump() {
-    if (!this.config.sqlDump)
+    if (!this.config.dev.sqlDump)
       return;
-    const sqlPath = path16.resolve(this.workspaceDir, this.config.sqlDump);
+    const sqlPath = path16.resolve(this.workspaceDir, this.config.dev.sqlDump);
     if (!fs14.existsSync(sqlPath)) {
       logger.warn(`  SQL dump not found: ${sqlPath}`);
       return;
@@ -116041,7 +116152,7 @@ class DockerEnvManager {
     await this.waitForMySQLReady();
     execSync(`docker cp "${sqlPath}" ${this.containerNames.mysql}:/tmp/dump.sql`, { stdio: "pipe" });
     execSync(`docker exec ${this.containerNames.mysql} sh -c "mysql -h 127.0.0.1 -u wordpress -pwordpress wordpress < /tmp/dump.sql"`, { stdio: "pipe" });
-    const siteUrl = `http://localhost:${this.config.port}`;
+    const siteUrl = this.getWordPressUrl();
     execSync(`docker exec ${this.containerNames.wordpress} wp option update siteurl "${siteUrl}" --allow-root`, { stdio: "pipe" });
     execSync(`docker exec ${this.containerNames.wordpress} wp option update home "${siteUrl}" --allow-root`, { stdio: "pipe" });
     await this.reactivatePlugins();
@@ -116093,14 +116204,12 @@ class DockerEnvManager {
     }
     logger.info("  Importing SQL dump...");
     await this.waitForMySQLReady();
-    execSync(`docker cp "${sqlPath}" ${this.containerNames.mysql}:/tmp/dump.sql`, {
-      stdio: "pipe"
-    });
+    execSync(`docker cp "${sqlPath}" ${this.containerNames.mysql}:/tmp/dump.sql`, { stdio: "pipe" });
     execSync(`docker exec ${this.containerNames.mysql} sh -c "mysql -h 127.0.0.1 -u wordpress -pwordpress wordpress < /tmp/dump.sql"`, { stdio: "pipe" });
     if (!await this.hasWPCLI()) {
       await this.installWPCLI();
     }
-    const siteUrl = `http://localhost:${this.config.port}`;
+    const siteUrl = this.getWordPressUrl();
     try {
       execSync(`docker exec ${this.containerNames.wordpress} wp option update siteurl "${siteUrl}" --allow-root`, { stdio: "pipe" });
       execSync(`docker exec ${this.containerNames.wordpress} wp option update home "${siteUrl}" --allow-root`, { stdio: "pipe" });
@@ -116112,14 +116221,14 @@ class DockerEnvManager {
   getDatabaseConfig() {
     return {
       host: "127.0.0.1",
-      port: this.config.databasePort ?? 3306,
+      port: this.config.dev.databasePort,
       database: "wordpress",
       username: "wordpress",
       password: "wordpress"
     };
   }
   getWordPressUrl() {
-    return `http://localhost:${this.config.port}`;
+    return `http://localhost:${this.config.dev.port}`;
   }
   sleep(ms) {
     return new Promise((resolve6) => setTimeout(resolve6, ms));
@@ -116139,27 +116248,23 @@ class DockerEnvManager {
         stdio: "pipe"
       });
     } catch {}
-    if (this.config.volumes.database) {
-      try {
-        execSync(`docker volume rm ${this.projectName}-mysql-data`, {
-          stdio: "pipe"
-        });
-      } catch {}
-    }
-    if (this.config.volumes.uploads) {
-      try {
-        execSync(`docker volume rm ${this.projectName}-uploads`, {
-          stdio: "pipe"
-        });
-      } catch {}
-    }
+    try {
+      execSync(`docker volume rm ${this.projectName}-mysql-data`, {
+        stdio: "pipe"
+      });
+    } catch {}
+    try {
+      execSync(`docker volume rm ${this.projectName}-uploads`, {
+        stdio: "pipe"
+      });
+    } catch {}
     logger.info("  ✓ Cleanup complete");
   }
 }
 // package.json
 var package_default = {
   name: "@wordpress-flow/cli",
-  version: "1.1.4",
+  version: "1.2.1",
   type: "module",
   description: "TypeScript-based WordPress block creation system",
   main: "dist/index.js",
@@ -116283,7 +116388,7 @@ class DevModeOrchestrator {
       console.log("\uD83D\uDCCB Loading configuration...");
       await this.initializeConfig();
       const config = this.configManager.getConfig();
-      if (config.env && !this.options.skipEnv) {
+      if (!this.options.skipEnv) {
         console.log("\uD83D\uDC33 Setting up Docker environment...");
         await this.startDockerEnvironment();
       }
@@ -116312,8 +116417,6 @@ class DevModeOrchestrator {
   }
   async startDockerEnvironment() {
     const config = this.configManager.getConfig();
-    if (!config.env)
-      return;
     const packageJsonPath = path17.join(this.configManager.getConfigDir(), "package.json");
     let projectName = "wordpress-project";
     if (fs15.existsSync(packageJsonPath)) {
@@ -116325,7 +116428,7 @@ class DevModeOrchestrator {
     this.dockerEnvManager = new DockerEnvManager({
       projectName,
       workspaceDir: this.configManager.getConfigDir(),
-      config: config.env
+      config
     });
     try {
       const { wordpressUrl, isFirstRun } = await this.dockerEnvManager.start();
@@ -116340,10 +116443,12 @@ class DevModeOrchestrator {
         }
         await this.dockerEnvManager.installPlugins();
       }
+      const dbConfig = this.dockerEnvManager.getDatabaseConfig();
+      this.configManager.setDatabaseConnection(dbConfig);
       logger.success(`WordPress running at ${wordpressUrl}`);
       logger.info(`  Admin: ${wordpressUrl}/wp-admin (admin / password)`);
-      if (config.env.databasePort) {
-        logger.info(`  Database: 127.0.0.1:${config.env.databasePort} (wordpress / wordpress)`);
+      if (config.dev.databasePort) {
+        logger.info(`  Database: 127.0.0.1:${config.dev.databasePort} (wordpress / wordpress)`);
       }
     } catch (error) {
       const errorMessage = error.message;
@@ -116355,23 +116460,15 @@ class DevModeOrchestrator {
   }
   async initializeConfig() {
     const config = this.configManager.getConfig();
-    this.blocksDir = this.configManager.resolvePath(config.build?.blocksDir || "./theme/blocks");
-    this.outputDir = this.configManager.resolvePath(config.build?.outputDir || "./theme/dist");
-    if (config.build?.webpackConfig) {
-      this.webpackConfig = this.configManager.resolvePath(config.build.webpackConfig);
-    } else {
-      this.webpackConfig = path17.join(__dirname2, "..", "webpack.config.cjs");
-    }
-    this.scriptsPath = config.build?.scriptsPath ? this.configManager.resolvePath(config.build.scriptsPath) : undefined;
-    this.contentDir = this.configManager.resolvePath(config.paths.mdxOutputDir);
-    if (config.templates) {
-      this.templatesDir = this.configManager.resolvePath(config.templates.templatesDir);
-      this.templatesOutputDir = this.configManager.resolvePath(config.templates.outputDir);
-    }
-    if (config.templateParts) {
-      this.templatePartsDir = this.configManager.resolvePath(config.templateParts.partsDir);
-      this.templatePartsOutputDir = this.configManager.resolvePath(config.templateParts.outputDir);
-    }
+    this.blocksDir = this.configManager.resolvePath(config.paths.blocks);
+    this.outputDir = this.configManager.resolvePath(config.paths.dist);
+    this.webpackConfig = path17.join(__dirname2, "..", "webpack.config.cjs");
+    this.scriptsPath = this.configManager.resolvePath(config.paths.scripts);
+    this.contentDir = this.configManager.resolvePath(config.paths.content);
+    this.templatesDir = this.configManager.resolvePath(config.paths.templates);
+    this.templatesOutputDir = this.configManager.resolvePath(config.paths.templatesOutput);
+    this.templatePartsDir = this.configManager.resolvePath(config.paths.templateParts);
+    this.templatePartsOutputDir = this.configManager.resolvePath(config.paths.partsOutput);
     if (!fs15.existsSync(this.outputDir)) {
       fs15.mkdirSync(this.outputDir, { recursive: true });
     }
@@ -116395,16 +116492,16 @@ class DevModeOrchestrator {
   async connectWordPress() {
     try {
       const config = this.configManager.getConfig();
-      let wpConfig = config.wordpress;
-      if (this.dockerEnvManager && config.env?.databasePort) {
-        const dbConfig = this.dockerEnvManager.getDatabaseConfig();
-        wpConfig = {
-          type: "database",
-          wordpressUrl: `http://localhost:${config.env.port || 8888}`,
-          database: dbConfig
-        };
-        logger.info(`  Using Docker database: ${dbConfig.host}:${dbConfig.port}`);
+      const dbConfig = config.database || this.dockerEnvManager?.getDatabaseConfig();
+      if (!dbConfig) {
+        throw new Error("No database connection available. Make sure Docker environment is running.");
       }
+      const wpConfig = {
+        type: "database",
+        wordpressUrl: this.configManager.getWordPressUrl(),
+        database: dbConfig
+      };
+      logger.info(`  Using database: ${dbConfig.host}:${dbConfig.port}`);
       await this.connectionManager.createConnection(wpConfig);
       this.pushCommand = new PushCommand(this.blockRegistry);
       logger.success("WordPress connection established");
@@ -117516,12 +117613,14 @@ import * as os2 from "os";
 class WorkerPool {
   concurrency;
   outputDir;
+  scriptsOutputDir;
   webpackConfigPath;
   scriptsPath;
   workerPath;
   constructor(options) {
     this.concurrency = options.concurrency ?? Math.max(1, os2.cpus().length - 1);
     this.outputDir = options.outputDir;
+    this.scriptsOutputDir = options.scriptsOutputDir;
     this.webpackConfigPath = options.webpackConfigPath;
     this.scriptsPath = options.scriptsPath;
     this.workerPath = path21.join(import.meta.dirname, "build", "block-build-worker.js");
@@ -117579,6 +117678,7 @@ class WorkerPool {
           scripts: block.scripts
         },
         outputDir: this.outputDir,
+        scriptsOutputDir: this.scriptsOutputDir,
         webpackConfigPath: this.webpackConfigPath,
         scriptsPath: this.scriptsPath,
         tempDir
@@ -117631,17 +117731,15 @@ class BuildCommand {
     logger.progress("Starting build operation...");
     try {
       const config = this.configManager.getConfig();
-      const blocksDir = this.configManager.resolvePath(options.blocksDir || config.build?.blocksDir || "./theme/blocks");
-      const outputDir = this.configManager.resolvePath(options.outputDir || config.build?.outputDir || "./theme/dist");
+      const blocksDir = this.configManager.resolvePath(options.blocksDir || config.paths.blocks);
+      const outputDir = this.configManager.resolvePath(options.outputDir || config.paths.blocksDist);
       let webpackConfig;
       if (options.webpackConfig) {
         webpackConfig = this.configManager.resolvePath(options.webpackConfig);
-      } else if (config.build?.webpackConfig) {
-        webpackConfig = this.configManager.resolvePath(config.build.webpackConfig);
       } else {
         webpackConfig = path22.join(__dirname3, "..", "webpack.config.cjs");
       }
-      const scriptsPath = config.build?.scriptsPath ? this.configManager.resolvePath(config.build.scriptsPath) : undefined;
+      const scriptsPath = this.configManager.resolvePath(config.paths.scripts);
       logger.info(`Scanning blocks in: ${blocksDir}`);
       logger.info(`Output directory: ${outputDir}`);
       if (scriptsPath) {
@@ -117671,9 +117769,11 @@ class BuildCommand {
       } else {
         logger.info(`Found ${blocks.length} block(s): ${blocks.map((b) => b.name).join(", ")}`);
       }
+      const scriptsOutputDir = this.configManager.resolvePath(config.paths.scriptsDist);
       const workerPool = new WorkerPool({
         concurrency: options.concurrency,
         outputDir,
+        scriptsOutputDir,
         webpackConfigPath: webpackConfig,
         scriptsPath
       });
@@ -117688,7 +117788,7 @@ class BuildCommand {
         if (block.scripts && block.scripts.length > 0) {
           const result2 = results.find((r) => r.blockName === block.name);
           if (result2?.success) {
-            const scriptPaths = block.scripts.map((script) => `scripts/${path22.basename(script).replace(/\.ts$/, ".js")}`);
+            const scriptPaths = block.scripts.map((script) => `dist/scripts/${path22.basename(script).replace(/\.ts$/, ".js")}`);
             this.blockScripts.set(block.name, scriptPaths);
           }
         }
@@ -117750,27 +117850,17 @@ class BuildTemplatesCommand {
   async execute(options = {}) {
     logger.progress("Starting template build operation...");
     const config = this.configManager.getConfig();
-    const templatesConfig = config.templates;
-    if (!templatesConfig) {
-      logger.error("Templates configuration not found in wordpress-flow.config.json");
-      logger.info('Add a "templates" section to your config with "templatesDir" and "outputDir"');
-      return;
-    }
-    const templatesDir = options.templatesDir || this.configManager.resolvePath(templatesConfig.templatesDir);
-    const outputDir = options.outputDir || this.configManager.resolvePath(templatesConfig.outputDir);
+    const templatesDir = options.templatesDir || this.configManager.resolvePath(config.paths.templates);
+    const outputDir = options.outputDir || this.configManager.resolvePath(config.paths.templatesOutput);
     if (!fs19.existsSync(templatesDir)) {
       logger.error(`Templates directory not found: ${templatesDir}`);
       return;
     }
     fs19.mkdirSync(outputDir, { recursive: true });
-    const buildConfig = config.build;
-    let blockRegistry;
-    if (buildConfig) {
-      const blocksOutputDir = this.configManager.resolvePath(buildConfig.outputDir);
-      blockRegistry = new BlockRegistry(blocksOutputDir);
-      await blockRegistry.loadBuiltBlocks();
-      logger.info(`Loaded ${blockRegistry.getAllComponentMappings().length} built blocks`);
-    }
+    const blocksOutputDir = this.configManager.resolvePath(config.paths.dist);
+    const blockRegistry = new BlockRegistry(blocksOutputDir);
+    await blockRegistry.loadBuiltBlocks();
+    logger.info(`Loaded ${blockRegistry.getAllComponentMappings().length} built blocks`);
     const renderer = new OfficialMDXRenderer({ blockRegistry });
     renderer.initialize();
     const templateFiles = this.findMDXFiles(templatesDir);
@@ -117841,9 +117931,6 @@ class EnvCommand {
   }
   getDockerEnvManager() {
     const config = this.configManager.getConfig();
-    if (!config.env) {
-      throw new Error("No Docker environment configured. Add 'env' section to your config file.");
-    }
     const packageJsonPath = path24.join(this.configManager.getConfigDir(), "package.json");
     let projectName = "wordpress-project";
     if (fs20.existsSync(packageJsonPath)) {
@@ -117855,7 +117942,7 @@ class EnvCommand {
     return new DockerEnvManager({
       projectName,
       workspaceDir: this.configManager.getConfigDir(),
-      config: config.env
+      config
     });
   }
   async destroy() {
@@ -117870,7 +117957,7 @@ class EnvCommand {
   }
   async dbImport(filePath2) {
     const config = this.configManager.getConfig();
-    const inputPath = filePath2 || config.env?.sqlDump;
+    const inputPath = filePath2 || config.dev.sqlDump;
     if (!inputPath) {
       throw new Error("No SQL file specified. Use --file option or set 'sqlDump' in config.");
     }
@@ -117885,7 +117972,7 @@ class EnvCommand {
   }
   async dbExport(filePath2) {
     const config = this.configManager.getConfig();
-    const outputPath = filePath2 || config.env?.sqlDump || "./db/dump.sql";
+    const outputPath = filePath2 || config.dev.sqlDump || "./db/dump.sql";
     console.log(`
 \uD83D\uDCE4 Exporting database to ${outputPath}...
 `);

package/package.json

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