@onexapis/cli 1.0.0

package/dist/index.js

@@ -0,0 +1,2104 @@
+'use strict';
+
+var path = require('path');
+var fs2 = require('fs');
+var child_process = require('child_process');
+var inquirer = require('inquirer');
+var chalk4 = require('chalk');
+var ora = require('ora');
+var fs = require('fs-extra');
+var ejs = require('ejs');
+var clientS3 = require('@aws-sdk/client-s3');
+var glob = require('glob');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var path__default = /*#__PURE__*/_interopDefault(path);
+var fs2__default = /*#__PURE__*/_interopDefault(fs2);
+var inquirer__default = /*#__PURE__*/_interopDefault(inquirer);
+var chalk4__default = /*#__PURE__*/_interopDefault(chalk4);
+var ora__default = /*#__PURE__*/_interopDefault(ora);
+var fs__default = /*#__PURE__*/_interopDefault(fs);
+var ejs__default = /*#__PURE__*/_interopDefault(ejs);
+
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : /* @__PURE__ */ Symbol.for("Symbol." + name);
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __forAwait = (obj, it, method) => (it = obj[__knownSymbol("asyncIterator")]) ? it.call(obj) : (obj = obj[__knownSymbol("iterator")](), it = {}, method = (key, fn) => (fn = obj[key]) && (it[key] = (arg) => new Promise((yes, no, done) => (arg = fn.call(obj, arg), done = arg.done, Promise.resolve(arg.value).then((value) => yes({ value, done }), no)))), method("next"), method("return"), it);
+var Logger = class {
+  constructor() {
+    this.spinner = null;
+  }
+  success(message) {
+    console.log(chalk4__default.default.green("\u2713"), message);
+  }
+  error(message) {
+    console.log(chalk4__default.default.red("\u2717"), message);
+  }
+  warning(message) {
+    console.log(chalk4__default.default.yellow("\u26A0"), message);
+  }
+  info(message) {
+    console.log(chalk4__default.default.blue("\u2139"), message);
+  }
+  log(message) {
+    console.log(message);
+  }
+  startSpinner(message) {
+    this.spinner = ora__default.default(message).start();
+  }
+  stopSpinner(success = true, message) {
+    if (!this.spinner) return;
+    if (success) {
+      this.spinner.succeed(message);
+    } else {
+      this.spinner.fail(message);
+    }
+    this.spinner = null;
+  }
+  updateSpinner(message) {
+    if (this.spinner) {
+      this.spinner.text = message;
+    }
+  }
+  newLine() {
+    console.log();
+  }
+  header(message) {
+    console.log();
+    console.log(chalk4__default.default.bold.cyan(message));
+    console.log(chalk4__default.default.cyan("=".repeat(message.length)));
+    console.log();
+  }
+  section(message) {
+    console.log();
+    console.log(chalk4__default.default.bold(message));
+  }
+};
+var logger = new Logger();
+
+// src/utils/validators.ts
+function validateName(name) {
+  return /^[a-z0-9]+(-[a-z0-9]+)*$/.test(name);
+}
+function toKebabCase(str) {
+  return str.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[\s_]+/g, "-").toLowerCase();
+}
+function toPascalCase(str) {
+  return str.split(/[-_\s]+/).map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join("");
+}
+function toCamelCase(str) {
+  const pascal = toPascalCase(str);
+  return pascal.charAt(0).toLowerCase() + pascal.slice(1);
+}
+function validateThemeName(name) {
+  return /^[a-z][a-z0-9-]*$/.test(name);
+}
+function pathExists(filePath) {
+  const fs7 = __require("fs-extra");
+  return fs7.existsSync(filePath);
+}
+function validateCategory(category) {
+  const validCategories = [
+    "headers",
+    "heroes",
+    "content",
+    "features",
+    "testimonials",
+    "galleries",
+    "cta",
+    "footers",
+    "ecommerce",
+    "blog",
+    "contact"
+  ];
+  return validCategories.includes(category);
+}
+function getValidCategories() {
+  return [
+    "headers",
+    "heroes",
+    "content",
+    "features",
+    "testimonials",
+    "galleries",
+    "cta",
+    "footers",
+    "ecommerce",
+    "blog",
+    "contact"
+  ];
+}
+async function renderTemplate(templatePath, data) {
+  const template = await fs__default.default.readFile(templatePath, "utf-8");
+  return ejs__default.default.render(template, data);
+}
+async function writeFile(filePath, content) {
+  await fs__default.default.ensureDir(path__default.default.dirname(filePath));
+  await fs__default.default.writeFile(filePath, content, "utf-8");
+}
+function getTemplatesDir() {
+  const locations = [
+    path__default.default.join(__dirname, "../../templates"),
+    // Development
+    path__default.default.join(__dirname, "../templates"),
+    // Production (dist/)
+    path__default.default.join(process.cwd(), "templates"),
+    // Fallback
+    path__default.default.join(process.cwd(), "packages/cli/templates")
+    // Monorepo
+  ];
+  for (const location of locations) {
+    if (fs__default.default.existsSync(location)) {
+      return location;
+    }
+  }
+  throw new Error("Templates directory not found");
+}
+async function copyTemplate(templateName, targetDir, data) {
+  const templatesDir = getTemplatesDir();
+  const templateDir = path__default.default.join(templatesDir, templateName);
+  if (!fs__default.default.existsSync(templateDir)) {
+    throw new Error(
+      `Template "${templateName}" not found at ${templateDir}. Available templates: ${fs__default.default.readdirSync(templatesDir).join(", ")}`
+    );
+  }
+  await fs__default.default.ensureDir(targetDir);
+  const files = await fs__default.default.readdir(templateDir);
+  for (const file of files) {
+    const templatePath = path__default.default.join(templateDir, file);
+    const targetPath = path__default.default.join(targetDir, file);
+    const stat = await fs__default.default.stat(templatePath);
+    if (stat.isDirectory()) {
+      await copyTemplateDir(templatePath, targetPath, data);
+    } else if (file.endsWith(".ejs")) {
+      const content = await renderTemplate(templatePath, data);
+      const outputPath = targetPath.replace(/\.ejs$/, "");
+      await writeFile(outputPath, content);
+    } else {
+      await fs__default.default.copy(templatePath, targetPath);
+    }
+  }
+}
+async function copyTemplateDir(templateDir, targetDir, data) {
+  await fs__default.default.ensureDir(targetDir);
+  const files = await fs__default.default.readdir(templateDir);
+  for (const file of files) {
+    const templatePath = path__default.default.join(templateDir, file);
+    const targetPath = path__default.default.join(targetDir, file);
+    const stat = await fs__default.default.stat(templatePath);
+    if (stat.isDirectory()) {
+      await copyTemplateDir(templatePath, targetPath, data);
+    } else if (file.endsWith(".ejs")) {
+      const content = await renderTemplate(templatePath, data);
+      const outputPath = targetPath.replace(/\.ejs$/, "");
+      await writeFile(outputPath, content);
+    } else {
+      await fs__default.default.copy(templatePath, targetPath);
+    }
+  }
+}
+function getProjectRoot() {
+  let currentDir = process.cwd();
+  while (currentDir !== path__default.default.parse(currentDir).root) {
+    const packageJsonPath = path__default.default.join(currentDir, "package.json");
+    if (fs__default.default.existsSync(packageJsonPath)) {
+      const packageJson = fs__default.default.readJsonSync(packageJsonPath);
+      if (packageJson.workspaces || fs__default.default.existsSync(path__default.default.join(currentDir, "src/themes")) || fs__default.default.existsSync(path__default.default.join(currentDir, "themes"))) {
+        return currentDir;
+      }
+    }
+    currentDir = path__default.default.dirname(currentDir);
+  }
+  return process.cwd();
+}
+function getThemesDir() {
+  try {
+    return path__default.default.join(getProjectRoot(), "src/themes");
+  } catch (e) {
+    return path__default.default.join(getProjectRoot(), "themes");
+  }
+}
+function getFeaturesDir() {
+  return path__default.default.join(getProjectRoot(), "src/features");
+}
+function isOneXProject() {
+  const root = getProjectRoot();
+  return fs__default.default.existsSync(path__default.default.join(root, "src/themes")) && fs__default.default.existsSync(path__default.default.join(root, "src/lib/registry"));
+}
+function ensureOneXProject() {
+  if (!isOneXProject()) {
+    logger.error(
+      "Not in a OneX project. Please run this command from a OneX project root."
+    );
+    process.exit(1);
+  }
+}
+function listThemes() {
+  const themesDir = getThemesDir();
+  if (!fs__default.default.existsSync(themesDir)) {
+    return [];
+  }
+  return fs__default.default.readdirSync(themesDir).filter((name) => {
+    const themePath = path__default.default.join(themesDir, name);
+    return fs__default.default.statSync(themePath).isDirectory() && fs__default.default.existsSync(path__default.default.join(themePath, "manifest.ts"));
+  });
+}
+function themeExists(themeName) {
+  const themePath = path__default.default.join(getThemesDir(), themeName);
+  return fs__default.default.existsSync(themePath) && fs__default.default.existsSync(path__default.default.join(themePath, "manifest.ts"));
+}
+function detectPackageManager() {
+  const userAgent = process.env.npm_config_user_agent || "";
+  if (userAgent.includes("pnpm")) return "pnpm";
+  if (userAgent.includes("yarn")) return "yarn";
+  if (userAgent.includes("bun")) return "bun";
+  const cwd = process.cwd();
+  if (fs__default.default.existsSync(path__default.default.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs__default.default.existsSync(path__default.default.join(cwd, "yarn.lock"))) return "yarn";
+  if (fs__default.default.existsSync(path__default.default.join(cwd, "bun.lockb"))) return "bun";
+  return "npm";
+}
+async function installDependencies(projectPath, packageManager = "npm") {
+  return new Promise((resolve, reject) => {
+    try {
+      const installCmd = packageManager === "yarn" ? "yarn" : `${packageManager} install`;
+      child_process.execSync(installCmd, {
+        cwd: projectPath,
+        stdio: "inherit"
+      });
+      resolve();
+    } catch (error) {
+      reject(error);
+    }
+  });
+}
+
+// src/commands/init.ts
+async function initCommand(projectName, options = {}) {
+  logger.header("Create New OneX Theme Project");
+  let name;
+  if (!projectName) {
+    const { inputName } = await inquirer__default.default.prompt([
+      {
+        type: "input",
+        name: "inputName",
+        message: "Project name (kebab-case):",
+        validate: (input) => {
+          if (!input) return "Project name is required";
+          const kebabName = toKebabCase(input);
+          if (!validateThemeName(kebabName)) {
+            return "Invalid project name. Use lowercase letters, numbers, and hyphens only.";
+          }
+          if (fs2__default.default.existsSync(path__default.default.join(process.cwd(), kebabName))) {
+            return `Directory "${kebabName}" already exists`;
+          }
+          return true;
+        }
+      }
+    ]);
+    name = toKebabCase(inputName);
+  } else {
+    name = toKebabCase(projectName);
+  }
+  const projectPath = path__default.default.join(process.cwd(), name);
+  if (fs2__default.default.existsSync(projectPath)) {
+    logger.error(`Directory "${name}" already exists.`);
+    process.exit(1);
+  }
+  let displayName;
+  let description;
+  let author;
+  let template;
+  if (options.yes) {
+    displayName = toPascalCase(name).replace(/([A-Z])/g, " $1").trim();
+    description = "A custom OneX theme";
+    author = "";
+    template = options.template || "default";
+  } else {
+    const answers = await inquirer__default.default.prompt([
+      {
+        type: "input",
+        name: "displayName",
+        message: "Display name:",
+        default: toPascalCase(name).replace(/([A-Z])/g, " $1").trim()
+      },
+      {
+        type: "input",
+        name: "description",
+        message: "Theme description:",
+        default: "A custom OneX theme"
+      },
+      {
+        type: "input",
+        name: "author",
+        message: "Author name:",
+        default: ""
+      },
+      {
+        type: "list",
+        name: "template",
+        message: "Template to use:",
+        choices: [
+          { name: "Default (basic theme structure)", value: "default" },
+          { name: "Minimal (bare minimum)", value: "minimal" }
+        ],
+        default: options.template || "default"
+      }
+    ]);
+    displayName = answers.displayName;
+    description = answers.description;
+    author = answers.author;
+    template = answers.template;
+  }
+  const data = {
+    projectName: name,
+    themeName: name,
+    themeNamePascal: toPascalCase(name),
+    displayName,
+    description,
+    author,
+    template
+  };
+  logger.startSpinner("Creating project structure...");
+  try {
+    fs2__default.default.mkdirSync(projectPath, { recursive: true });
+    await copyTemplate(template, projectPath, data);
+    const srcPath = path__default.default.join(projectPath, "src");
+    fs2__default.default.mkdirSync(srcPath, { recursive: true });
+    const manifestContent = generateManifest(data);
+    await writeFile(path__default.default.join(srcPath, "manifest.ts"), manifestContent);
+    const configContent = generateThemeConfig(data);
+    await writeFile(path__default.default.join(srcPath, "config.ts"), configContent);
+    const layoutContent = generateThemeLayout(data);
+    await writeFile(path__default.default.join(srcPath, "layout.ts"), layoutContent);
+    const indexContent = generateThemeIndex(data);
+    await writeFile(path__default.default.join(srcPath, "index.ts"), indexContent);
+    const sectionsPath = path__default.default.join(srcPath, "sections");
+    fs2__default.default.mkdirSync(sectionsPath, { recursive: true });
+    await writeFile(
+      path__default.default.join(sectionsPath, "README.md"),
+      `# ${displayName} Sections
+
+Add your theme-specific sections here.
+`
+    );
+    const blocksPath = path__default.default.join(srcPath, "blocks");
+    fs2__default.default.mkdirSync(blocksPath, { recursive: true });
+    await writeFile(
+      path__default.default.join(blocksPath, "README.md"),
+      `# ${displayName} Blocks
+
+Add your theme-specific blocks here.
+`
+    );
+    const pagesPath = path__default.default.join(srcPath, "pages");
+    fs2__default.default.mkdirSync(pagesPath, { recursive: true });
+    const homePageContent = generateHomePage(data);
+    await writeFile(path__default.default.join(pagesPath, "home.ts"), homePageContent);
+    logger.stopSpinner(true, "Project structure created!");
+    if (options.git) {
+      logger.startSpinner("Initializing git repository...");
+      try {
+        child_process.execSync("git init", { cwd: projectPath, stdio: "ignore" });
+        child_process.execSync("git add .", { cwd: projectPath, stdio: "ignore" });
+        child_process.execSync('git commit -m "Initial commit from onex init"', {
+          cwd: projectPath,
+          stdio: "ignore"
+        });
+        logger.stopSpinner(true, "Git repository initialized!");
+      } catch (e) {
+        logger.stopSpinner(false, "Failed to initialize git");
+      }
+    }
+    if (!options.noInstall) {
+      logger.newLine();
+      const packageManager = detectPackageManager();
+      logger.startSpinner(`Installing dependencies with ${packageManager}...`);
+      try {
+        await installDependencies(projectPath, packageManager);
+        logger.stopSpinner(true, "Dependencies installed!");
+      } catch (e) {
+        logger.stopSpinner(false, "Failed to install dependencies");
+        logger.info(
+          "You can install dependencies manually by running: cd " + name + " && npm install"
+        );
+      }
+    }
+    logger.newLine();
+    logger.section("Success! \u{1F389}");
+    logger.newLine();
+    logger.info(`Created OneX theme project at: ${projectPath}`);
+    logger.newLine();
+    logger.section("Next steps:");
+    logger.log(`  cd ${name}`);
+    if (options.noInstall) {
+      logger.log(`  npm install`);
+    }
+    logger.log(`  npm run build      # Build your theme`);
+    logger.log(`  npm run dev        # Start development mode`);
+    logger.newLine();
+    logger.section("Theme structure:");
+    logger.log("  src/manifest.ts    - Theme manifest and exports");
+    logger.log("  src/config.ts      - Design tokens (colors, typography, etc.)");
+    logger.log("  src/layout.ts      - Header and footer configuration");
+    logger.log("  src/sections/      - Custom sections for your theme");
+    logger.log("  src/blocks/        - Reusable blocks");
+    logger.log("  src/pages/         - Page configurations");
+    logger.newLine();
+    logger.success(`Happy theming! \u{1F3A8}`);
+  } catch (error) {
+    logger.stopSpinner(false, "Failed to create project");
+    logger.error(
+      error instanceof Error ? error.message : "Unknown error occurred"
+    );
+    if (fs2__default.default.existsSync(projectPath)) {
+      fs2__default.default.rmSync(projectPath, { recursive: true, force: true });
+    }
+    process.exit(1);
+  }
+}
+function generateManifest(data) {
+  return `import type { ThemeExport } from "@duongthiu/onex-core";
+
+/**
+ * ${data.displayName} Theme Manifest
+ * ${data.description}
+ */
+export const manifest: ThemeExport = {
+  id: "${data.themeName}",
+  name: "${data.displayName}",
+  description: "${data.description}",
+  version: "1.0.0",
+  author: "${data.author}",
+
+  // Theme configuration
+  config: () => import("./theme.config").then((m) => m.themeConfig),
+
+  // Theme layout (header/footer sections)
+  layout: () => import("./theme.layout").then((m) => m.themeLayout),
+
+  // Available sections in this theme
+  sections: {
+    // Example: hero: () => import("./sections/hero").then((m) => m.heroSchema),
+  },
+
+  // Available blocks in this theme
+  blocks: {
+    // Example: productCard: () => import("./blocks/product-card").then((m) => m.productCardDefinition),
+  },
+
+  // Default pages
+  pages: {
+    home: () => import("./pages/home").then((m) => m.homePageConfig),
+  },
+
+  // Supported page types
+  supportedPageTypes: ["home", "about", "contact", "custom"],
+
+  // Preview image (optional)
+  preview: undefined,
+
+  // Tags for categorization (optional)
+  tags: ["custom"],
+};
+
+export default manifest;
+`;
+}
+function generateThemeConfig(data) {
+  return `import type { ThemeConfig } from "@duongthiu/onex-core";
+
+/**
+ * ${data.displayName} Theme Configuration
+ * Design tokens: colors, typography, spacing, etc.
+ */
+export const themeConfig: ThemeConfig = {
+  // Color palette
+  colors: {
+    primary: {
+      50: "#eff6ff",
+      100: "#dbeafe",
+      200: "#bfdbfe",
+      300: "#93c5fd",
+      400: "#60a5fa",
+      500: "#3b82f6",
+      600: "#2563eb",
+      700: "#1d4ed8",
+      800: "#1e40af",
+      900: "#1e3a8a",
+    },
+    secondary: {
+      50: "#f8fafc",
+      100: "#f1f5f9",
+      200: "#e2e8f0",
+      300: "#cbd5e1",
+      400: "#94a3b8",
+      500: "#64748b",
+      600: "#475569",
+      700: "#334155",
+      800: "#1e293b",
+      900: "#0f172a",
+    },
+    accent: {
+      50: "#fdf4ff",
+      100: "#fae8ff",
+      200: "#f5d0fe",
+      300: "#f0abfc",
+      400: "#e879f9",
+      500: "#d946ef",
+      600: "#c026d3",
+      700: "#a21caf",
+      800: "#86198f",
+      900: "#701a75",
+    },
+  },
+
+  // Typography
+  typography: {
+    fontFamily: {
+      sans: ["Inter", "system-ui", "sans-serif"],
+      serif: ["Georgia", "serif"],
+      mono: ["Monaco", "monospace"],
+    },
+    fontSize: {
+      xs: "0.75rem",
+      sm: "0.875rem",
+      base: "1rem",
+      lg: "1.125rem",
+      xl: "1.25rem",
+      "2xl": "1.5rem",
+      "3xl": "1.875rem",
+      "4xl": "2.25rem",
+      "5xl": "3rem",
+    },
+  },
+
+  // Spacing
+  spacing: {
+    xs: "0.5rem",
+    sm: "1rem",
+    md: "1.5rem",
+    lg: "2rem",
+    xl: "3rem",
+    "2xl": "4rem",
+    "3xl": "6rem",
+    "4xl": "8rem",
+  },
+
+  // Border radius
+  borderRadius: {
+    none: "0",
+    sm: "0.125rem",
+    md: "0.375rem",
+    lg: "0.5rem",
+    xl: "0.75rem",
+    full: "9999px",
+  },
+
+  // Breakpoints
+  breakpoints: {
+    sm: "640px",
+    md: "768px",
+    lg: "1024px",
+    xl: "1280px",
+    "2xl": "1536px",
+  },
+};
+`;
+}
+function generateThemeLayout(data) {
+  return `import type { ThemeLayoutConfig } from "@duongthiu/onex-core";
+
+/**
+ * ${data.themeName} Theme Layout
+ * Define header and footer sections
+ */
+export const themeLayout: ThemeLayoutConfig = {
+  // Header section configuration
+  header: undefined,
+  // Example:
+  // header: {
+  //   type: "header",
+  //   template: "default",
+  //   enabled: true,
+  //   settings: {},
+  // },
+
+  // Footer section configuration
+  footer: undefined,
+  // Example:
+  // footer: {
+  //   type: "footer",
+  //   template: "default",
+  //   enabled: true,
+  //   settings: {},
+  // },
+};
+`;
+}
+function generateThemeIndex(data) {
+  return `/**
+ * ${data.themeNamePascal} Theme
+ */
+
+export { manifest as ${data.themeName}Manifest } from "./manifest";
+export { themeConfig as ${data.themeName}Config } from "./theme.config";
+export { themeLayout as ${data.themeName}Layout } from "./theme.layout";
+`;
+}
+function generateHomePage(data) {
+  return `import type { PageConfig } from "@duongthiu/onex-core";
+
+/**
+ * Home Page Configuration
+ */
+export const homePageConfig: PageConfig = {
+  type: "home",
+  title: "${data.displayName}",
+  description: "Welcome to ${data.displayName}",
+
+  // SEO metadata
+  seo: {
+    title: "${data.displayName} - Home",
+    description: "Welcome to ${data.displayName}",
+    keywords: [],
+    ogImage: undefined,
+  },
+
+  // Page sections
+  sections: [
+    // Add your sections here
+    // Example:
+    // {
+    //   id: "hero-1",
+    //   type: "hero",
+    //   template: "default",
+    //   order: 0,
+    //   enabled: true,
+    //   settings: {},
+    //   components: [],
+    //   blocks: [],
+    // },
+  ],
+};
+`;
+}
+async function createSectionCommand(name, options) {
+  logger.header("Create New Section");
+  ensureOneXProject();
+  const sectionName = toKebabCase(name);
+  if (!validateName(sectionName)) {
+    logger.error(
+      `Invalid section name: ${sectionName}. Use kebab-case (e.g., hero, featured-products)`
+    );
+    process.exit(1);
+  }
+  const answers = await inquirer__default.default.prompt([
+    {
+      type: "list",
+      name: "theme",
+      message: "Which theme should this section belong to?",
+      choices: listThemes(),
+      when: !options.theme
+    },
+    {
+      type: "list",
+      name: "category",
+      message: "What category is this section?",
+      choices: getValidCategories(),
+      when: !options.category
+    },
+    {
+      type: "input",
+      name: "displayName",
+      message: "Display name for this section:",
+      default: toPascalCase(sectionName).replace(/([A-Z])/g, " $1").trim()
+    },
+    {
+      type: "input",
+      name: "description",
+      message: "Section description:",
+      default: `${toPascalCase(sectionName)} section`
+    },
+    {
+      type: "confirm",
+      name: "createTemplate",
+      message: "Create a default template variant?",
+      default: true
+    }
+  ]);
+  const themeName = options.theme || answers.theme;
+  const category = options.category || answers.category;
+  const displayName = answers.displayName;
+  const description = answers.description;
+  const createTemplate = answers.createTemplate;
+  if (!themeExists(themeName)) {
+    logger.error(`Theme "${themeName}" does not exist.`);
+    process.exit(1);
+  }
+  const data = {
+    sectionName,
+    sectionNamePascal: toPascalCase(sectionName),
+    themeName,
+    category,
+    displayName,
+    description
+  };
+  logger.startSpinner("Creating section files...");
+  try {
+    const themePath = path__default.default.join(getThemesDir(), themeName);
+    const sectionPath = path__default.default.join(themePath, "sections", sectionName);
+    const schemaContent = generateSectionSchema(data);
+    await writeFile(
+      path__default.default.join(sectionPath, `${sectionName}.schema.ts`),
+      schemaContent
+    );
+    if (createTemplate) {
+      const templateContent = generateSectionTemplate(data);
+      await writeFile(
+        path__default.default.join(sectionPath, `${sectionName}-default.tsx`),
+        templateContent
+      );
+    }
+    const indexContent = generateSectionIndex(data, createTemplate);
+    await writeFile(path__default.default.join(sectionPath, "index.ts"), indexContent);
+    logger.stopSpinner(true, "Section files created successfully!");
+    logger.newLine();
+    logger.section("Next steps:");
+    logger.log(
+      `  1. Edit schema: ${path__default.default.relative(process.cwd(), path__default.default.join(sectionPath, `${sectionName}.schema.ts`))}`
+    );
+    if (createTemplate) {
+      logger.log(
+        `  2. Edit template: ${path__default.default.relative(process.cwd(), path__default.default.join(sectionPath, `${sectionName}-default.tsx`))}`
+      );
+    }
+    logger.log(
+      `  3. Add to theme manifest: ${path__default.default.relative(process.cwd(), path__default.default.join(themePath, "manifest.ts"))}`
+    );
+    logger.newLine();
+    logger.success("Section created successfully!");
+  } catch (error) {
+    logger.stopSpinner(false, "Failed to create section");
+    logger.error(
+      error instanceof Error ? error.message : "Unknown error occurred"
+    );
+    process.exit(1);
+  }
+}
+function generateSectionSchema(data) {
+  return `import type { SectionSchema } from "@duongthiu/onex-core";
+
+/**
+ * ${data.displayName} Section Schema
+ * ${data.description}
+ */
+export const ${data.sectionName}Schema: SectionSchema = {
+  type: "${data.sectionName}",
+  name: "${data.displayName}",
+  description: "${data.description}",
+  category: "${data.category}",
+  icon: "layout",
+
+  // Available template variants
+  templates: [
+    {
+      id: "default",
+      name: "Default",
+      description: "Default ${data.sectionName} layout",
+      isDefault: true,
+    },
+  ],
+
+  // Section-level settings
+  settings: [
+    {
+      id: "backgroundColor",
+      type: "color",
+      label: "Background Color",
+      category: "style",
+    },
+    {
+      id: "padding",
+      type: "select",
+      label: "Padding",
+      category: "style",
+      options: [
+        { label: "None", value: "none" },
+        { label: "Small", value: "sm" },
+        { label: "Medium", value: "md" },
+        { label: "Large", value: "lg" },
+      ],
+      defaultValue: "md",
+    },
+  ],
+
+  // Default settings values
+  defaults: {
+    backgroundColor: "#ffffff",
+    padding: "md",
+  },
+
+  // Allowed blocks (optional)
+  allowedBlocks: [],
+
+  // Maximum number of instances on a page (optional)
+  maxInstances: undefined,
+};
+`;
+}
+function generateSectionTemplate(data) {
+  return `import React from "react";
+import type { SectionComponentProps } from "@duongthiu/onex-core";
+
+/**
+ * ${data.displayName} - Default Template
+ */
+export function ${data.sectionNamePascal}Default({
+  section,
+  isEditing = false,
+}: SectionComponentProps) {
+  const { settings = {} } = section;
+  const backgroundColor = settings.backgroundColor as string || "#ffffff";
+  const padding = settings.padding as string || "md";
+
+  // Map padding values to Tailwind classes
+  const paddingClasses = {
+    none: "",
+    sm: "py-8",
+    md: "py-16",
+    lg: "py-24",
+  };
+
+  return (
+    <section
+      className={\`${data.sectionName}-section \${paddingClasses[padding as keyof typeof paddingClasses] || paddingClasses.md}\`}
+      style={{ backgroundColor }}
+      data-section-id={section.id}
+      data-section-type={section.type}
+    >
+      <div className="container mx-auto px-4">
+        {/* TODO: Implement section content */}
+        <div className="text-center">
+          <h2 className="text-3xl font-bold">${data.displayName}</h2>
+          <p className="mt-4 text-gray-600">
+            Start building your section here
+          </p>
+        </div>
+
+        {/* Render blocks if any */}
+        {section.blocks && section.blocks.length > 0 && (
+          <div className="mt-8">
+            {/* TODO: Render blocks */}
+          </div>
+        )}
+
+        {/* Render components if any */}
+        {section.components && section.components.length > 0 && (
+          <div className="mt-8">
+            {/* TODO: Render components */}
+          </div>
+        )}
+      </div>
+    </section>
+  );
+}
+`;
+}
+function generateSectionIndex(data, hasTemplate) {
+  return `/**
+ * ${data.sectionNamePascal} Section
+ */
+
+export { ${data.sectionName}Schema } from "./${data.sectionName}.schema";
+${hasTemplate ? `export { ${data.sectionNamePascal}Default } from "./${data.sectionName}-default";` : ""}
+`;
+}
+async function createBlockCommand(name, options) {
+  logger.header("Create New Block");
+  ensureOneXProject();
+  const blockName = toKebabCase(name);
+  if (!validateName(blockName)) {
+    logger.error(
+      `Invalid block name: ${blockName}. Use kebab-case (e.g., product-card, testimonial-item)`
+    );
+    process.exit(1);
+  }
+  const answers = await inquirer__default.default.prompt([
+    {
+      type: "list",
+      name: "scope",
+      message: "Block scope:",
+      choices: [
+        { name: "Shared (available to all themes)", value: "shared" },
+        { name: "Theme-specific", value: "theme" }
+      ],
+      default: "shared"
+    },
+    {
+      type: "list",
+      name: "theme",
+      message: "Which theme?",
+      choices: listThemes(),
+      when: (answers2) => answers2.scope === "theme" && !options.theme
+    },
+    {
+      type: "input",
+      name: "displayName",
+      message: "Display name for this block:",
+      default: toPascalCase(blockName).replace(/([A-Z])/g, " $1").trim()
+    },
+    {
+      type: "input",
+      name: "description",
+      message: "Block description:",
+      default: `${toPascalCase(blockName)} block`
+    },
+    {
+      type: "confirm",
+      name: "hasComponents",
+      message: "Does this block contain components?",
+      default: true
+    },
+    {
+      type: "confirm",
+      name: "hasNestedBlocks",
+      message: "Does this block support nested blocks?",
+      default: false
+    }
+  ]);
+  const scope = answers.scope;
+  const themeName = options.theme || answers.theme;
+  const displayName = answers.displayName;
+  const description = answers.description;
+  const hasComponents = answers.hasComponents;
+  const hasNestedBlocks = answers.hasNestedBlocks;
+  if (scope === "theme" && !themeExists(themeName)) {
+    logger.error(`Theme "${themeName}" does not exist.`);
+    process.exit(1);
+  }
+  const data = {
+    blockName,
+    blockNamePascal: toPascalCase(blockName),
+    displayName,
+    description,
+    hasComponents,
+    hasNestedBlocks,
+    scope,
+    themeName
+  };
+  logger.startSpinner("Creating block files...");
+  try {
+    const blockPath = scope === "shared" ? path__default.default.join(getFeaturesDir(), "blocks", blockName) : path__default.default.join(getThemesDir(), themeName, "blocks", blockName);
+    const schemaContent = generateBlockSchema(data);
+    await writeFile(
+      path__default.default.join(blockPath, `${blockName}.schema.ts`),
+      schemaContent
+    );
+    const componentContent = generateBlockComponent(data);
+    await writeFile(path__default.default.join(blockPath, `${blockName}.tsx`), componentContent);
+    const indexContent = generateBlockIndex(data);
+    await writeFile(path__default.default.join(blockPath, "index.ts"), indexContent);
+    logger.stopSpinner(true, "Block files created successfully!");
+    logger.newLine();
+    logger.section("Next steps:");
+    logger.log(
+      `  1. Edit schema: ${path__default.default.relative(process.cwd(), path__default.default.join(blockPath, `${blockName}.schema.ts`))}`
+    );
+    logger.log(
+      `  2. Edit component: ${path__default.default.relative(process.cwd(), path__default.default.join(blockPath, `${blockName}.tsx`))}`
+    );
+    logger.log(
+      `  3. Register in block registry: src/lib/registry/block-registry.ts`
+    );
+    logger.newLine();
+    logger.success("Block created successfully!");
+  } catch (error) {
+    logger.stopSpinner(false, "Failed to create block");
+    logger.error(
+      error instanceof Error ? error.message : "Unknown error occurred"
+    );
+    process.exit(1);
+  }
+}
+function generateBlockSchema(data) {
+  return `import type { BlockDefinition } from "@duongthiu/onex-core";
+
+/**
+ * ${data.displayName} Block Schema
+ * ${data.description}
+ */
+export const ${data.blockName}Definition: BlockDefinition = {
+  type: "${data.blockName}",
+  name: "${data.displayName}",
+  description: "${data.description}",
+  icon: "square",
+
+  // Block settings
+  settings: [
+    {
+      id: "title",
+      type: "text",
+      label: "Title",
+      category: "content",
+    },
+    {
+      id: "alignment",
+      type: "select",
+      label: "Alignment",
+      category: "style",
+      options: [
+        { label: "Left", value: "left" },
+        { label: "Center", value: "center" },
+        { label: "Right", value: "right" },
+      ],
+      defaultValue: "left",
+    },
+  ],
+
+  // Default settings values
+  defaults: {
+    title: "${data.displayName}",
+    alignment: "left",
+  },
+
+  ${data.hasComponents ? `// This block can contain components
+  allowsComponents: true,` : ""}
+  ${data.hasNestedBlocks ? `// This block can contain nested blocks
+  allowsNestedBlocks: true,` : ""}
+};
+`;
+}
+function generateBlockComponent(data) {
+  return `import React from "react";
+import type { BlockComponentProps } from "@duongthiu/onex-core";
+
+/**
+ * ${data.displayName} Block Component
+ */
+export function ${data.blockNamePascal}({
+  block,
+  isEditing = false,
+}: BlockComponentProps) {
+  const { settings = {} } = block;
+  const title = settings.title as string || "${data.displayName}";
+  const alignment = settings.alignment as string || "left";
+
+  const alignmentClasses = {
+    left: "text-left",
+    center: "text-center",
+    right: "text-right",
+  };
+
+  return (
+    <div
+      className={\`${data.blockName}-block \${alignmentClasses[alignment as keyof typeof alignmentClasses]}\`}
+      data-block-id={block.id}
+      data-block-type={block.type}
+    >
+      {title && <h3 className="text-xl font-semibold mb-4">{title}</h3>}
+
+      {/* TODO: Implement block content */}
+      <div className="block-content">
+        <p className="text-gray-600">Block content goes here</p>
+      </div>
+
+      ${data.hasComponents ? `{/* Render components if any */}
+      {block.components && block.components.length > 0 && (
+        <div className="block-components mt-4">
+          {/* TODO: Render components using ComponentRenderer */}
+        </div>
+      )}` : ""}
+
+      ${data.hasNestedBlocks ? `{/* Render nested blocks if any */}
+      {block.blocks && block.blocks.length > 0 && (
+        <div className="nested-blocks mt-4">
+          {/* TODO: Render nested blocks using BlockRenderer */}
+        </div>
+      )}` : ""}
+    </div>
+  );
+}
+`;
+}
+function generateBlockIndex(data) {
+  return `/**
+ * ${data.blockNamePascal} Block
+ */
+
+export { ${data.blockName}Definition } from "./${data.blockName}.schema";
+export { ${data.blockNamePascal} } from "./${data.blockName}";
+`;
+}
+async function createComponentCommand(name, options) {
+  logger.header("Create New Component");
+  ensureOneXProject();
+  const componentName = toKebabCase(name);
+  if (!validateName(componentName)) {
+    logger.error(
+      `Invalid component name: ${componentName}. Use kebab-case (e.g., button, icon-badge)`
+    );
+    process.exit(1);
+  }
+  const answers = await inquirer__default.default.prompt([
+    {
+      type: "list",
+      name: "componentType",
+      message: "Component type:",
+      choices: [
+        { name: "UI Component (button, badge, etc.)", value: "ui" },
+        { name: "Form Component (input, select, etc.)", value: "form" },
+        { name: "Layout Component (container, grid, etc.)", value: "layout" },
+        {
+          name: "Content Component (heading, paragraph, etc.)",
+          value: "content"
+        }
+      ],
+      when: !options.type
+    },
+    {
+      type: "input",
+      name: "displayName",
+      message: "Display name for this component:",
+      default: toPascalCase(componentName).replace(/([A-Z])/g, " $1").trim()
+    },
+    {
+      type: "input",
+      name: "description",
+      message: "Component description:",
+      default: `${toPascalCase(componentName)} component`
+    }
+  ]);
+  const componentType = options.type || answers.componentType;
+  const displayName = answers.displayName;
+  const description = answers.description;
+  const data = {
+    componentName,
+    componentNamePascal: toPascalCase(componentName),
+    componentType,
+    displayName,
+    description
+  };
+  logger.startSpinner("Creating component files...");
+  try {
+    const componentPath = path__default.default.join(
+      getFeaturesDir(),
+      "components",
+      componentName
+    );
+    const schemaContent = generateComponentSchema(data);
+    await writeFile(
+      path__default.default.join(componentPath, `${componentName}.schema.ts`),
+      schemaContent
+    );
+    const componentContent = generateComponent(data);
+    await writeFile(
+      path__default.default.join(componentPath, `${componentName}.tsx`),
+      componentContent
+    );
+    const indexContent = generateComponentIndex(data);
+    await writeFile(path__default.default.join(componentPath, "index.ts"), indexContent);
+    logger.stopSpinner(true, "Component files created successfully!");
+    logger.newLine();
+    logger.section("Next steps:");
+    logger.log(
+      `  1. Edit schema: ${path__default.default.relative(process.cwd(), path__default.default.join(componentPath, `${componentName}.schema.ts`))}`
+    );
+    logger.log(
+      `  2. Edit component: ${path__default.default.relative(process.cwd(), path__default.default.join(componentPath, `${componentName}.tsx`))}`
+    );
+    logger.log(
+      `  3. Register in component registry: src/lib/registry/component-registry.ts`
+    );
+    logger.newLine();
+    logger.success("Component created successfully!");
+  } catch (error) {
+    logger.stopSpinner(false, "Failed to create component");
+    logger.error(
+      error instanceof Error ? error.message : "Unknown error occurred"
+    );
+    process.exit(1);
+  }
+}
+function generateComponentSchema(data) {
+  return `import type { ComponentDefinition } from "@duongthiu/onex-core";
+
+/**
+ * ${data.displayName} Component Schema
+ * ${data.description}
+ */
+export const ${data.componentName}Definition: ComponentDefinition = {
+  type: "${data.componentName}",
+  name: "${data.displayName}",
+  description: "${data.description}",
+  category: "${data.componentType}",
+  icon: "square",
+
+  // Content fields (what the component displays)
+  contentFields: [
+    {
+      id: "text",
+      type: "text",
+      label: "Text",
+      defaultValue: "${data.displayName}",
+    },
+  ],
+
+  // Style fields (how the component looks)
+  styleFields: [
+    {
+      id: "variant",
+      type: "select",
+      label: "Variant",
+      options: [
+        { label: "Default", value: "default" },
+        { label: "Primary", value: "primary" },
+        { label: "Secondary", value: "secondary" },
+      ],
+      defaultValue: "default",
+    },
+    {
+      id: "size",
+      type: "select",
+      label: "Size",
+      options: [
+        { label: "Small", value: "sm" },
+        { label: "Medium", value: "md" },
+        { label: "Large", value: "lg" },
+      ],
+      defaultValue: "md",
+    },
+  ],
+
+  // Default content values
+  defaultContent: {
+    text: "${data.displayName}",
+  },
+
+  // Default style values
+  defaultStyle: {
+    variant: "default",
+    size: "md",
+  },
+};
+`;
+}
+function generateComponent(data) {
+  return `import React from "react";
+import type { ComponentProps } from "@duongthiu/onex-core";
+
+/**
+ * ${data.displayName} Component
+ */
+export function ${data.componentNamePascal}({
+  component,
+  isEditing = false,
+}: ComponentProps) {
+  const { content = {}, style = {} } = component;
+  const text = content.text as string || "${data.displayName}";
+  const variant = style.variant as string || "default";
+  const size = style.size as string || "md";
+
+  // Variant classes
+  const variantClasses = {
+    default: "bg-gray-100 text-gray-900",
+    primary: "bg-blue-600 text-white",
+    secondary: "bg-gray-600 text-white",
+  };
+
+  // Size classes
+  const sizeClasses = {
+    sm: "text-sm px-3 py-1",
+    md: "text-base px-4 py-2",
+    lg: "text-lg px-6 py-3",
+  };
+
+  return (
+    <div
+      className={\`${data.componentName} \${variantClasses[variant as keyof typeof variantClasses]} \${sizeClasses[size as keyof typeof sizeClasses]} inline-block rounded\`}
+      data-component-id={component.id}
+      data-component-type={component.type}
+    >
+      {text}
+    </div>
+  );
+}
+`;
+}
+function generateComponentIndex(data) {
+  return `/**
+ * ${data.componentNamePascal} Component
+ */
+
+export { ${data.componentName}Definition } from "./${data.componentName}.schema";
+export { ${data.componentNamePascal} } from "./${data.componentName}";
+`;
+}
+async function listCommand(options) {
+  logger.header("OneX Project Inventory");
+  ensureOneXProject();
+  const showAll = !options.sections && !options.blocks && !options.components;
+  if (showAll || options.sections) {
+    await listSections(options.theme);
+  }
+  if (showAll || options.blocks) {
+    await listBlocks(options.theme);
+  }
+  if (showAll || options.components) {
+    await listComponents();
+  }
+  if (showAll) {
+    await listThemesInfo();
+  }
+}
+async function listSections(themeFilter) {
+  logger.section("\u{1F4C4} Sections");
+  const themes = themeFilter ? [themeFilter] : listThemes();
+  if (themes.length === 0) {
+    logger.warning("No themes found");
+    return;
+  }
+  for (const theme of themes) {
+    const sectionsDir = path__default.default.join(getThemesDir(), theme, "sections");
+    if (!fs__default.default.existsSync(sectionsDir)) {
+      continue;
+    }
+    const sections = fs__default.default.readdirSync(sectionsDir).filter((name) => {
+      const sectionPath = path__default.default.join(sectionsDir, name);
+      return fs__default.default.statSync(sectionPath).isDirectory() && fs__default.default.existsSync(path__default.default.join(sectionPath, "index.ts"));
+    });
+    if (sections.length > 0) {
+      logger.log(chalk4__default.default.cyan(`
+  ${theme}:`));
+      sections.forEach((section) => {
+        logger.log(`    \u2022 ${section}`);
+      });
+    }
+  }
+  logger.newLine();
+}
+async function listBlocks(themeFilter) {
+  logger.section("\u{1F9F1} Blocks");
+  const sharedBlocksDir = path__default.default.join(getFeaturesDir(), "blocks");
+  if (fs__default.default.existsSync(sharedBlocksDir)) {
+    const sharedBlocks = fs__default.default.readdirSync(sharedBlocksDir).filter((name) => {
+      const blockPath = path__default.default.join(sharedBlocksDir, name);
+      return fs__default.default.statSync(blockPath).isDirectory() && fs__default.default.existsSync(path__default.default.join(blockPath, "index.ts"));
+    });
+    if (sharedBlocks.length > 0) {
+      logger.log(chalk4__default.default.cyan("\n  Shared:"));
+      sharedBlocks.forEach((block) => {
+        logger.log(`    \u2022 ${block}`);
+      });
+    }
+  }
+  const themes = themeFilter ? [themeFilter] : listThemes();
+  for (const theme of themes) {
+    const blocksDir = path__default.default.join(getThemesDir(), theme, "blocks");
+    if (!fs__default.default.existsSync(blocksDir)) {
+      continue;
+    }
+    const blocks = fs__default.default.readdirSync(blocksDir).filter((name) => {
+      const blockPath = path__default.default.join(blocksDir, name);
+      return fs__default.default.statSync(blockPath).isDirectory() && fs__default.default.existsSync(path__default.default.join(blockPath, "index.ts"));
+    });
+    if (blocks.length > 0) {
+      logger.log(chalk4__default.default.cyan(`
+  ${theme}:`));
+      blocks.forEach((block) => {
+        logger.log(`    \u2022 ${block}`);
+      });
+    }
+  }
+  logger.newLine();
+}
+async function listComponents() {
+  logger.section("\u2699\uFE0F  Components");
+  const componentsDir = path__default.default.join(getFeaturesDir(), "components");
+  if (!fs__default.default.existsSync(componentsDir)) {
+    logger.warning("No components directory found");
+    return;
+  }
+  const components = fs__default.default.readdirSync(componentsDir).filter((name) => {
+    const componentPath = path__default.default.join(componentsDir, name);
+    return fs__default.default.statSync(componentPath).isDirectory() && fs__default.default.existsSync(path__default.default.join(componentPath, "index.ts"));
+  });
+  if (components.length === 0) {
+    logger.warning("No components found");
+    return;
+  }
+  logger.log("");
+  components.forEach((component) => {
+    logger.log(`  \u2022 ${component}`);
+  });
+  logger.newLine();
+}
+async function listThemesInfo() {
+  logger.section("\u{1F3A8} Themes");
+  const themes = listThemes();
+  if (themes.length === 0) {
+    logger.warning("No themes found");
+    return;
+  }
+  logger.log("");
+  for (const theme of themes) {
+    const manifestPath = path__default.default.join(getThemesDir(), theme, "manifest.ts");
+    const manifestContent = fs__default.default.readFileSync(manifestPath, "utf-8");
+    const nameMatch = manifestContent.match(/name:\s*["'](.+)["']/);
+    const versionMatch = manifestContent.match(/version:\s*["'](.+)["']/);
+    const descMatch = manifestContent.match(/description:\s*["'](.+)["']/);
+    const displayName = nameMatch ? nameMatch[1] : theme;
+    const version = versionMatch ? versionMatch[1] : "unknown";
+    const description = descMatch ? descMatch[1] : "";
+    logger.log(chalk4__default.default.cyan(`  ${displayName}`) + chalk4__default.default.gray(` (v${version})`));
+    if (description) {
+      logger.log(chalk4__default.default.gray(`    ${description}`));
+    }
+  }
+  logger.newLine();
+}
+async function buildCommand(options) {
+  logger.header("Build Theme");
+  let themePath;
+  let themeName;
+  if (options.theme) {
+    themeName = options.theme;
+    try {
+      const workspaceThemePath = path__default.default.join(getThemesDir(), themeName);
+      if (fs__default.default.existsSync(workspaceThemePath)) {
+        themePath = workspaceThemePath;
+      } else {
+        themePath = path__default.default.join(process.cwd(), themeName);
+      }
+    } catch (e) {
+      themePath = path__default.default.join(process.cwd(), themeName);
+    }
+    if (!fs__default.default.existsSync(themePath)) {
+      logger.error(`Theme "${themeName}" not found.`);
+      process.exit(1);
+    }
+  } else {
+    const manifestPath = path__default.default.join(process.cwd(), "manifest.ts");
+    if (fs__default.default.existsSync(manifestPath)) {
+      themePath = process.cwd();
+      themeName = path__default.default.basename(themePath);
+      logger.info(`Building current theme: ${themeName}`);
+    } else {
+      logger.error(
+        "Not in a theme directory and no --theme specified. Run from theme root or use --theme flag."
+      );
+      process.exit(1);
+    }
+  }
+  const packageJsonPath = path__default.default.join(themePath, "package.json");
+  const hasPkgJson = fs__default.default.existsSync(packageJsonPath);
+  if (!hasPkgJson) {
+    logger.warning(
+      "No package.json found in theme. Skipping build (themes in monorepo are built via turbo)."
+    );
+    logger.newLine();
+    logger.info("To build all packages, run:");
+    logger.log("  pnpm turbo build");
+    logger.newLine();
+    logger.info("To build specific theme components:");
+    logger.log("  pnpm turbo build --filter=./src/themes/*");
+    return;
+  }
+  logger.newLine();
+  logger.section("Build Steps");
+  logger.startSpinner("Running type check...");
+  const typeCheckSuccess = await runCommand("pnpm", ["type-check"], themePath);
+  if (!typeCheckSuccess) {
+    logger.stopSpinner(false, "Type check failed");
+    logger.error("Fix type errors before building.");
+    process.exit(1);
+  }
+  logger.stopSpinner(true, "Type check passed");
+  logger.startSpinner("Running linter...");
+  const lintSuccess = await runCommand("pnpm", ["lint"], themePath);
+  if (!lintSuccess) {
+    logger.stopSpinner(false, "Lint failed");
+    logger.error("Fix lint errors before building.");
+    process.exit(1);
+  }
+  logger.stopSpinner(true, "Lint passed");
+  const buildArgs = options.watch ? ["build", "--watch"] : ["build"];
+  logger.startSpinner(
+    options.watch ? "Building (watch mode)..." : "Building..."
+  );
+  const buildSuccess = await runCommand("pnpm", buildArgs, themePath);
+  if (!buildSuccess && !options.watch) {
+    logger.stopSpinner(false, "Build failed");
+    process.exit(1);
+  }
+  if (!options.watch) {
+    logger.stopSpinner(true, "Build complete");
+    logger.newLine();
+    logger.success("\u2713 Theme built successfully!");
+    logger.newLine();
+    logger.info(`Theme: ${themeName}`);
+    const distPath = path__default.default.join(themePath, "dist");
+    if (fs__default.default.existsSync(distPath)) {
+      logger.log(`Output: ${path__default.default.relative(process.cwd(), distPath)}`);
+      const files = fs__default.default.readdirSync(distPath);
+      logger.log(`Files: ${files.length}`);
+    }
+  }
+}
+function runCommand(command, args, cwd) {
+  return new Promise((resolve) => {
+    const proc = child_process.spawn(command, args, {
+      cwd,
+      stdio: "pipe",
+      shell: true
+    });
+    let hasError = false;
+    proc.stderr.on("data", (data) => {
+      const message = data.toString();
+      if (message.includes("error") || message.includes("Error") || message.includes("ERROR")) {
+        hasError = true;
+      }
+    });
+    proc.on("close", (code) => {
+      resolve(code === 0 && !hasError);
+    });
+    proc.on("error", () => {
+      resolve(false);
+    });
+  });
+}
+function getS3Client() {
+  const adapterMode = (process.env.ADAPTER_MODE || "aws").trim().toLowerCase();
+  if (adapterMode === "vps") {
+    const endpoint = process.env.MINIO_ENDPOINT || "localhost:9000";
+    const secure = process.env.MINIO_SECURE === "true";
+    const endpointUrl = endpoint.startsWith("http") ? endpoint : `${secure ? "https" : "http"}://${endpoint}`;
+    return new clientS3.S3Client({
+      endpoint: endpointUrl,
+      region: "us-east-1",
+      // MinIO doesn't use real regions
+      credentials: {
+        accessKeyId: process.env.MINIO_ACCESS_KEY || "minioadmin",
+        secretAccessKey: process.env.MINIO_SECRET_KEY || "minioadmin"
+      },
+      forcePathStyle: true
+      // Required for MinIO
+    });
+  }
+  if (adapterMode === "local") {
+    return new clientS3.S3Client({
+      endpoint: "http://localhost:4569",
+      region: "ap-southeast-1",
+      credentials: {
+        accessKeyId: "S3RVER",
+        secretAccessKey: "S3RVER"
+      },
+      forcePathStyle: true
+    });
+  }
+  return new clientS3.S3Client({
+    region: process.env.AWS_REGION || "ap-southeast-1"
+  });
+}
+function getBucketName(env) {
+  if (process.env.BUCKET_NAME) {
+    return process.env.BUCKET_NAME;
+  }
+  const environment = env || process.env.ENVIRONMENT || "staging";
+  return environment === "production" ? "onex-themes-prod" : "onex-themes-staging";
+}
+async function findCompiledThemeDir(themeId, version) {
+  const searchPaths = [
+    path__default.default.resolve(process.cwd(), "dist"),
+    path__default.default.resolve(
+      process.cwd(),
+      `../../apps/api-server/compiled-themes/${themeId}@${version}`
+    ),
+    path__default.default.resolve(
+      process.cwd(),
+      `../api-server/compiled-themes/${themeId}@${version}`
+    )
+  ];
+  for (const dir of searchPaths) {
+    if (await fs__default.default.pathExists(dir)) {
+      const manifestPath = path__default.default.join(dir, "manifest.json");
+      if (await fs__default.default.pathExists(manifestPath)) {
+        return dir;
+      }
+    }
+  }
+  return null;
+}
+async function readManifest() {
+  var _a;
+  const manifestTsPath = path__default.default.resolve(process.cwd(), "manifest.ts");
+  if (await fs__default.default.pathExists(manifestTsPath)) {
+    try {
+      const module = await import(manifestTsPath);
+      return module.default || module;
+    } catch (error) {
+      logger.warning("Failed to import manifest.ts, trying package.json");
+    }
+  }
+  const packageJsonPath = path__default.default.resolve(process.cwd(), "package.json");
+  if (await fs__default.default.pathExists(packageJsonPath)) {
+    const pkg = await fs__default.default.readJson(packageJsonPath);
+    return {
+      themeId: ((_a = pkg.name) == null ? void 0 : _a.replace("@onex-themes/", "")) || "unknown",
+      version: pkg.version || "1.0.0"
+    };
+  }
+  throw new Error(
+    "No manifest.ts or package.json found. Are you in a theme directory?"
+  );
+}
+function getContentType(filename) {
+  const ext = path__default.default.extname(filename).toLowerCase();
+  const types = {
+    ".js": "application/javascript",
+    ".mjs": "application/javascript",
+    ".json": "application/json",
+    ".css": "text/css",
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".svg": "image/svg+xml",
+    ".woff2": "font/woff2",
+    ".woff": "font/woff",
+    ".ttf": "font/ttf",
+    ".ts": "text/plain"
+  };
+  return types[ext] || "application/octet-stream";
+}
+async function uploadFile(s3Client, bucket, themeId, version, baseDir, file) {
+  const filePath = path__default.default.join(baseDir, file);
+  const content = await fs__default.default.readFile(filePath);
+  const s3Key = `themes/${themeId}/${version}/${file}`;
+  await s3Client.send(
+    new clientS3.PutObjectCommand({
+      Bucket: bucket,
+      Key: s3Key,
+      Body: content,
+      ContentType: getContentType(file)
+    })
+  );
+}
+async function updateLatestPointer(s3Client, bucket, themeId, version) {
+  const latestData = {
+    version,
+    uploadedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  await s3Client.send(
+    new clientS3.PutObjectCommand({
+      Bucket: bucket,
+      Key: `themes/${themeId}/latest.json`,
+      Body: JSON.stringify(latestData, null, 2),
+      ContentType: "application/json"
+    })
+  );
+}
+async function uploadCommand(options) {
+  logger.header("Upload Theme to S3");
+  ensureOneXProject();
+  const spinner = ora__default.default("Preparing theme upload...").start();
+  try {
+    const manifest = await readManifest();
+    const themeId = manifest.themeId;
+    const version = options.version || manifest.version || "1.0.0";
+    spinner.text = `Found theme: ${themeId}@${version}`;
+    const bucket = options.bucket || getBucketName(options.environment);
+    const s3Client = getS3Client();
+    const compiledDir = await findCompiledThemeDir(themeId, version);
+    if (!compiledDir) {
+      spinner.fail(
+        chalk4__default.default.red(
+          `Compiled theme not found for ${themeId}@${version}. Run 'onex build' first.`
+        )
+      );
+      logger.info(
+        chalk4__default.default.gray(
+          `Expected locations:
+  - ./dist/
+  - ../../apps/api-server/compiled-themes/${themeId}@${version}/`
+        )
+      );
+      process.exit(1);
+    }
+    spinner.succeed(`Found compiled theme at: ${compiledDir}`);
+    spinner.start(`Scanning files...`);
+    const files = await glob.glob("**/*", {
+      cwd: compiledDir,
+      nodir: true,
+      dot: true
+    });
+    if (files.length === 0) {
+      spinner.fail(chalk4__default.default.red("No files found in compiled theme directory"));
+      process.exit(1);
+    }
+    spinner.succeed(`Found ${files.length} files to upload`);
+    if (options.dryRun) {
+      spinner.info(chalk4__default.default.yellow("Dry run mode - no files will be uploaded"));
+      console.log(chalk4__default.default.gray("\nFiles to upload:"));
+      const displayFiles = files.slice(0, 10);
+      displayFiles.forEach((file) => console.log(chalk4__default.default.gray(`  - ${file}`)));
+      if (files.length > 10) {
+        console.log(chalk4__default.default.gray(`  ... and ${files.length - 10} more files
+`));
+      }
+      console.log(chalk4__default.default.cyan(`
+S3 bucket: ${bucket}`));
+      console.log(
+        chalk4__default.default.cyan(`S3 path: s3://${bucket}/themes/${themeId}/${version}/
+`)
+      );
+      return;
+    }
+    spinner.start(`Uploading to S3: ${bucket}...`);
+    let uploaded = 0;
+    const total = files.length;
+    const batchSize = 10;
+    for (let i = 0; i < files.length; i += batchSize) {
+      const batch = files.slice(i, i + batchSize);
+      await Promise.all(
+        batch.map(async (file) => {
+          await uploadFile(
+            s3Client,
+            bucket,
+            themeId,
+            version,
+            compiledDir,
+            file
+          );
+          uploaded++;
+          spinner.text = `Uploading... ${uploaded}/${total} files (${Math.round(uploaded / total * 100)}%)`;
+        })
+      );
+    }
+    spinner.succeed(`Uploaded ${total} files to S3`);
+    spinner.start("Updating latest.json pointer...");
+    await updateLatestPointer(s3Client, bucket, themeId, version);
+    spinner.succeed("Updated latest.json pointer");
+    console.log();
+    logger.success(chalk4__default.default.green.bold("\u2705 Theme uploaded successfully!"));
+    console.log();
+    console.log(
+      chalk4__default.default.cyan("   Theme:   ") + chalk4__default.default.white(`${themeId}@${version}`)
+    );
+    console.log(chalk4__default.default.cyan("   Bucket:  ") + chalk4__default.default.white(bucket));
+    console.log(chalk4__default.default.cyan("   Files:   ") + chalk4__default.default.white(total));
+    console.log(
+      chalk4__default.default.cyan("   Path:    ") + chalk4__default.default.gray(`s3://${bucket}/themes/${themeId}/${version}/`)
+    );
+    console.log();
+  } catch (error) {
+    spinner.fail(chalk4__default.default.red(`Upload failed: ${error.message}`));
+    logger.error(error.stack || error.message);
+    process.exit(1);
+  }
+}
+function getS3Client2() {
+  const adapterMode = (process.env.ADAPTER_MODE || "aws").trim().toLowerCase();
+  if (adapterMode === "vps") {
+    const endpoint = process.env.MINIO_ENDPOINT || "localhost:9000";
+    const secure = process.env.MINIO_SECURE === "true";
+    const endpointUrl = endpoint.startsWith("http") ? endpoint : `${secure ? "https" : "http"}://${endpoint}`;
+    return new clientS3.S3Client({
+      endpoint: endpointUrl,
+      region: "us-east-1",
+      credentials: {
+        accessKeyId: process.env.MINIO_ACCESS_KEY || "minioadmin",
+        secretAccessKey: process.env.MINIO_SECRET_KEY || "minioadmin"
+      },
+      forcePathStyle: true
+    });
+  }
+  if (adapterMode === "local") {
+    return new clientS3.S3Client({
+      endpoint: "http://localhost:4569",
+      region: "ap-southeast-1",
+      credentials: {
+        accessKeyId: "S3RVER",
+        secretAccessKey: "S3RVER"
+      },
+      forcePathStyle: true
+    });
+  }
+  return new clientS3.S3Client({
+    region: process.env.AWS_REGION || "ap-southeast-1"
+  });
+}
+function getBucketName2(env) {
+  if (process.env.BUCKET_NAME) {
+    return process.env.BUCKET_NAME;
+  }
+  const environment = env || process.env.ENVIRONMENT || "staging";
+  return environment === "production" ? "onex-themes-prod" : "onex-themes-staging";
+}
+async function streamToString(stream) {
+  const chunks = [];
+  try {
+    for (var iter = __forAwait(stream), more, temp, error; more = !(temp = await iter.next()).done; more = false) {
+      const chunk = temp.value;
+      chunks.push(Buffer.from(chunk));
+    }
+  } catch (temp) {
+    error = [temp];
+  } finally {
+    try {
+      more && (temp = iter.return) && await temp.call(iter);
+    } finally {
+      if (error)
+        throw error[0];
+    }
+  }
+  return Buffer.concat(chunks).toString("utf-8");
+}
+async function streamToBuffer(stream) {
+  const chunks = [];
+  try {
+    for (var iter = __forAwait(stream), more, temp, error; more = !(temp = await iter.next()).done; more = false) {
+      const chunk = temp.value;
+      chunks.push(Buffer.from(chunk));
+    }
+  } catch (temp) {
+    error = [temp];
+  } finally {
+    try {
+      more && (temp = iter.return) && await temp.call(iter);
+    } finally {
+      if (error)
+        throw error[0];
+    }
+  }
+  return Buffer.concat(chunks);
+}
+async function resolveLatestVersion(s3Client, bucket, themeId) {
+  try {
+    const response = await s3Client.send(
+      new clientS3.GetObjectCommand({
+        Bucket: bucket,
+        Key: `themes/${themeId}/latest.json`
+      })
+    );
+    const body = await streamToString(response.Body);
+    const data = JSON.parse(body);
+    return data.version;
+  } catch (error) {
+    throw new Error(
+      `Failed to resolve latest version for theme "${themeId}": ${error.message}`
+    );
+  }
+}
+async function downloadManifest(s3Client, bucket, themeId, version) {
+  try {
+    const response = await s3Client.send(
+      new clientS3.GetObjectCommand({
+        Bucket: bucket,
+        Key: `themes/${themeId}/${version}/manifest.json`
+      })
+    );
+    const body = await streamToString(response.Body);
+    return JSON.parse(body);
+  } catch (error) {
+    throw new Error(
+      `Failed to download manifest for ${themeId}@${version}: ${error.message}
+The theme may not exist in S3 bucket "${bucket}".`
+    );
+  }
+}
+async function downloadFile(s3Client, bucket, themeId, version, file, outputDir) {
+  const s3Key = `themes/${themeId}/${version}/${file}`;
+  const localPath = path__default.default.join(outputDir, file);
+  await fs__default.default.ensureDir(path__default.default.dirname(localPath));
+  try {
+    const response = await s3Client.send(
+      new clientS3.GetObjectCommand({
+        Bucket: bucket,
+        Key: s3Key
+      })
+    );
+    const content = await streamToBuffer(response.Body);
+    await fs__default.default.writeFile(localPath, content);
+  } catch (error) {
+    throw new Error(`Failed to download ${file}: ${error.message}`);
+  }
+}
+function collectFilesToDownload(manifest) {
+  const files = ["manifest.json"];
+  if (manifest.output) {
+    if (manifest.output.entry) {
+      files.push(manifest.output.entry);
+    }
+    if (manifest.output.chunks) {
+      files.push(...manifest.output.chunks);
+    }
+    if (manifest.output.assets) {
+      files.push(...manifest.output.assets);
+    }
+  }
+  return files;
+}
+async function createCompatibilityFiles(outputDir) {
+  const sectionsRegistryPath = path__default.default.join(outputDir, "sections-registry.js");
+  const content = `// Re-export all sections from bundle-entry
+// This file exists to maintain compatibility with the import path
+export * from './bundle-entry.js';
+`;
+  await fs__default.default.writeFile(sectionsRegistryPath, content, "utf-8");
+}
+function showDownloadFailureHelp(themeId, bucket) {
+  console.log();
+  logger.error(chalk4__default.default.red.bold("\u274C Theme download failed"));
+  console.log();
+  console.log(chalk4__default.default.yellow("Possible reasons:"));
+  console.log(chalk4__default.default.gray("  1. Theme not uploaded to S3 yet"));
+  console.log(chalk4__default.default.gray("  2. AWS credentials not configured correctly"));
+  console.log(chalk4__default.default.gray("  3. Bucket name or region is incorrect"));
+  console.log(chalk4__default.default.gray("  4. Theme files are incomplete or corrupted"));
+  console.log();
+  console.log(chalk4__default.default.cyan.bold("To fix this:"));
+  console.log();
+  console.log(chalk4__default.default.white("1. Compile and upload the theme:"));
+  console.log(chalk4__default.default.gray(`   cd themes/${themeId}`));
+  console.log(chalk4__default.default.gray("   pnpm build"));
+  console.log(chalk4__default.default.gray("   pnpm upload"));
+  console.log();
+  console.log(chalk4__default.default.white("2. Verify AWS credentials are set:"));
+  console.log(
+    chalk4__default.default.gray("   - Set AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY")
+  );
+  console.log(chalk4__default.default.gray("   - Or use AWS_PROFILE=your-profile"));
+  console.log(chalk4__default.default.gray("   - Set AWS_REGION (e.g., ap-southeast-1)"));
+  console.log();
+  console.log(chalk4__default.default.white("3. Check bucket configuration:"));
+  console.log(chalk4__default.default.gray(`   Current bucket: ${bucket}`));
+  console.log(
+    chalk4__default.default.gray("   Set BUCKET_NAME environment variable if different")
+  );
+  console.log();
+  console.log(chalk4__default.default.white("4. Verify theme exists in S3:"));
+  console.log(chalk4__default.default.gray(`   aws s3 ls s3://${bucket}/themes/${themeId}/`));
+  console.log();
+}
+async function downloadCommand(options) {
+  logger.header("Download Theme from S3");
+  const spinner = ora__default.default("Initializing download...").start();
+  try {
+    const themeId = options.themeId || process.env.NEXT_PUBLIC_THEME_ID || process.env.THEME_ID;
+    const version = options.version || process.env.THEME_VERSION || "latest";
+    const bucket = options.bucket || getBucketName2(options.environment);
+    const outputDir = options.output || "./active-theme";
+    if (!themeId) {
+      spinner.fail(
+        chalk4__default.default.red(
+          "Theme ID not specified. Use --theme-id or set NEXT_PUBLIC_THEME_ID environment variable."
+        )
+      );
+      process.exit(1);
+    }
+    spinner.text = `Downloading ${themeId}@${version} from ${bucket}...`;
+    const s3Client = getS3Client2();
+    let resolvedVersion = version;
+    if (version === "latest") {
+      spinner.text = "Resolving latest version...";
+      resolvedVersion = await resolveLatestVersion(s3Client, bucket, themeId);
+      spinner.succeed(
+        `Resolved latest version: ${chalk4__default.default.cyan(resolvedVersion)}`
+      );
+      spinner.start("Downloading manifest...");
+    }
+    const manifest = await downloadManifest(
+      s3Client,
+      bucket,
+      themeId,
+      resolvedVersion
+    );
+    spinner.succeed("Downloaded manifest");
+    spinner.start("Preparing output directory...");
+    await fs__default.default.remove(outputDir);
+    await fs__default.default.ensureDir(outputDir);
+    spinner.succeed("Output directory ready");
+    spinner.start("Downloading theme files...");
+    const files = collectFilesToDownload(manifest);
+    let downloaded = 0;
+    const total = files.length;
+    const batchSize = 10;
+    for (let i = 0; i < files.length; i += batchSize) {
+      const batch = files.slice(i, i + batchSize);
+      await Promise.all(
+        batch.map(async (file) => {
+          await downloadFile(
+            s3Client,
+            bucket,
+            themeId,
+            resolvedVersion,
+            file,
+            outputDir
+          );
+          downloaded++;
+          spinner.text = `Downloading... ${downloaded}/${total} files (${Math.round(downloaded / total * 100)}%)`;
+        })
+      );
+    }
+    spinner.succeed(`Downloaded ${total} files`);
+    await createCompatibilityFiles(outputDir);
+    console.log();
+    logger.success(chalk4__default.default.green.bold("\u2705 Theme downloaded successfully!"));
+    console.log();
+    console.log(
+      chalk4__default.default.cyan("   Theme:   ") + chalk4__default.default.white(`${themeId}@${resolvedVersion}`)
+    );
+    console.log(chalk4__default.default.cyan("   Bucket:  ") + chalk4__default.default.white(bucket));
+    console.log(chalk4__default.default.cyan("   Output:  ") + chalk4__default.default.white(outputDir));
+    console.log(chalk4__default.default.cyan("   Files:   ") + chalk4__default.default.white(total));
+    console.log(
+      chalk4__default.default.cyan("   Sections:") + chalk4__default.default.white(` ${manifest.counts.sections}`)
+    );
+    console.log();
+  } catch (error) {
+    spinner.fail(chalk4__default.default.red("Download failed"));
+    logger.error(error.message);
+    const themeId = options.themeId || process.env.NEXT_PUBLIC_THEME_ID || "unknown";
+    const bucket = options.bucket || getBucketName2(options.environment);
+    showDownloadFailureHelp(themeId, bucket);
+    process.exit(1);
+  }
+}
+
+exports.Logger = Logger;
+exports.buildCommand = buildCommand;
+exports.copyTemplate = copyTemplate;
+exports.createBlockCommand = createBlockCommand;
+exports.createComponentCommand = createComponentCommand;
+exports.createSectionCommand = createSectionCommand;
+exports.detectPackageManager = detectPackageManager;
+exports.downloadCommand = downloadCommand;
+exports.ensureOneXProject = ensureOneXProject;
+exports.getFeaturesDir = getFeaturesDir;
+exports.getProjectRoot = getProjectRoot;
+exports.getThemesDir = getThemesDir;
+exports.getValidCategories = getValidCategories;
+exports.initCommand = initCommand;
+exports.installDependencies = installDependencies;
+exports.isOneXProject = isOneXProject;
+exports.listCommand = listCommand;
+exports.listThemes = listThemes;
+exports.logger = logger;
+exports.pathExists = pathExists;
+exports.renderTemplate = renderTemplate;
+exports.themeExists = themeExists;
+exports.toCamelCase = toCamelCase;
+exports.toKebabCase = toKebabCase;
+exports.toPascalCase = toPascalCase;
+exports.uploadCommand = uploadCommand;
+exports.validateCategory = validateCategory;
+exports.validateName = validateName;
+exports.validateThemeName = validateThemeName;
+exports.writeFile = writeFile;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map