wp-uikit-cli 1.0.0

package/index.js

@@ -0,0 +1,1024 @@
+#! /usr/bin/env node
+import { Command } from "commander";
+import inquirer from "inquirer";
+import fs from "fs-extra";
+import path from "path";
+import ora from "ora";
+import figlet from "figlet";
+import chalk from "chalk";
+import { fileURLToPath } from "url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const pkg = fs.readJsonSync(path.join(__dirname, "package.json"));
+const program = new Command();
+const traitRegistryPath = path.join(__dirname, "traits.json");
+
+program
+  .name("sf")
+  .description("⚡ WP-UIkit CLI — scaffold, clean, debug and deploy SF Framework / SF Widget plugins")
+  .version(pkg.version, "-v, --version", "output the current version");
+
+
+/* ----------------------------- Zip Starts ----------------------------- */
+async function zipCurrentDirectory(outputName) {
+  const spinner = ora("📦 Creating zip...").start();
+  const { default: AdmZip } = await import("adm-zip");
+  const zip = new AdmZip();
+  const root = process.cwd();
+
+  zip.addLocalFolder(root);
+
+  const outputPath = path.join(
+    root,
+    outputName.endsWith(".zip") ? outputName : `${outputName}.zip`
+  );
+  zip.writeZip(outputPath);
+
+  spinner.succeed(`✅ Zipped to ${outputPath}`);
+}
+/* ----------------------------- Zip Ends----------------------------- */
+
+/* ----------------------------- Create Feature Starts ---------------------------- */
+
+// Kebab-case slug for filenames and method suffixes: FancyAnimatedTextTrait -> fancy-animated-text
+function getTraitSlugKebab(traitName) {
+  return traitName
+    .replace(/Trait$/, "")
+    .replace(/([a-z0-9])([A-Z])/g, "$1-$2")
+    .replace(/[\s_]+/g, "-")
+    .toLowerCase();
+}
+
+// Snake-case slug for method names: fancy_animated_text
+function toSnake(slugKebab) {
+  return slugKebab.replace(/-/g, "_");
+}
+
+// Extract raw args string from a PHP function declaration
+function extractMethodArgsString(fileContent, methodName) {
+  const regex = new RegExp(`function\\s+${methodName}\\s*\\(([^)]*)\\)`, "m");
+  const match = fileContent.match(regex);
+  return match ? match[1].trim() : "";
+}
+
+// Parse PHP params into { name, default } items
+function parsePhpParams(paramsStr) {
+  if (!paramsStr) return [];
+  return paramsStr
+    .split(",")
+    .map((s) => s.trim())
+    .filter(Boolean)
+    .map((p) => {
+      let cleaned = p
+        .replace(/^\s*(?:\[.*?\]\s*)?/, "") // attributes
+        .replace(/^\s*&\s*/, "") // by-ref
+        .replace(/^\s*(?:\??[A-Za-z_\\][A-Za-z0-9_\\]*)\s+/, ""); // type hints
+      const m = cleaned.match(/^\$[A-Za-z_][A-Za-z0-9_]*\s*(?:=\s*(.*))?$/);
+      const nameMatch = cleaned.match(/^\$[A-Za-z_][A-Za-z0-9_]*/);
+      const name = nameMatch ? nameMatch[0] : "";
+      const def = m && m[1] !== undefined ? m[1].trim() : undefined;
+      return { name, default: def };
+    });
+}
+
+// Format arguments for call site - values only (no named params, no assignments)
+function formatCallArgs(params) {
+  if (params.length === 0) return "";
+  const values = params.map(({ name, default: def }) => {
+    if (def !== undefined && def !== "") return def; // keep default literal
+    // try variable name (e.g., $prefix) else pass empty string
+    return name || "''";
+  });
+  return values.join(", ");
+}
+
+// Build calls by reading trait file, supporting hyphenated filenames and snake-case methods
+function buildTraitCalls(traitName, root) {
+  const kebab = getTraitSlugKebab(traitName); // fancy-animated-text
+  const snake = toSnake(kebab); // fancy_animated_text
+
+  const traitFilePath = path.join(
+    root,
+    "core",
+    "includes",
+    "traits",
+    `${kebab}-trait.php`
+  );
+
+  if (!fs.existsSync(traitFilePath)) {
+    console.log(chalk.red(`❌ Trait file not found: ${traitFilePath}`));
+    return { controlCall: "", renderCall: "" };
+  }
+
+  const code = fs.readFileSync(traitFilePath, "utf8");
+
+  // Try standard names first
+  let registerSig = extractMethodArgsString(code, `register_${snake}_controls`);
+  let renderSig =
+    extractMethodArgsString(code, `render_${snake}`) ||
+    extractMethodArgsString(
+      code,
+      `render${snake.replace(/_([a-z])/g, (_, c) => c.toUpperCase())}`
+    );
+
+  // Fallbacks: if trait uses custom naming like fancy_text_register_controls
+  if (!registerSig) {
+    // try any register_*controls that contains snake parts
+    const regAny = code.match(
+      new RegExp(
+        `function\\s+(register_[A-Za-z0-9_]+controls)\\s*\\(([^)]*)\\)`,
+        "g"
+      )
+    );
+    // naive fallback: try specific known variant samples
+    registerSig =
+      extractMethodArgsString(code, "fancy_text_register_controls") || "";
+  }
+
+  const regParams = parsePhpParams(registerSig);
+  const renParams = parsePhpParams(renderSig);
+
+  const controlArgs = formatCallArgs(regParams);
+  const renderArgs = formatCallArgs(renParams);
+
+  return {
+    controlCall: `$this->register_${snake}_controls(${controlArgs});`,
+    renderCall: `$this->render_${snake}(${renderArgs});`,
+  };
+}
+
+/* ---------------------- file/stub helpers ---------------------- */
+function readStub(name) {
+  return fs.readFileSync(path.join(__dirname, "stubs", name), "utf8");
+}
+
+function writeFromStub(stubName, destPath, replacements = {}) {
+  let content = readStub(stubName);
+  for (const [k, v] of Object.entries(replacements)) {
+    const re = new RegExp(`{{${k}}}`, "g");
+    content = content.replace(re, v || "");
+  }
+  content = content.replace(/{{}}/g, "");
+  content = content.replace(/\/\*__([a-z0-9_-]+)__\*\//gi, "");
+  content = content.replace(/^[ \t]*\/\*__([a-z0-9_-]+)__\*\/[ \t]*\n?/gim, "");
+  fs.outputFileSync(destPath, content);
+}
+
+/* --------------------------- sync ------------------------------ */
+async function syncTraits() {
+  const traitDir = path.join(process.cwd(), "core", "includes", "traits");
+  const traitFiles = fs.existsSync(traitDir)
+    ? fs.readdirSync(traitDir).filter((f) => f.endsWith("-trait.php"))
+    : [];
+
+  // Convert filename (kebab) to class name CamelCase + Trait
+  const traitNames = traitFiles.map((f) => {
+    const base = f.replace("-trait.php", ""); // e.g. fancy-animated-text
+    const classish = base
+      .split(/[-_ ]+/)
+      .map((w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase())
+      .join("");
+    return `${classish}Trait`;
+  });
+
+  fs.writeJsonSync(traitRegistryPath, traitNames, { spaces: 2 });
+  return traitNames;
+}
+
+/* --------------------------- create ---------------------------- */
+async function runCreate(opts) {
+  const spinner = ora("Generating widget files...").start();
+  const words = opts.name.trim().split(/[\s_-]+/);
+  const className = words
+    .map((w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase())
+    .join("_");
+  const fileName = words.map((w) => w.toLowerCase()).join("-");
+  const slug = "sf-" + words.map((w) => w.toLowerCase()).join("-");
+  const widgetName =
+    "SF " +
+    words
+      .map((w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase())
+      .join(" ");
+  const root = process.cwd();
+
+  const paths = {
+    php: path.join(root, "widgets", `${fileName}.php`),
+    css: path.join(root, "assets", "css", `${fileName}.css`),
+    js: path.join(root, "assets", "js", `${fileName}.js`),
+  };
+
+  // Smart trait imports and calls
+  const traitUses = (opts.traits || [])
+    .map((t) => `use \\SFWPStudio\\Core\\Includes\\Traits\\${t};`)
+    .join("\n");
+
+  const traitControls = (opts.traits || [])
+    .map((t) => buildTraitCalls(t, root).controlCall)
+    .filter(Boolean)
+    .join("\n    ");
+
+  const traitRender = (opts.traits || [])
+    .map((t) => buildTraitCalls(t, root).renderCall)
+    .filter(Boolean)
+    .join("\n    ");
+
+  const replacements = {
+    CLASSNAME: className,
+    FILENAME: fileName,
+    SLUG: slug,
+    ICON: opts.icon,
+    STYLE_DEPENDS: opts.css
+      ? `public function get_style_depends() {\n    return [ 'sf-${fileName}' ];\n}`
+      : "",
+    SCRIPT_DEPENDS: opts.js
+      ? `public function get_script_depends() {\n    return [ 'sf-${fileName}' ];\n}`
+      : "",
+    TRAIT_USES: traitUses || "",
+    TRAIT_IMPORTS: traitUses || "", 
+    TRAIT_CONTROLS: traitControls || "",
+    TRAIT_RENDER: traitRender || "",
+    WIDGET_NAME: widgetName || "",
+  };
+
+  const existing = Object.entries(paths)
+    .filter(([key, file]) => opts[key] !== false && fs.existsSync(file))
+    .map(([_, file]) => file);
+
+  if (existing.length) {
+    spinner.stop();
+    console.log(chalk.yellow("The following files already exist:"));
+    existing.forEach((f) => console.log(" " + f));
+    const { overwrite } = await inquirer.prompt([
+      {
+        type: "confirm",
+        name: "overwrite",
+        message: "Overwrite existing files?",
+        default: false,
+      },
+    ]);
+    if (!overwrite) {
+      console.log(chalk.red("Aborted — no files changed."));
+      return;
+    }
+    spinner.start();
+  }
+
+  writeFromStub("widget.php.stub", paths.php, replacements);
+  if (opts.css) writeFromStub("style.css.stub", paths.css, replacements);
+  if (opts.js) writeFromStub("script.js.stub", paths.js, replacements);
+
+  spinner.succeed(chalk.green(`Widget ${className} created!`));
+  console.log(chalk.blue("📁 Files created:"));
+  Object.entries(paths).forEach(([key, file]) => {
+    if (opts[key] !== false) console.log("  " + file);
+  });
+}
+
+/* --------------------------- trait create ---------------------- */
+function formatTraitNames(input) {
+  const raw = input.trim().replace(/Trait$/, "");
+  const className =
+    raw
+      .replace(/[\s_-]+/g, " ")
+      .split(" ")
+      .map((w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase())
+      .join("") + "Trait";
+
+  const slug = raw
+    .replace(/([a-z])([A-Z])/g, "$1_$2")
+    .replace(/[\s\-]+/g, "_")
+    .toLowerCase();
+
+  const fileSlug = raw
+    .replace(/([a-z])([A-Z])/g, "$1-$2")
+    .replace(/[\s_]+/g, "-")
+    .toLowerCase();
+
+  return { className, slug, fileName: `${fileSlug}-trait.php` };
+}
+
+async function runTraitCreation(name) {
+  const spinner = ora("Creating trait...").start();
+  const { className, slug, fileName } = formatTraitNames(name);
+  const traitDir = path.join(process.cwd(), "core", "includes", "traits");
+  const traitPath = path.join(traitDir, fileName);
+
+  if (fs.existsSync(traitPath)) {
+    spinner.stop();
+    console.log(chalk.yellow(`Trait ${fileName} already exists.`));
+    const { overwrite } = await inquirer.prompt([
+      {
+        type: "confirm",
+        name: "overwrite",
+        message: "Do you want to overwrite it?",
+        default: false,
+      },
+    ]);
+    if (!overwrite) {
+      console.log(chalk.red("Trait creation cancelled."));
+      return;
+    }
+    spinner.start();
+  }
+
+  fs.ensureDirSync(traitDir);
+  writeFromStub("trait.php.stub", traitPath, {
+    TRAITNAME: className,
+    TRAITSLUG: slug,
+  });
+  spinner.succeed(chalk.green(`Trait ${className} created!`));
+  console.log(chalk.blue("File created:\n ") + traitPath);
+}
+
+async function interactiveFlow(traitChoices) {
+  const answers = await inquirer.prompt([
+    {
+      type: "input",
+      name: "name",
+      message: "Widget name (e.g. Heading, Icon Box):",
+      validate: (val) => !!val || "Name required",
+    },
+    {
+      type: "confirm",
+      name: "css",
+      message: "Create CSS file?",
+      default: true,
+    },
+    { type: "confirm", name: "js", message: "Create JS file?", default: false },
+    {
+      type: "input",
+      name: "icon",
+      message:
+        "Elementor icon class (e.g. eicon-star):\nBrowse icons here 👉 (https://elementor.github.io/elementor-icons/):",
+      default: "eicon-star",
+    },
+    {
+      type: "checkbox",
+      name: "traits",
+      message: "Select traits to include:",
+      choices: traitChoices,
+    },
+  ]);
+  return answers;
+}
+/* ----------------------------- Create Feature Ends ---------------------------- */
+
+/* ----------------------------- Debug Feature Starts ---------------------------- */
+
+function toggleDebugMode(enable) {
+  const currentDir = process.cwd();
+  let wpConfigPath = "";
+  let dir = currentDir;
+
+  while (dir !== path.parse(dir).root) {
+    const candidate = path.join(dir, "wp-config.php");
+    if (fs.existsSync(candidate)) {
+      wpConfigPath = candidate;
+      break;
+    }
+    dir = path.dirname(dir);
+  }
+
+  if (!wpConfigPath) {
+    console.log(
+      chalk.red(
+        "❌ wp-config.php not found — make sure you’re inside a plugin/widget directory"
+      )
+    );
+    return;
+  }
+
+  let content = fs.readFileSync(wpConfigPath, "utf8");
+  let modified = false;
+
+  const wpDebugRegex = /define\(\s*['"]WP_DEBUG['"]\s*,\s*(true|false)\s*\);/;
+  const wpDebugReplacement = `define('WP_DEBUG', ${enable});`;
+
+  const newContent = content.replace(wpDebugRegex, wpDebugReplacement);
+  if (newContent !== content) {
+    content = newContent;
+    modified = true;
+  }
+
+  const debugBlock = `
+if ( ! defined( 'WP_DEBUG_LOG' ) ) {
+  define( 'WP_DEBUG_LOG', true );
+}
+
+if ( ! defined( 'WP_DEBUG_DISPLAY' ) ) {
+  define( 'WP_DEBUG_DISPLAY', true );
+}
+`.trim();
+
+  if (enable) {
+    if (content.includes(debugBlock)) {
+      console.log(chalk.yellow("⚠️  Debug block already present"));
+    } else {
+      const wpDebugBlockRegex =
+        /if\s*\(\s*!\s*defined\s*\(\s*['"]WP_DEBUG['"]\s*\)\s*\)\s*\{\s*define\s*\(\s*['"]WP_DEBUG['"]\s*,\s*true\s*\)\s*;\s*\}/s;
+      const wpDebugLineRegex =
+        /define\(\s*['"]WP_DEBUG['"]\s*,\s*true\s*\);\s*/;
+
+      let updatedContent = content.replace(
+        wpDebugBlockRegex,
+        `if ( ! defined( 'WP_DEBUG' ) ) {\n\tdefine( 'WP_DEBUG', true );\n}\n\n${debugBlock}\n`
+      );
+
+      if (updatedContent === content) {
+        updatedContent = content.replace(
+          wpDebugLineRegex,
+          `define('WP_DEBUG', true);\n\n${debugBlock}\n`
+        );
+      }
+
+      if (updatedContent !== content) {
+        content = updatedContent;
+        modified = true;
+      } else {
+        console.log(
+          chalk.red("❌ WP_DEBUG line not found — cannot insert debug block")
+        );
+        return;
+      }
+    }
+  } else {
+    const blockRegex = new RegExp(
+      `\\n?if\\s*\\(\\s*!\\s*defined\\s*\\(\\s*['"]WP_DEBUG_LOG['"]\\s*\\)\\s*\\)\\s*{[^}]*}\\s*\\n?if\\s*\\(\\s*!\\s*defined\\s*\\(\\s*['"]WP_DEBUG_DISPLAY['"]\\s*\\)\\s*\\)\\s*{[^}]*}`,
+      "g"
+    );
+    const cleanedContent = content.replace(blockRegex, "").trim();
+    if (cleanedContent !== content) {
+      content = cleanedContent;
+      modified = true;
+    }
+  }
+
+  if (modified) {
+    fs.writeFileSync(wpConfigPath, content + "\n");
+    console.log(
+      chalk.green(
+        `✅ Debug mode ${
+          enable ? "activated" : "deactivated"
+        } and config updated`
+      )
+    );
+    if (enable) {
+      console.log(
+        chalk.blue("\n📣 To verify logging, paste this in any PHP file:")
+      );
+      console.log(
+        chalk.yellow(`\n  error_log(print_r("Welcome to WP-UIkit Debug", true));\n`)
+      );
+      console.log(
+        chalk.white(`Then check:`),
+        chalk.cyan(`wp-content/debug.log\n`)
+      );
+    }
+  }
+}
+/* ----------------------------- Debug Feature Ends ---------------------------- */
+
+/* ----------------------------- Code Clean Feature Starts ---------------------------- */
+
+// Process single widget and return statistics
+async function localizeWidgetStrings(widgetName) {
+  const root = process.cwd();
+  const fileSlug = widgetName.trim().toLowerCase().replace(/\s+/g, "-");
+  const phpPath = path.join(root, "widgets", `${fileSlug}.php`);
+
+  if (!fs.existsSync(phpPath)) {
+    return { widget: widgetName, found: false, escHtmlCount: 0, domain: "-" };
+  }
+
+  let content = fs.readFileSync(phpPath, "utf8");
+  const originalContent = content;
+  let escHtmlCount = 0;
+
+  // 1️⃣ Normalize domain inside existing esc_html__ calls
+  content = content.replace(
+    /esc_html__\(\s*(['"])([^'"]+)\1\s*,\s*['"][^'"]+['"]\s*\)/g,
+    (match, q, str) => {
+      escHtmlCount++;
+      return `esc_html__(${q}${str}${q}, 'sf-widget')`;
+    }
+  );
+
+  // 2️⃣ Upgrade existing __(...) calls to esc_html__()
+  content = content.replace(
+    /__\(\s*(['"])([^'"]+)\1\s*,\s*['"][^'"]+['"]\s*\)/g,
+    (match, q, str) => {
+      escHtmlCount++;
+      return `esc_html__(${q}${str}${q}, 'sf-widget')`;
+    }
+  );
+
+  // 3️⃣ Wrap plain strings in esc_html__()
+  const regex =
+    /(label|description|title|placeholder|raw)\s*=>\s*['"]([^'"]+)['"]/g;
+  content = content.replace(regex, (match, key, str) => {
+    if (/esc_html__\(/.test(match)) return match;
+    escHtmlCount++;
+    return `${key} => esc_html__('${str}', 'sf-widget')`;
+  });
+
+  // 4️⃣ Cleanup accidental double replacements
+  content = content.replace(/esc_htmlesc_html__/g, "esc_html__");
+
+  if (content !== originalContent) {
+    fs.writeFileSync(phpPath, content);
+  }
+
+  return {
+    widget: widgetName,
+    found: true,
+    escHtmlCount: escHtmlCount,
+    domain: "sf-widget",
+    path: phpPath,
+  };
+}
+
+// Process all widgets
+async function localizeAllWidgets() {
+  const root = process.cwd();
+  const widgetsDir = path.join(root, "widgets");
+
+  if (!fs.existsSync(widgetsDir)) {
+    console.log(chalk.red("❌ Widgets directory not found"));
+    return;
+  }
+
+  const widgetFiles = fs.readdirSync(widgetsDir).filter((f) => f.endsWith(".php"));
+
+  if (widgetFiles.length === 0) {
+    console.log(chalk.yellow("⚠️  No widget files found"));
+    return;
+  }
+
+  const spinner = ora(`🌐 Processing ${widgetFiles.length} widgets...`).start();
+  const results = [];
+
+  for (const file of widgetFiles) {
+    const widgetName = file.replace(".php", "");
+    const result = await localizeWidgetStrings(widgetName);
+    results.push(result);
+  }
+
+  spinner.succeed(`✅ Processed ${widgetFiles.length} widgets\n`);
+
+  // Display results in table format
+  console.log(chalk.bold.cyan("\n📊 Localization Report\n"));
+  
+  const header = [
+    chalk.bold.white("Widget"),
+    chalk.bold.white("Status"),
+    chalk.bold.white("esc_html Count"),
+    chalk.bold.white("Domain"),
+  ];
+  
+  const maxWidgetLen = Math.max(...results.map((r) => r.widget.length), "Widget".length);
+  const maxStatusLen = 9;
+  const maxCountLen = 14;
+  const maxDomainLen = 10;
+
+  console.log(
+    chalk.gray(
+      "├─ " +
+      "─".repeat(maxWidgetLen + 2) +
+      "─".repeat(maxStatusLen + 2) +
+      "─".repeat(maxCountLen + 2) +
+      "─".repeat(maxDomainLen)
+    )
+  );
+
+  // Print header
+  console.log(
+    chalk.gray("│ ") +
+    "Widget".padEnd(maxWidgetLen) +
+    chalk.gray(" │ ") +
+    "Status".padEnd(maxStatusLen) +
+    chalk.gray(" │ ") +
+    "esc_html Count".padEnd(maxCountLen) +
+    chalk.gray(" │ ") +
+    "Domain".padEnd(maxDomainLen)
+  );
+
+  console.log(
+    chalk.gray(
+      "├─ " +
+      "─".repeat(maxWidgetLen + 2) +
+      "─".repeat(maxStatusLen + 2) +
+      "─".repeat(maxCountLen + 2) +
+      "─".repeat(maxDomainLen)
+    )
+  );
+
+  // Print rows
+  results.forEach((result) => {
+    const status = result.found ? chalk.green("✓ Done") : chalk.red("✗ Missing");
+    const count = result.escHtmlCount > 0 ? chalk.yellow(result.escHtmlCount) : chalk.gray("0");
+    const domain = result.found ? chalk.cyan(result.domain) : chalk.gray("-");
+
+    console.log(
+      chalk.gray("│ ") +
+      result.widget.padEnd(maxWidgetLen) +
+      chalk.gray(" │ ") +
+      status.padEnd(maxStatusLen + 10) +
+      chalk.gray(" │ ") +
+      count.padEnd(maxCountLen + 10) +
+      chalk.gray(" │ ") +
+      domain.padEnd(maxDomainLen + 5)
+    );
+  });
+
+  console.log(
+    chalk.gray(
+      "└─ " +
+      "─".repeat(maxWidgetLen + 2) +
+      "─".repeat(maxStatusLen + 2) +
+      "─".repeat(maxCountLen + 2) +
+      "─".repeat(maxDomainLen)
+    )
+  );
+
+  // Summary
+  const totalCount = results.reduce((sum, r) => sum + r.escHtmlCount, 0);
+  const processedCount = results.filter((r) => r.found).length;
+  
+  console.log(chalk.bold.cyan(`\n✨ Summary`));
+  console.log(chalk.gray(`  ├─ Total widgets processed: `) + chalk.white(processedCount));
+  console.log(chalk.gray(`  ├─ Total esc_html__() added: `) + chalk.yellow(totalCount));
+  console.log(chalk.gray(`  └─ Domain used: `) + chalk.cyan("sf-widget\n"));
+}
+
+/* ----------------------------- Code Clean Feature Ends ---------------------------- */
+
+
+
+/* ----------------------------- Commands Starts ---------------------------- */
+program
+  .command("debug <mode>")
+  .description("Toggle WP_DEBUG settings in wp-config.php (appended at end)")
+  .action((mode) => {
+    const enable = mode === "on";
+    toggleDebugMode(enable);
+  });
+
+program
+  .command("clean [widgetName]")
+  .option("--all", "Process all widgets with localization statistics")
+  .description("Wrap all user-visible strings in esc_html__() with domain 'sf-widget'")
+  .action(async (widgetName, opts) => {
+    if (opts.all) {
+      await localizeAllWidgets();
+    } else if (widgetName) {
+      const spinner = ora(`🌐 Localizing strings for ${widgetName}...`).start();
+      const result = await localizeWidgetStrings(widgetName);
+      if (result.found) {
+        spinner.succeed(
+          `✅ Localized ${result.escHtmlCount} strings in ${widgetName} with esc_html__() and domain 'sf-widget'`
+        );
+      } else {
+        spinner.fail(`❌ Widget file not found: ${widgetName}.php`);
+      }
+    } else {
+      console.log(chalk.yellow("⚠️  Please provide a widget name or use --all flag\n"));
+      console.log(chalk.cyan("Usage:"));
+      console.log(chalk.gray("  sf clean <widgetName>    - Process single widget"));
+      console.log(chalk.gray("  sf clean --all           - Process all widgets"));
+    }
+  });
+
+program
+  .command("create")
+  .description("Create a widget or trait interactively")
+  .action(async () => {
+    console.log(
+      chalk.cyan(figlet.textSync("WP-UIkit CLI", { horizontalLayout: "full" }))
+    );
+
+    const spinner = ora("🍳 Cooking up trait list...").start();
+    await new Promise((resolve) => setTimeout(resolve, 1000));
+    const traitChoices = await syncTraits();
+    spinner.succeed("Traits synced!");
+
+    const { type } = await inquirer.prompt([
+      {
+        type: "list",
+        name: "type",
+        message: "What do you want to create?",
+        choices: ["Widget", "Trait"],
+      },
+    ]);
+
+    if (type === "Trait") {
+      const { traitName } = await inquirer.prompt([
+        {
+          type: "input",
+          name: "traitName",
+          message: "Enter trait name (e.g. CardTrait):",
+          validate: (val) => !!val || "Trait name required",
+        },
+      ]);
+      await runTraitCreation(traitName);
+    } else {
+      const answers = await interactiveFlow(traitChoices);
+      await runCreate({ ...answers });
+    }
+  });
+
+program
+  .command("zip [filename]")
+  .description("Zip the current working directory into <filename>.zip")
+  .action(async (filename) => {
+    const finalName =
+      filename && String(filename).trim()
+        ? String(filename).trim()
+        : path.basename(process.cwd());
+
+    await zipCurrentDirectory(finalName);
+  });
+
+/* ----------------------------- Deploy Feature Starts ---------------------------- */
+
+/**
+ * Recursively minify all .js files in a directory using Terser.
+ * Writes <name>.min.js and deletes the original.
+ */
+async function minifyJsFiles(dir, spinner, terserMinify) {
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      await minifyJsFiles(fullPath, spinner, terserMinify);
+    } else if (
+      entry.isFile() &&
+      entry.name.endsWith(".js") &&
+      !entry.name.endsWith(".min.js")
+    ) {
+      try {
+        const original = fs.readFileSync(fullPath, "utf8");
+        const result = await terserMinify(original, { mangle: true, compress: true });
+        if (result.code) {
+          const minPath = fullPath.replace(/\.js$/, ".min.js");
+          fs.writeFileSync(minPath, result.code, "utf8");
+          fs.removeSync(fullPath);
+          spinner.text = chalk.gray(`  Minified JS: ${path.basename(fullPath)}`);
+        }
+      } catch (err) {
+        spinner.warn(chalk.yellow(`⚠️  Terser failed on ${fullPath}: ${err.message}`));
+        spinner.start();
+      }
+    }
+  }
+}
+
+/**
+ * Recursively minify all .css files in a directory using CleanCSS.
+ * Writes <name>.min.css and deletes the original.
+ */
+function minifyCssFiles(dir, spinner, CleanCSS) {
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      minifyCssFiles(fullPath, spinner, CleanCSS);
+    } else if (
+      entry.isFile() &&
+      entry.name.endsWith(".css") &&
+      !entry.name.endsWith(".min.css")
+    ) {
+      try {
+        const original = fs.readFileSync(fullPath, "utf8");
+        const result = new CleanCSS({}).minify(original);
+        if (result.errors && result.errors.length > 0) {
+          spinner.warn(chalk.yellow(`⚠️  CleanCSS errors on ${fullPath}: ${result.errors.join(", ")}`));
+          spinner.start();
+        } else {
+          const minPath = fullPath.replace(/\.css$/, ".min.css");
+          fs.writeFileSync(minPath, result.styles, "utf8");
+          fs.removeSync(fullPath);
+          spinner.text = chalk.gray(`  Minified CSS: ${path.basename(fullPath)}`);
+        }
+      } catch (err) {
+        spinner.warn(chalk.yellow(`⚠️  CleanCSS failed on ${fullPath}: ${err.message}`));
+        spinner.start();
+      }
+    }
+  }
+}
+
+/**
+ * Main deploy handler. Called with { framework: true } or { widget: true }.
+ *
+ * Flow:
+ *  - CWD         = the plugin folder  → minify, dev flag, gitignore removal, zip
+ *  - destDir     = folder path user provides → zip is moved here + JSON is updated here
+ */
+async function runDeploy(opts) {
+  const isFramework = !!opts.framework;
+  const isWidget = !!opts.widget;
+
+  if (!isFramework && !isWidget) {
+    console.log(chalk.red("❌ Please specify --framework or --widget"));
+    return;
+  }
+
+  // ── Plugin meta ──────────────────────────────────────────────────────────
+  const pluginKey   = isFramework ? "sf-framework" : "sf-widget";
+  const mainPhpFile = isFramework ? "sf-framework.php" : "sf-widget.php";
+  const devConstant = isFramework ? "SF_FRAMEWORK_DEVELOPMENT_MODE" : "SF_DEVELOPMENT_MODE";
+  const downloadUrl = isFramework
+    ? `https://gitea.syncfusion.com/syncfusion-wordpress-template/SF-Framework/raw/branch/main/{{VERSION}}`
+    : `https://gitea.syncfusion.com/syncfusion-wordpress-template/SF-Widget/raw/branch/development/{{VERSION}}`;
+  const description = isFramework
+    ? "A Design System for SF Widgets and Elementor. Build modern websites with ease."
+    : "30+ widgets Pro Feature and new design system for Elementor. Build modern websites with ease.";
+
+  // ── Plugin folder = current working directory ────────────────────────────
+  const pluginDir = process.cwd();
+  const divider = chalk.gray("─".repeat(60));
+
+  console.log("\n" + chalk.bold.cyan(figlet.textSync("WP-UIkit Deploy", { horizontalLayout: "full" })));
+  console.log(divider);
+  console.log(chalk.bold(`  Plugin  `) + chalk.cyan(pluginKey));
+  console.log(chalk.bold(`  Source  `) + chalk.white(pluginDir));
+  console.log(divider + "\n");
+
+  // ── Step 1: Ask for destination folder (where zip + JSON will go) ────────
+  const { folderPath } = await inquirer.prompt([
+    {
+      type: "input",
+      name: "folderPath",
+      message: chalk.bold("Destination folder") + chalk.gray(" (zip & update.json will be placed here):"),
+      validate: (val) => {
+        const trimmed = val.trim();
+        if (!trimmed) return "Folder path is required";
+        if (!fs.existsSync(trimmed)) return `Path does not exist: ${trimmed}`;
+        if (!fs.statSync(trimmed).isDirectory()) return "Path must be a directory";
+        return true;
+      },
+    },
+  ]);
+
+  const destDir = path.resolve(folderPath.trim());
+
+  // ── Step 2: Ask for new version ──────────────────────────────────────────
+  const { newVersion } = await inquirer.prompt([
+    {
+      type: "input",
+      name: "newVersion",
+      message: chalk.bold("New version") + chalk.gray(" (e.g. 1.2.0):"),
+      validate: (val) => /^\d+\.\d+\.\d+$/.test(val.trim()) || "Version must be in X.Y.Z format",
+    },
+  ]);
+
+  const version = newVersion.trim();
+  const zipName = `${pluginKey}-${version}`;
+
+  console.log("\n" + divider);
+  console.log(chalk.bold.white("  Running build steps"));
+  console.log(divider);
+
+  // ── Step 3: Minify JS assets (in CWD) ───────────────────────────────────
+  const jsDir = path.join(pluginDir, "assets", "js");
+  if (fs.existsSync(jsDir)) {
+    const jsSpinner = ora({ text: chalk.white("Minifying JS files..."), prefixText: "  " }).start();
+    const { minify: terserMinify } = await import("terser");
+    await minifyJsFiles(jsDir, jsSpinner, terserMinify);
+    jsSpinner.succeed(chalk.green("JS minified successfully"));
+  } else {
+    console.log(chalk.gray("  › No assets/js directory — skipping JS minification"));
+  }
+
+  // ── Step 4: Minify CSS assets (in CWD) ──────────────────────────────────
+  const cssDir = path.join(pluginDir, "assets", "css");
+  if (fs.existsSync(cssDir)) {
+    const cssSpinner = ora({ text: chalk.white("Minifying CSS files..."), prefixText: "  " }).start();
+    const { default: CleanCSS } = await import("clean-css");
+    minifyCssFiles(cssDir, cssSpinner, CleanCSS);
+    cssSpinner.succeed(chalk.green("CSS minified successfully"));
+  } else {
+    console.log(chalk.gray("  › No assets/css directory — skipping CSS minification"));
+  }
+
+  // ── Step 5: Set development flag to false (in CWD) ──────────────────────
+  const mainPhpPath = path.join(pluginDir, mainPhpFile);
+  if (fs.existsSync(mainPhpPath)) {
+    const devSpinner = ora({ text: chalk.white(`Disabling development mode...`), prefixText: "  " }).start();
+    let phpContent = fs.readFileSync(mainPhpPath, "utf8");
+    const devFlagRegex = new RegExp(
+      `define\\s*\\(\\s*['"]${devConstant}['"]\\s*,\\s*true\\s*\\)`,
+      "g"
+    );
+    const updated = phpContent.replace(devFlagRegex, `define('${devConstant}', false)`);
+    if (updated !== phpContent) {
+      fs.writeFileSync(mainPhpPath, updated, "utf8");
+      devSpinner.succeed(chalk.green(`Development mode disabled  `) + chalk.gray(`(${mainPhpFile})`));
+    } else {
+      devSpinner.warn(chalk.yellow(`Flag not found or already false  `) + chalk.gray(`(${mainPhpFile})`));
+    }
+  } else {
+    console.log(chalk.yellow(`  › ${mainPhpFile} not found — skipping dev flag update`));
+  }
+
+  // ── Step 6: Remove .gitignore (in CWD) ──────────────────────────────────
+  const gitignorePath = path.join(pluginDir, ".gitignore");
+  if (fs.existsSync(gitignorePath)) {
+    fs.removeSync(gitignorePath);
+    console.log("  " + chalk.green("✔") + "  " + chalk.green(".gitignore removed"));
+  } else {
+    console.log(chalk.gray("  › No .gitignore found — skipping"));
+  }
+
+  // ── Step 6.5: Remove fonts folder for widget plugin (in CWD) ─────────────
+  if (isWidget) {
+    const fontsPath = path.join(pluginDir, "assets", "icons", "fonts");
+    if (fs.existsSync(fontsPath)) {
+      fs.removeSync(fontsPath);
+      console.log("  " + chalk.green("✔") + "  " + chalk.green("Fonts folder removed"));
+    } else {
+      console.log(chalk.gray("  › No fonts folder found — skipping"));
+    }
+  }
+
+  // ── Step 7: Zip the CWD plugin folder ───────────────────────────────────
+  const zipSpinner = ora({ text: chalk.white(`Creating zip  ${zipName}.zip...`), prefixText: "  " }).start();
+  const { default: AdmZip } = await import("adm-zip");
+  const zip = new AdmZip();
+
+  // Exclude .git, node_modules, and any existing .zip files from the archive
+  const excludeDirs = [".git", "node_modules"];
+  zip.addLocalFolder(pluginDir, pluginKey, (filePath) => {
+    const normalized = filePath.replace(/\\/g, "/");
+    for (const dir of excludeDirs) {
+      if (normalized.startsWith(`${dir}/`) || normalized === dir) return false;
+    }
+    if (normalized.endsWith(".zip")) return false;
+    return true;
+  });
+
+  const tempZipPath = path.join(pluginDir, `${zipName}.zip`);
+  zip.writeZip(tempZipPath);
+  zipSpinner.succeed(chalk.green(`Zip created  `) + chalk.gray(`${zipName}.zip`));
+
+  // ── Step 8: Move zip to destination folder ───────────────────────────────
+  const finalZipPath = path.join(destDir, `${zipName}.zip`);
+  fs.moveSync(tempZipPath, finalZipPath, { overwrite: true });
+  console.log("  " + chalk.green("✔") + "  " + chalk.green("Zip moved to destination  ") + chalk.gray(finalZipPath));
+
+  // ── Step 9: Update update.json in destination folder (only if it exists) ──
+  const jsonFilePath = path.join(destDir, "update.json");
+  if (fs.existsSync(jsonFilePath)) {
+    const jsonSpinner = ora({ text: chalk.white("Updating update.json..."), prefixText: "  " }).start();
+    const versionedUrl = downloadUrl.replace("{{VERSION}}", `${zipName}.zip`);
+    const jsonData = {
+      name: pluginKey,
+      version: version,
+      download_url: versionedUrl,
+      sections: { description: description },
+    };
+    fs.writeJsonSync(jsonFilePath, jsonData, { spaces: 2 });
+    jsonSpinner.succeed(chalk.green("update.json updated  ") + chalk.gray(jsonFilePath));
+  } else {
+    console.log(chalk.gray("  › No update.json found in destination — skipping"));
+  }
+
+  // ── Done ─────────────────────────────────────────────────────────────────
+  console.log("\n" + divider);
+  console.log(
+    chalk.bold.green("  ✔  Deploy complete — ") +
+    chalk.bold.white(`${pluginKey}`) +
+    chalk.bold.green(" v") +
+    chalk.bold.cyan(`${version}`)
+  );
+  console.log(divider);
+  console.log(chalk.bold(`\n  Output`));
+  console.log(chalk.gray(`  ├─ Zip   `) + chalk.white(finalZipPath));
+  if (fs.existsSync(jsonFilePath)) {
+    console.log(chalk.gray(`  └─ JSON  `) + chalk.white(jsonFilePath));
+  }
+  console.log(chalk.bold(`\n  Next steps`));
+  console.log(chalk.gray(`  ├─`) + chalk.yellow(`  Open the destination folder in your file manager`));
+  console.log(chalk.gray(`  ├─`) + chalk.yellow(`  Review the changes — check update.json & zip`));
+  console.log(chalk.gray(`  ├─`) + chalk.yellow(`  Stage all changes:  `) + chalk.cyan(`git add .`));
+  console.log(chalk.gray(`  ├─`) + chalk.yellow(`  Commit:             `) + chalk.cyan(`git commit -m "Release ${pluginKey} v${version}"`));
+  console.log(chalk.gray(`  └─`) + chalk.yellow(`  Push:               `) + chalk.cyan(`git push`));
+  console.log("");
+}
+
+/* ----------------------------- Deploy Feature Ends ---------------------------- */
+
+program
+  .command("deploy")
+  .description("Deploy sf-framework or sf-widget plugin (minify, update JSON, zip)")
+  .option("--framework", "Deploy sf-framework plugin")
+  .option("--widget", "Deploy sf-widget plugin")
+  .action(async (opts) => {
+    await runDeploy(opts);
+  });
+
+program.parse(process.argv);
+
+/* ----------------------------- Commands Ends ---------------------------- */
+