@onexapis/cli 1.0.3 → 1.1.0

package/dist/index.mjs

@@ -1,9 +1,13 @@
+import chalk4 from 'chalk';
+import ora from 'ora';
+import * as esbuild from 'esbuild';
 import path from 'path';
+import fs6 from 'fs/promises';
+import crypto from 'crypto';
+import { glob } from 'glob';
 import fs2 from 'fs';
 import { execSync, spawn } from 'child_process';
 import inquirer from 'inquirer';
-import chalk4 from 'chalk';
-import ora from 'ora';
 import fs from 'fs-extra';
 import ejs from 'ejs';
 import { PutObjectCommand, GetObjectCommand, S3Client } from '@aws-sdk/client-s3';
@@ -11,6 +15,8 @@ import os from 'os';
 import archiver from 'archiver';
 import AdmZip from 'adm-zip';
 
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
 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]
@@ -18,58 +24,644 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
   if (typeof require !== "undefined") return require.apply(this, arguments);
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 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.green("\u2713"), message);
-  }
-  error(message) {
-    console.log(chalk4.red("\u2717"), message);
+var Logger, logger;
+var init_logger = __esm({
+  "src/utils/logger.ts"() {
+    Logger = class {
+      constructor() {
+        this.spinner = null;
+      }
+      success(message) {
+        console.log(chalk4.green("\u2713"), message);
+      }
+      error(message) {
+        console.log(chalk4.red("\u2717"), message);
+      }
+      warning(message) {
+        console.log(chalk4.yellow("\u26A0"), message);
+      }
+      info(message) {
+        console.log(chalk4.blue("\u2139"), message);
+      }
+      log(message) {
+        console.log(message);
+      }
+      startSpinner(message) {
+        this.spinner = ora(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.bold.cyan(message));
+        console.log(chalk4.cyan("=".repeat(message.length)));
+        console.log();
+      }
+      section(message) {
+        console.log();
+        console.log(chalk4.bold(message));
+      }
+    };
+    logger = new Logger();
   }
-  warning(message) {
-    console.log(chalk4.yellow("\u26A0"), message);
+});
+
+// src/utils/compile-theme.ts
+var compile_theme_exports = {};
+__export(compile_theme_exports, {
+  compilePreviewRuntime: () => compilePreviewRuntime,
+  compileStandaloneTheme: () => compileStandaloneTheme,
+  compileStandaloneThemeDev: () => compileStandaloneThemeDev,
+  generateManifest: () => generateManifest2
+});
+async function resolveNodeModulesFile(startDir, relativePath) {
+  let dir = startDir;
+  while (true) {
+    const candidate = path.join(dir, "node_modules", relativePath);
+    try {
+      await fs6.access(candidate);
+      return candidate;
+    } catch (e) {
+      const parent = path.dirname(dir);
+      if (parent === dir) break;
+      dir = parent;
+    }
   }
-  info(message) {
-    console.log(chalk4.blue("\u2139"), message);
+  return null;
+}
+function createCoreGlobalPlugin(themePath) {
+  const exportsBySubpath = {};
+  return {
+    name: "core-global",
+    setup(build2) {
+      build2.onResolve({ filter: /^@onexapis\/core(\/.*)?$/ }, (args) => ({
+        path: args.path,
+        namespace: "core-global"
+      }));
+      build2.onLoad({ filter: /.*/, namespace: "core-global" }, async (args) => {
+        const match = args.path.match(/^@onexapis\/core(\/(.+))?$/);
+        const subpath = (match == null ? void 0 : match[2]) || "";
+        const moduleAccess = subpath ? `['${subpath}']` : "";
+        let namedExports = [];
+        const cacheKey = subpath || "__root__";
+        if (exportsBySubpath[cacheKey]) {
+          namedExports = exportsBySubpath[cacheKey];
+        } else {
+          const distFileName = subpath ? `${subpath}.mjs` : "index.mjs";
+          const distPath = await resolveNodeModulesFile(
+            themePath,
+            path.join("@onexapis", "core", "dist", distFileName)
+          );
+          try {
+            if (!distPath) throw new Error("not found");
+            const distContent = await fs6.readFile(distPath, "utf-8");
+            const exportMatches = distContent.matchAll(/export\s*\{([^}]+)\}/g);
+            for (const m of exportMatches) {
+              const names = m[1].split(",").map((n) => {
+                const parts = n.trim().split(/\s+as\s+/);
+                return (parts[1] || parts[0]).trim();
+              }).filter((n) => n.length > 0);
+              namedExports.push(...names);
+            }
+            namedExports = [...new Set(namedExports)];
+          } catch (e) {
+          }
+          exportsBySubpath[cacheKey] = namedExports;
+        }
+        const namedExportLines = namedExports.length > 0 ? `
+export const {
+  ${namedExports.join(",\n  ")}
+} = _module;
+` : "";
+        return {
+          contents: `
+if (!globalThis.__ONEX_CORE__) {
+  throw new Error('[Theme Bundle] @onexapis/core not initialized. Ensure globalThis.__ONEX_CORE__ is set before loading theme.');
+}
+
+const _module = globalThis.__ONEX_CORE__${moduleAccess};
+if (!_module) {
+  const subpath = ${subpath ? `'${subpath}'` : "null"};
+  const modulePath = subpath ? '/' + subpath : '';
+  const moduleKey = subpath ? '["' + subpath + '"]' : '';
+  throw new Error('[Theme Bundle] @onexapis/core' + modulePath + ' not available in globalThis.__ONEX_CORE__' + moduleKey);
+}
+
+export default _module;
+${namedExportLines}
+            `.trim(),
+          loader: "js"
+        };
+      });
+    }
+  };
+}
+async function contentHashEntry(outputDir) {
+  const entryPath = path.join(outputDir, "bundle-entry.js");
+  const mapPath = path.join(outputDir, "bundle-entry.js.map");
+  const oldFiles = await glob("bundle-entry-*.js*", { cwd: outputDir });
+  for (const f of oldFiles) {
+    await fs6.unlink(path.join(outputDir, f));
   }
-  log(message) {
-    console.log(message);
+  let entryContent;
+  try {
+    entryContent = await fs6.readFile(entryPath, "utf-8");
+  } catch (e) {
+    const indexPath = path.join(outputDir, "index.js");
+    try {
+      entryContent = await fs6.readFile(indexPath, "utf-8");
+    } catch (e2) {
+      logger.warning("No entry file found in output, skipping content hash");
+      return;
+    }
+    const hash2 = crypto.createHash("sha256").update(entryContent).digest("hex").slice(0, 8);
+    const hashedName2 = `bundle-entry-${hash2}.js`;
+    const indexMapPath = path.join(outputDir, "index.js.map");
+    const hashedMapName2 = `bundle-entry-${hash2}.js.map`;
+    entryContent = entryContent.replace(
+      /\/\/# sourceMappingURL=index\.js\.map/,
+      `//# sourceMappingURL=${hashedMapName2}`
+    );
+    await fs6.writeFile(path.join(outputDir, hashedName2), entryContent);
+    await fs6.unlink(indexPath);
+    try {
+      await fs6.access(indexMapPath);
+      await fs6.rename(indexMapPath, path.join(outputDir, hashedMapName2));
+    } catch (e2) {
+    }
+    logger.info(`Entry hashed: ${hashedName2}`);
+    return;
   }
-  startSpinner(message) {
-    this.spinner = ora(message).start();
+  const hash = crypto.createHash("sha256").update(entryContent).digest("hex").slice(0, 8);
+  const hashedName = `bundle-entry-${hash}.js`;
+  const hashedMapName = `bundle-entry-${hash}.js.map`;
+  entryContent = entryContent.replace(
+    /\/\/# sourceMappingURL=bundle-entry\.js\.map/,
+    `//# sourceMappingURL=${hashedMapName}`
+  );
+  await fs6.writeFile(path.join(outputDir, hashedName), entryContent);
+  await fs6.unlink(entryPath);
+  try {
+    await fs6.access(mapPath);
+    await fs6.rename(mapPath, path.join(outputDir, hashedMapName));
+  } catch (e) {
   }
-  stopSpinner(success = true, message) {
-    if (!this.spinner) return;
-    if (success) {
-      this.spinner.succeed(message);
-    } else {
-      this.spinner.fail(message);
+  logger.info(`Entry hashed: ${hashedName}`);
+}
+async function generateManifest2(themeName, themePath, outputDir) {
+  let version = "1.0.0";
+  let themeId = themeName;
+  try {
+    const pkgContent = await fs6.readFile(
+      path.join(themePath, "package.json"),
+      "utf-8"
+    );
+    const pkg = JSON.parse(pkgContent);
+    version = pkg.version || version;
+    if (pkg.name) {
+      themeId = pkg.name.replace(/^@onex-themes\//, "");
     }
-    this.spinner = null;
+  } catch (e) {
   }
-  updateSpinner(message) {
-    if (this.spinner) {
-      this.spinner.text = message;
+  const [sectionFiles, blockFiles, schemaFiles] = await Promise.all([
+    glob("sections/**/index.ts", { cwd: themePath }),
+    glob("blocks/**/index.ts", { cwd: themePath }),
+    glob("**/*.schema.ts", { cwd: themePath })
+  ]);
+  let hasThemeConfig = false;
+  try {
+    await fs6.access(path.join(themePath, "theme.config.ts"));
+    hasThemeConfig = true;
+  } catch (e) {
+  }
+  const allFiles = await glob("**/*", { cwd: outputDir, nodir: true });
+  const jsFiles = allFiles.filter((f) => f.endsWith(".js"));
+  const cssFiles = allFiles.filter((f) => f.endsWith(".css"));
+  const entryFile = jsFiles.find((f) => f.includes("bundle-entry")) || "bundle-entry.js";
+  const manifest = {
+    themeId,
+    version,
+    name: themeId.charAt(0).toUpperCase() + themeId.slice(1),
+    compiledAt: (/* @__PURE__ */ new Date()).toISOString(),
+    format: "esm",
+    platform: "browser",
+    target: "es2020",
+    counts: {
+      sections: sectionFiles.length,
+      blocks: blockFiles.length,
+      schemas: schemaFiles.length
+    },
+    output: {
+      entry: entryFile,
+      chunks: jsFiles.filter((f) => f !== entryFile && !f.endsWith(".map")),
+      assets: allFiles.filter(
+        (f) => [".png", ".jpg", ".jpeg", ".svg", ".gif", ".webp"].some(
+          (ext) => f.endsWith(ext)
+        )
+      ),
+      stylesheets: cssFiles
+    },
+    external: ["react", "react-dom", "@onexapis/core"],
+    source: {
+      sections: sectionFiles,
+      blocks: blockFiles,
+      schemas: schemaFiles,
+      hasThemeConfig
+    }
+  };
+  await fs6.writeFile(
+    path.join(outputDir, "manifest.json"),
+    JSON.stringify(manifest, null, 2)
+  );
+}
+async function compileStandaloneTheme(themePath, themeName) {
+  const outputDir = path.join(themePath, "dist");
+  const bundleEntry = path.join(themePath, "bundle-entry.ts");
+  const indexEntry = path.join(themePath, "index.ts");
+  let entryPoint = indexEntry;
+  try {
+    await fs6.access(bundleEntry);
+    entryPoint = bundleEntry;
+  } catch (e) {
+  }
+  const shimPath = path.join(outputDir, ".process-shim.js");
+  await fs6.mkdir(outputDir, { recursive: true });
+  await fs6.writeFile(shimPath, PROCESS_SHIM);
+  const buildOptions = {
+    entryPoints: [entryPoint],
+    bundle: true,
+    platform: "browser",
+    format: "esm",
+    outdir: outputDir,
+    splitting: false,
+    chunkNames: "[name]-[hash]",
+    banner: {
+      js: '"use client";'
+    },
+    plugins: [reactGlobalPlugin, createCoreGlobalPlugin(themePath)],
+    external: [],
+    alias: {
+      events: "events/",
+      buffer: "buffer/"
+    },
+    inject: [shimPath],
+    define: {
+      "process.env.NODE_ENV": JSON.stringify("production"),
+      global: "globalThis"
+    },
+    minify: true,
+    sourcemap: true,
+    logLevel: "warning",
+    target: "es2020",
+    jsx: "automatic",
+    jsxImportSource: "react",
+    loader: {
+      ".tsx": "tsx",
+      ".ts": "ts",
+      ".jpg": "file",
+      ".jpeg": "file",
+      ".png": "file",
+      ".gif": "file",
+      ".svg": "file",
+      ".webp": "file"
+    },
+    assetNames: "assets/[name]-[hash]",
+    publicPath: "./",
+    metafile: true
+  };
+  try {
+    const result = await esbuild.build(buildOptions);
+    try {
+      await fs6.unlink(shimPath);
+    } catch (e) {
+    }
+    await contentHashEntry(outputDir);
+    await generateManifest2(themeName, themePath, outputDir);
+    if (result.metafile) {
+      const outputs = result.metafile.outputs;
+      let totalSize = 0;
+      for (const output of Object.values(outputs)) {
+        totalSize += output.bytes;
+      }
+      const totalKB = (totalSize / 1024).toFixed(2);
+      logger.info(`Bundle size: ${totalKB} KB`);
     }
+    return true;
+  } catch (error) {
+    try {
+      await fs6.unlink(shimPath);
+    } catch (e) {
+    }
+    logger.error(`esbuild compilation failed: ${error}`);
+    return false;
   }
-  newLine() {
-    console.log();
+}
+async function compileStandaloneThemeDev(themePath, themeName) {
+  const outputDir = path.join(themePath, "dist");
+  const bundleEntry = path.join(themePath, "bundle-entry.ts");
+  const indexEntry = path.join(themePath, "index.ts");
+  let entryPoint = indexEntry;
+  try {
+    await fs6.access(bundleEntry);
+    entryPoint = bundleEntry;
+  } catch (e) {
+  }
+  const shimPath = path.join(outputDir, ".process-shim.js");
+  await fs6.mkdir(outputDir, { recursive: true });
+  await fs6.writeFile(shimPath, PROCESS_SHIM);
+  const buildOptions = {
+    entryPoints: [entryPoint],
+    bundle: true,
+    platform: "browser",
+    format: "esm",
+    outdir: outputDir,
+    splitting: false,
+    banner: {
+      js: '"use client";'
+    },
+    plugins: [reactGlobalPlugin, createCoreGlobalPlugin(themePath)],
+    external: [],
+    alias: {
+      events: "events/",
+      buffer: "buffer/"
+    },
+    inject: [shimPath],
+    define: {
+      "process.env.NODE_ENV": JSON.stringify("development"),
+      global: "globalThis"
+    },
+    minify: false,
+    sourcemap: true,
+    logLevel: "warning",
+    target: "es2020",
+    jsx: "automatic",
+    jsxImportSource: "react",
+    loader: {
+      ".tsx": "tsx",
+      ".ts": "ts",
+      ".jpg": "file",
+      ".jpeg": "file",
+      ".png": "file",
+      ".gif": "file",
+      ".svg": "file",
+      ".webp": "file"
+    },
+    assetNames: "assets/[name]-[hash]",
+    publicPath: "./",
+    metafile: true
+  };
+  const context2 = await esbuild.context(buildOptions);
+  await context2.rebuild();
+  await generateManifest2(themeName, themePath, outputDir);
+  return { context: context2, outputDir };
+}
+async function compilePreviewRuntime(themePath) {
+  const outputDir = path.join(themePath, "dist");
+  await fs6.mkdir(outputDir, { recursive: true });
+  const outputPath = path.join(outputDir, "preview-runtime.js");
+  const locations = [
+    path.join(__dirname, "..", "preview", "preview-app.tsx"),
+    path.join(__dirname, "preview", "preview-app.tsx"),
+    path.join(__dirname, "..", "..", "src", "preview", "preview-app.tsx")
+  ];
+  let previewEntryPath = null;
+  for (const loc of locations) {
+    try {
+      await fs6.access(loc);
+      previewEntryPath = loc;
+      break;
+    } catch (e) {
+    }
   }
-  header(message) {
-    console.log();
-    console.log(chalk4.bold.cyan(message));
-    console.log(chalk4.cyan("=".repeat(message.length)));
-    console.log();
+  if (!previewEntryPath) {
+    throw new Error(
+      `Preview app source not found. Searched:
+${locations.join("\n")}`
+    );
   }
-  section(message) {
-    console.log();
-    console.log(chalk4.bold(message));
+  const serverStubPlugin = {
+    name: "server-stub",
+    setup(build2) {
+      build2.onResolve({ filter: /^server-only$/ }, () => ({
+        path: "server-only",
+        namespace: "server-stub"
+      }));
+      build2.onLoad({ filter: /.*/, namespace: "server-stub" }, () => ({
+        contents: "// server-only stub for browser",
+        loader: "js"
+      }));
+      const nodeBuiltins = [
+        "fs",
+        "fs/promises",
+        "path",
+        "os",
+        "crypto",
+        "stream",
+        "url",
+        "http",
+        "https",
+        "net",
+        "tls",
+        "child_process",
+        "util",
+        "events",
+        "buffer",
+        "querystring",
+        "zlib"
+      ];
+      for (const mod of nodeBuiltins) {
+        build2.onResolve({ filter: new RegExp(`^${mod.replace("/", "\\/")}$`) }, () => ({
+          path: mod,
+          namespace: "node-stub"
+        }));
+      }
+      build2.onLoad({ filter: /.*/, namespace: "node-stub" }, (args) => {
+        const stubs = {
+          events: "export class EventEmitter { on(){return this} off(){return this} emit(){return false} addListener(){return this} removeListener(){return this} } export default { EventEmitter };",
+          path: "export function join(){return ''} export function resolve(){return ''} export function dirname(){return ''} export function basename(){return ''} export function extname(){return ''} export default {};",
+          fs: "export const promises = {}; export function readFileSync(){return ''} export function existsSync(){return false} export default {};"
+        };
+        return {
+          contents: stubs[args.path] || "export default {};",
+          loader: "js"
+        };
+      });
+    }
+  };
+  await esbuild.build({
+    entryPoints: [previewEntryPath],
+    bundle: true,
+    platform: "browser",
+    format: "esm",
+    outfile: outputPath,
+    // Bundle React + core INTO the output (NOT externalized)
+    external: [],
+    plugins: [serverStubPlugin],
+    minify: false,
+    sourcemap: true,
+    target: "es2020",
+    jsx: "automatic",
+    jsxImportSource: "react",
+    define: {
+      "process.env.NODE_ENV": JSON.stringify("development"),
+      global: "globalThis"
+    },
+    loader: { ".tsx": "tsx", ".ts": "ts" },
+    // Force CJS resolution to avoid sideEffects:false dropping ESM chunk imports
+    conditions: ["require", "default"],
+    mainFields: ["main"],
+    logOverride: {
+      "ignored-bare-import": "silent"
+    }
+  });
+  return outputPath;
+}
+var PROCESS_SHIM, reactGlobalPlugin;
+var init_compile_theme = __esm({
+  "src/utils/compile-theme.ts"() {
+    init_logger();
+    PROCESS_SHIM = `
+if (typeof process === "undefined") {
+  globalThis.process = {
+    env: {},
+    browser: true,
+  };
+}
+`;
+    reactGlobalPlugin = {
+      name: "react-global",
+      setup(build2) {
+        build2.onResolve({ filter: /^react$/ }, () => ({
+          path: "react-external",
+          namespace: "react-global"
+        }));
+        build2.onResolve({ filter: /^react-dom$/ }, () => ({
+          path: "react-dom-external",
+          namespace: "react-global"
+        }));
+        build2.onResolve({ filter: /^react\/jsx-runtime$/ }, () => ({
+          path: "react-jsx-runtime-external",
+          namespace: "react-global"
+        }));
+        build2.onLoad({ filter: /.*/, namespace: "react-global" }, (args) => {
+          if (args.path === "react-external") {
+            return {
+              contents: `
+if (!globalThis.__ONEX_REACT__) {
+  throw new Error('[Theme Bundle] React not initialized. Ensure globalThis.__ONEX_REACT__ is set before loading theme.');
+}
+
+const React = globalThis.__ONEX_REACT__;
+export default React;
+
+export const {
+  useState,
+  useEffect,
+  useContext,
+  useReducer,
+  useCallback,
+  useMemo,
+  useRef,
+  useImperativeHandle,
+  useLayoutEffect,
+  useDebugValue,
+  useDeferredValue,
+  useTransition,
+  useId,
+  useSyncExternalStore,
+  useInsertionEffect,
+  createContext,
+  forwardRef,
+  lazy,
+  memo,
+  startTransition,
+  createElement,
+  cloneElement,
+  isValidElement,
+  Children,
+  Fragment,
+  Profiler,
+  StrictMode,
+  Suspense,
+  Component,
+  PureComponent,
+  useActionState,
+  use,
+} = React;
+          `.trim(),
+              loader: "js"
+            };
+          }
+          if (args.path === "react-dom-external") {
+            return {
+              contents: `
+if (!globalThis.__ONEX_REACT_DOM__) {
+  throw new Error('[Theme Bundle] ReactDOM not initialized. Ensure globalThis.__ONEX_REACT_DOM__ is set before loading theme.');
+}
+
+const ReactDOM = globalThis.__ONEX_REACT_DOM__;
+export default ReactDOM;
+
+export const {
+  createRoot,
+  hydrateRoot,
+  flushSync,
+  createPortal,
+  findDOMNode,
+  render,
+  hydrate,
+  unmountComponentAtNode,
+} = ReactDOM;
+          `.trim(),
+              loader: "js"
+            };
+          }
+          if (args.path === "react-jsx-runtime-external") {
+            return {
+              contents: `
+if (!globalThis.__ONEX_JSX_RUNTIME__) {
+  throw new Error('[Theme Bundle] React JSX runtime not initialized. Ensure globalThis.__ONEX_JSX_RUNTIME__ is set before loading theme.');
+}
+const _jsxRuntime = globalThis.__ONEX_JSX_RUNTIME__;
+export const jsx = _jsxRuntime.jsx;
+export const jsxs = _jsxRuntime.jsxs;
+export const Fragment = _jsxRuntime.Fragment;
+          `.trim(),
+              loader: "js"
+            };
+          }
+          return null;
+        });
+      }
+    };
   }
-};
-var logger = new Logger();
+});
+
+// src/commands/init.ts
+init_logger();
 
 // src/utils/validators.ts
 function validateName(name) {
@@ -89,8 +681,8 @@ function validateThemeName(name) {
   return /^[a-z][a-z0-9-]*$/.test(name);
 }
 function pathExists(filePath) {
-  const fs8 = __require("fs-extra");
-  return fs8.existsSync(filePath);
+  const fs11 = __require("fs-extra");
+  return fs11.existsSync(filePath);
 }
 function validateCategory(category) {
   const validCategories = [
@@ -123,6 +715,9 @@ function getValidCategories() {
     "contact"
   ];
 }
+
+// src/utils/file-helpers.ts
+init_logger();
 async function renderTemplate(templatePath, data) {
   const template = await fs.readFile(templatePath, "utf-8");
   return ejs.render(template, data);
@@ -208,18 +803,18 @@ function getProjectRoot() {
 }
 function getThemesDir() {
   const root = getProjectRoot();
-  const themesDir = path.join(root, "themes");
-  if (fs.existsSync(themesDir)) {
-    return themesDir;
-  }
-  return path.join(root, "src/themes");
+  if (fs.existsSync(path.join(root, "themes")))
+    return path.join(root, "themes");
+  if (fs.existsSync(path.join(root, "src/themes")))
+    return path.join(root, "src/themes");
+  return path.dirname(root);
 }
 function getFeaturesDir() {
   return path.join(getProjectRoot(), "src/features");
 }
 function isOneXProject() {
   const root = getProjectRoot();
-  return fs.existsSync(path.join(root, "themes")) || fs.existsSync(path.join(root, "src/themes"));
+  return fs.existsSync(path.join(root, "themes")) || fs.existsSync(path.join(root, "src/themes")) || fs.existsSync(path.join(root, "theme.config.ts")) || fs.existsSync(path.join(root, "bundle-entry.ts"));
 }
 function ensureOneXProject() {
   if (!isOneXProject()) {
@@ -681,9 +1276,20 @@ export const homePageConfig: PageConfig = {
 };
 `;
 }
+
+// src/commands/create-section.ts
+init_logger();
 async function createSectionCommand(name, options) {
   logger.header("Create New Section");
   ensureOneXProject();
+  if (!options.theme) {
+    const isStandaloneTheme = ["theme.config.ts", "bundle-entry.ts"].some(
+      (f) => fs.existsSync(path.join(process.cwd(), f))
+    );
+    if (isStandaloneTheme) {
+      options.theme = path.basename(process.cwd());
+    }
+  }
   const sectionName = toKebabCase(name);
   if (!validateName(sectionName)) {
     logger.error(
@@ -912,9 +1518,20 @@ export { ${data.sectionName}Schema } from "./${data.sectionName}.schema";
 ${hasTemplate ? `export { ${data.sectionNamePascal}Default } from "./${data.sectionName}-default";` : ""}
 `;
 }
+
+// src/commands/create-block.ts
+init_logger();
 async function createBlockCommand(name, options) {
   logger.header("Create New Block");
   ensureOneXProject();
+  if (!options.theme) {
+    const isStandaloneTheme = ["theme.config.ts", "bundle-entry.ts"].some(
+      (f) => fs.existsSync(path.join(process.cwd(), f))
+    );
+    if (isStandaloneTheme) {
+      options.theme = path.basename(process.cwd());
+    }
+  }
   const blockName = toKebabCase(name);
   if (!validateName(blockName)) {
     logger.error(
@@ -1128,6 +1745,9 @@ export { ${data.blockName}Definition } from "./${data.blockName}.schema";
 export { ${data.blockNamePascal} } from "./${data.blockName}";
 `;
 }
+
+// src/commands/create-component.ts
+init_logger();
 async function createComponentCommand(name, options) {
   logger.header("Create New Component");
   ensureOneXProject();
@@ -1332,6 +1952,9 @@ export { ${data.componentName}Definition } from "./${data.componentName}.schema"
 export { ${data.componentNamePascal} } from "./${data.componentName}";
 `;
 }
+
+// src/commands/list.ts
+init_logger();
 async function listCommand(options) {
   logger.header("OneX Project Inventory");
   ensureOneXProject();
@@ -1463,7 +2086,11 @@ async function listThemesInfo() {
   }
   logger.newLine();
 }
+
+// src/commands/build.ts
+init_logger();
 async function buildCommand(options) {
+  var _a;
   logger.header("Build Theme");
   let themePath;
   let themeName;
@@ -1484,8 +2111,12 @@ async function buildCommand(options) {
       process.exit(1);
     }
   } else {
-    const manifestPath = path.join(process.cwd(), "manifest.ts");
-    if (fs.existsSync(manifestPath)) {
+    const isThemeDir = [
+      "theme.config.ts",
+      "bundle-entry.ts",
+      "manifest.ts"
+    ].some((f) => fs.existsSync(path.join(process.cwd(), f)));
+    if (isThemeDir) {
       themePath = process.cwd();
       themeName = path.basename(themePath);
       logger.info(`Building current theme: ${themeName}`);
@@ -1528,11 +2159,20 @@ async function buildCommand(options) {
     process.exit(1);
   }
   logger.stopSpinner(true, "Lint passed");
-  const buildArgs = options.watch ? ["build", "--watch"] : ["build"];
+  const pkgJson = fs.readJsonSync(packageJsonPath);
+  const buildScript = ((_a = pkgJson.scripts) == null ? void 0 : _a.build) || "";
+  const isRecursive = buildScript.includes("onex build") || buildScript.includes("onex-cli build");
   logger.startSpinner(
     options.watch ? "Building (watch mode)..." : "Building..."
   );
-  const buildSuccess = await runCommand("pnpm", buildArgs, themePath);
+  let buildSuccess;
+  if (isRecursive) {
+    const { compileStandaloneTheme: compileStandaloneTheme2 } = await Promise.resolve().then(() => (init_compile_theme(), compile_theme_exports));
+    buildSuccess = await compileStandaloneTheme2(themePath, themeName);
+  } else {
+    const buildArgs = options.watch ? ["build", "--watch"] : ["build"];
+    buildSuccess = await runCommand("pnpm", buildArgs, themePath);
+  }
   if (!buildSuccess && !options.watch) {
     logger.stopSpinner(false, "Build failed");
     process.exit(1);
@@ -1573,6 +2213,9 @@ function runCommand(command, args, cwd) {
     });
   });
 }
+
+// src/commands/upload.ts
+init_logger();
 function getS3Client() {
   const adapterMode = (process.env.ADAPTER_MODE || "aws").trim().toLowerCase();
   if (adapterMode === "vps") {
@@ -1612,21 +2255,12 @@ function getBucketName(env) {
   return environment === "production" ? "onex-themes-prod" : "onex-themes-staging";
 }
 async function findCompiledThemeDir(themeId, version) {
-  const searchPaths = [
-    path.resolve(process.cwd(), "dist"),
-    path.resolve(
-      process.cwd(),
-      `../../apps/api-server/compiled-themes/${themeId}@${version}`
-    ),
-    path.resolve(
-      process.cwd(),
-      `../api-server/compiled-themes/${themeId}@${version}`
-    )
-  ];
+  const searchPaths = [path.resolve(process.cwd(), "dist")];
   for (const dir of searchPaths) {
     if (await fs.pathExists(dir)) {
-      const manifestPath = path.join(dir, "manifest.json");
-      if (await fs.pathExists(manifestPath)) {
+      const hasManifest = await fs.pathExists(path.join(dir, "manifest.json"));
+      const hasThemeEntry = await fs.pathExists(path.join(dir, "bundle-entry.js")) || await fs.pathExists(path.join(dir, "theme.config.js")) || await fs.pathExists(path.join(dir, "index.js"));
+      if (hasManifest || hasThemeEntry) {
         return dir;
       }
     }
@@ -1729,13 +2363,8 @@ async function uploadCommand(options) {
           `Compiled theme not found for ${themeId}@${version}. Run 'onex build' first.`
         )
       );
-      logger.info(
-        chalk4.gray(
-          `Expected locations:
-  - ./dist/
-  - ../../apps/api-server/compiled-themes/${themeId}@${version}/`
-        )
-      );
+      logger.info(chalk4.gray(`Expected location:
+  - ./dist/`));
       process.exit(1);
     }
     spinner.succeed(`Found compiled theme at: ${compiledDir}`);
@@ -1842,9 +2471,7 @@ async function uploadCommand(options) {
     );
     console.log(chalk4.cyan("   Bucket:  ") + chalk4.white(bucket));
     console.log(
-      chalk4.cyan("   Files:   ") + chalk4.white(
-        `bundle.zip${sourceUploaded ? " + source.zip" : ""}`
-      )
+      chalk4.cyan("   Files:   ") + chalk4.white(`bundle.zip${sourceUploaded ? " + source.zip" : ""}`)
     );
     console.log(
       chalk4.cyan("   Path:    ") + chalk4.gray(`s3://${bucket}/themes/${themeId}/${version}/`)
@@ -1856,6 +2483,9 @@ async function uploadCommand(options) {
     process.exit(1);
   }
 }
+
+// src/commands/download.ts
+init_logger();
 function getS3Client2() {
   const adapterMode = (process.env.ADAPTER_MODE || "aws").trim().toLowerCase();
   if (adapterMode === "vps") {
@@ -2003,11 +2633,7 @@ function showDownloadFailureHelp(themeId, bucket) {
   );
   console.log();
   console.log(chalk4.white("4. Verify theme exists in S3:"));
-  console.log(
-    chalk4.gray(
-      `   aws s3 ls s3://${bucket}/themes/${themeId}/`
-    )
-  );
+  console.log(chalk4.gray(`   aws s3 ls s3://${bucket}/themes/${themeId}/`));
   console.log();
 }
 async function downloadCommand(options) {
@@ -2083,6 +2709,9 @@ async function downloadCommand(options) {
     process.exit(1);
   }
 }
+
+// src/commands/clone.ts
+init_logger();
 function getS3Client3() {
   const adapterMode = (process.env.ADAPTER_MODE || "aws").trim().toLowerCase();
   if (adapterMode === "vps") {
@@ -2186,17 +2815,100 @@ function runInstall(cwd) {
     proc.on("error", () => resolve(false));
   });
 }
+async function promptThemeName(originalName) {
+  const { default: inquirer5 } = await import('inquirer');
+  const { themeName } = await inquirer5.prompt([
+    {
+      type: "input",
+      name: "themeName",
+      message: "New theme name (kebab-case):",
+      default: `my-${originalName}`,
+      validate: (input) => {
+        if (!/^[a-z][a-z0-9-]*$/.test(input)) {
+          return "Theme name must be kebab-case (lowercase letters, numbers, hyphens)";
+        }
+        if (input === originalName) {
+          return `Name must differ from the original theme "${originalName}"`;
+        }
+        return true;
+      }
+    }
+  ]);
+  return themeName;
+}
+async function renameTheme(themeDir, oldName, newName) {
+  const oldPrefix = `${oldName}-`;
+  const newPrefix = `${newName}-`;
+  const newDisplayName = newName.split("-").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
+  const pkgPath = path.join(themeDir, "package.json");
+  if (await fs.pathExists(pkgPath)) {
+    const pkg = await fs.readJson(pkgPath);
+    pkg.name = `@onex-themes/${newName}`;
+    if (pkg.description) {
+      pkg.description = pkg.description.replace(
+        new RegExp(oldName, "gi"),
+        newDisplayName
+      );
+    }
+    pkg.version = "1.0.0";
+    await fs.writeJson(pkgPath, pkg, { spaces: 2 });
+  }
+  const configPath = path.join(themeDir, "theme.config.ts");
+  if (await fs.pathExists(configPath)) {
+    let content = await fs.readFile(configPath, "utf-8");
+    content = content.replace(/id:\s*"[^"]*"/, `id: "${newName}"`);
+    content = content.replace(
+      /name:\s*"[^"]*Theme"/,
+      `name: "${newDisplayName} Theme"`
+    );
+    await fs.writeFile(configPath, content);
+  }
+  const layoutPath = path.join(themeDir, "theme.layout.ts");
+  if (await fs.pathExists(layoutPath)) {
+    let content = await fs.readFile(layoutPath, "utf-8");
+    content = content.replace(/id:\s*"[^"]*"/, `id: "${newName}"`);
+    content = content.replace(
+      /name:\s*"[^"]*Theme"/,
+      `name: "${newDisplayName} Theme"`
+    );
+    await fs.writeFile(layoutPath, content);
+  }
+  const oldDisplayName = oldName.split("-").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
+  const tsFiles = await glob("**/*.ts", { cwd: themeDir, nodir: true });
+  for (const file of tsFiles) {
+    const filePath = path.join(themeDir, file);
+    let content = await fs.readFile(filePath, "utf-8");
+    const original = content;
+    content = content.replace(
+      new RegExp(`"${oldPrefix}`, "g"),
+      `"${newPrefix}`
+    );
+    content = content.replace(
+      new RegExp(`themeId:\\s*"${oldName}"`, "g"),
+      `themeId: "${newName}"`
+    );
+    content = content.replace(
+      new RegExp(`${oldDisplayName} Theme`, "g"),
+      `${newDisplayName} Theme`
+    );
+    if (content !== original) {
+      await fs.writeFile(filePath, content);
+    }
+  }
+}
 async function cloneCommand(themeName, options) {
   logger.header("Clone Theme Source");
+  let newName = options.name;
+  if (!newName) {
+    newName = await promptThemeName(themeName);
+  }
   const spinner = ora("Initializing clone...").start();
   try {
     const bucket = options.bucket || getBucketName3(options.environment);
-    const outputDir = options.output || path.resolve(process.cwd(), themeName);
+    const outputDir = options.output || path.resolve(process.cwd(), newName);
     const s3Client = getS3Client3();
     if (await fs.pathExists(outputDir)) {
-      spinner.fail(
-        chalk4.red(`Directory already exists: ${outputDir}`)
-      );
+      spinner.fail(chalk4.red(`Directory already exists: ${outputDir}`));
       logger.info(
         chalk4.gray(
           "Use -o to specify a different output directory, or remove the existing directory."
@@ -2210,9 +2922,7 @@ async function cloneCommand(themeName, options) {
       version = await resolveLatestVersion2(s3Client, bucket, themeName);
       spinner.succeed(`Resolved latest version: ${chalk4.cyan(version)}`);
     }
-    spinner.start(
-      `Downloading source.zip for ${themeName}@${version}...`
-    );
+    spinner.start(`Downloading source.zip for ${themeName}@${version}...`);
     const s3Key = `themes/${themeName}/${version}/source.zip`;
     let zipBuffer;
     try {
@@ -2230,9 +2940,7 @@ async function cloneCommand(themeName, options) {
         chalk4.yellow("The theme source may not have been uploaded yet.")
       );
       console.log(
-        chalk4.gray(
-          `Upload source with: onex upload --theme ${themeName}`
-        )
+        chalk4.gray(`Upload source with: onex upload --theme ${themeName}`)
       );
       console.log();
       process.exit(1);
@@ -2245,6 +2953,13 @@ async function cloneCommand(themeName, options) {
     zip.extractAllTo(outputDir, true);
     const entries = zip.getEntries().filter((e) => !e.isDirectory);
     spinner.succeed(`Extracted ${entries.length} files`);
+    spinner.start(
+      `Renaming theme: ${chalk4.gray(themeName)} \u2192 ${chalk4.cyan(newName)}...`
+    );
+    await renameTheme(outputDir, themeName, newName);
+    spinner.succeed(
+      `Renamed theme: ${chalk4.gray(themeName)} \u2192 ${chalk4.cyan(newName)}`
+    );
     if (options.install !== false) {
       const hasPkgJson = await fs.pathExists(
         path.join(outputDir, "package.json")
@@ -2267,15 +2982,14 @@ async function cloneCommand(themeName, options) {
     logger.success(chalk4.green.bold("Theme cloned successfully!"));
     console.log();
     console.log(
-      chalk4.cyan("   Theme:    ") + chalk4.white(`${themeName}@${version}`)
+      chalk4.cyan("   Source:   ") + chalk4.gray(`${themeName}@${version}`)
     );
+    console.log(chalk4.cyan("   Theme:    ") + chalk4.white(newName));
     console.log(chalk4.cyan("   Location: ") + chalk4.white(outputDir));
     console.log(chalk4.cyan("   Files:    ") + chalk4.white(entries.length));
     console.log();
     console.log(chalk4.cyan("Next steps:"));
-    console.log(
-      chalk4.gray(`   cd ${path.relative(process.cwd(), outputDir)}`)
-    );
+    console.log(chalk4.gray(`   cd ${path.relative(process.cwd(), outputDir)}`));
     if (options.install === false) {
       console.log(chalk4.gray("   pnpm install"));
     }
@@ -2288,6 +3002,9 @@ async function cloneCommand(themeName, options) {
   }
 }
 
+// src/index.ts
+init_logger();
+
 export { Logger, buildCommand, cloneCommand, copyTemplate, createBlockCommand, createComponentCommand, createSectionCommand, detectPackageManager, downloadCommand, ensureOneXProject, getFeaturesDir, getProjectRoot, getThemesDir, getValidCategories, initCommand, installDependencies, isOneXProject, listCommand, listThemes, logger, pathExists, renderTemplate, themeExists, toCamelCase, toKebabCase, toPascalCase, uploadCommand, validateCategory, validateName, validateThemeName, writeFile };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map