@konomi-app/k2 2.1.4 → 3.0.0

package/dist/index.js

@@ -1,123 +1,47 @@
 #!/usr/bin/env node
+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');
+});
 
 // src/index.ts
 import { program as program6 } from "commander";
 
 // src/commands/build.ts
 import { program } from "commander";
-import fs2 from "fs-extra";
+import fs3 from "fs-extra";
 import path6 from "path";
+import chalk2 from "chalk";
 
 // src/lib/constants.ts
 import path from "path";
 var WORKSPACE_DIRECTORY = ".k2";
 var DEVELOPMENT_DIRECTORY = path.join(WORKSPACE_DIRECTORY, "dev");
+var PRODUCTION_DIRECTORY = path.join(WORKSPACE_DIRECTORY, "prod");
 var CONFIG_FILE_NAME = "k2.config.mjs";
 var PLUGIN_WORKSPACE_DIRECTORY = ".plugin";
 var PLUGIN_CONTENTS_DIRECTORY = path.join(PLUGIN_WORKSPACE_DIRECTORY, "contents");
 var PLUGIN_DEVELOPMENT_DIRECTORY = path.join(PLUGIN_WORKSPACE_DIRECTORY, "dev");
+var PLUGIN_PRODUCTION_DIRECTORY = path.join(PLUGIN_WORKSPACE_DIRECTORY, "prod");
 var DEFAULT_PORT = 32767;
 
-// src/commands/build-base.ts
-import "webpack";
-
-// src/lib/webpack.ts
-import MiniCssExtractPlugin from "mini-css-extract-plugin";
-import path2 from "path";
-import { cwd } from "process";
-import TerserPlugin from "terser-webpack-plugin";
-import webpack from "webpack";
-import chalk from "chalk";
-import { TsconfigPathsPlugin } from "tsconfig-paths-webpack-plugin";
-var buildWithWebpack = async (props) => {
-  const { entries, outDir } = props;
-  const exclude = /node_modules/;
-  const styleLoader = MiniCssExtractPlugin.loader;
-  const tsConfigPath = path2.join(cwd(), "tsconfig.json");
-  console.group(chalk.blue("\u{1F680} Building with Webpack..."));
-  console.log("\u{1F527} tsconfig.json path:", tsConfigPath);
-  console.groupEnd();
-  return new Promise((resolve, reject) => {
-    webpack(
-      {
-        mode: "production",
-        target: ["web", "es2023"],
-        entry: entries,
-        resolve: {
-          extensions: [".ts", ".tsx", ".js", ".json"],
-          fallback: {
-            path: false
-          },
-          plugins: [new TsconfigPathsPlugin({ configFile: tsConfigPath })]
-        },
-        cache: { type: "filesystem" },
-        output: { filename: "[name].js", path: path2.resolve(outDir) },
-        module: {
-          rules: [
-            { test: /\.tsx?$/, exclude, loader: "ts-loader" },
-            { test: /\.css$/, use: [styleLoader, "css-loader"] },
-            {
-              test: /\.scss$/,
-              use: [
-                styleLoader,
-                "css-loader",
-                { loader: "sass-loader", options: { sassOptions: { outputStyle: "expanded" } } }
-              ]
-            }
-          ]
-        },
-        plugins: [new MiniCssExtractPlugin()],
-        optimization: {
-          minimize: true,
-          minimizer: [
-            new TerserPlugin({
-              terserOptions: { format: { comments: false } },
-              extractComments: false
-            })
-          ]
-        }
-      },
-      (err, stats) => {
-        if (err) {
-          reject(err);
-        } else {
-          if (stats?.compilation.errors.length) {
-            reject(
-              [
-                chalk.red("\u26A0 Build failed."),
-                ...stats.compilation.errors.map((error) => error.message)
-              ].join("\n")
-            );
-          } else {
-            resolve();
-          }
-        }
-      }
-    );
-  });
-};
-
-// src/commands/build-base.ts
-async function action(params) {
-  const { entries, outDir } = params;
-  return buildWithWebpack({ entries, outDir });
-}
-
 // src/commands/build-tailwind.ts
-import path5 from "path";
+import path4 from "path";
 
 // src/lib/import.ts
 import { pathToFileURL } from "url";
-import path3 from "path";
-var esmImport = (path12) => {
+import path2 from "path";
+var esmImport = (path11) => {
   if (process.platform === "win32") {
-    return import(pathToFileURL(path12).toString());
+    return import(pathToFileURL(path11).toString());
   } else {
-    return import(path12);
+    return import(path11);
   }
 };
 var importK2Config = async (configFileName) => {
-  return (await esmImport(path3.resolve(configFileName ?? CONFIG_FILE_NAME))).default;
+  return (await esmImport(path2.resolve(configFileName ?? CONFIG_FILE_NAME))).default;
 };
 
 // src/lib/tailwind.ts
@@ -125,14 +49,14 @@ import chokidar from "chokidar";
 import cssnanoPlugin from "cssnano";
 import fs from "fs-extra";
 import { glob } from "glob";
-import path4 from "path";
+import path3 from "path";
 import postcss from "postcss";
 import { debounce } from "remeda";
 import tailwindcss from "tailwindcss";
 import invariant from "tiny-invariant";
 var getTailwindConfigFromK2Config = async (k2Config) => {
   invariant(k2Config?.config, "tailwind.config is required");
-  const config = (await esmImport(path4.resolve(k2Config?.config))).default;
+  const config = (await esmImport(path3.resolve(k2Config?.config))).default;
   return config;
 };
 var outputCss = async (params) => {
@@ -177,16 +101,16 @@ var watchTailwindCSS = async (params) => {
   watcher.on("error", (error) => {
     console.error("Error watching Tailwind CSS:", error);
   });
-  watcher.on("add", (path12) => {
+  watcher.on("add", (path11) => {
     debouncedProcessChanges.call("add");
   });
-  watcher.on("change", (path12) => {
+  watcher.on("change", (path11) => {
     debouncedProcessChanges.call("change");
   });
-  watcher.on("unlink", (path12) => {
+  watcher.on("unlink", (path11) => {
     debouncedProcessChanges.call("unlink");
   });
-  watcher.on("unlinkDir", (path12) => {
+  watcher.on("unlinkDir", (path11) => {
     debouncedProcessChanges.call("unlink");
   });
   return watcher;
@@ -197,12 +121,12 @@ var buildTailwind = async (config) => {
   if (!config.tailwind?.css || !config.tailwind?.config) {
     return;
   }
-  const tailwindConfig = (await esmImport(path5.resolve(config.tailwind.config))).default;
-  const inputPath = path5.resolve(config.tailwind.css);
+  const tailwindConfig = (await esmImport(path4.resolve(config.tailwind.config))).default;
+  const inputPath = path4.resolve(config.tailwind.css);
   const fileName = config.tailwind.fileName ?? "tailwind.css";
   await outputCss({
     inputPath,
-    outputPath: path5.join(config.outDir, fileName),
+    outputPath: path4.join(config.outDir, fileName),
     config: tailwindConfig,
     minify: true
   });
@@ -219,28 +143,131 @@ var getDefaultK2Config = () => {
   };
 };
 
+// src/lib/vite.ts
+import path5 from "path";
+import fs2 from "fs-extra";
+import { build as viteBuild } from "vite";
+import chalk from "chalk";
+var createViteConfig = (config = {}) => {
+  const plugins = [...config.plugins ?? []];
+  try {
+    const tsconfigPaths = __require("vite-tsconfig-paths");
+    plugins.push(tsconfigPaths.default ? tsconfigPaths.default() : tsconfigPaths());
+  } catch {
+  }
+  return {
+    ...config,
+    configFile: false,
+    build: {
+      ...config.build,
+      cssCodeSplit: false,
+      rollupOptions: {
+        ...config.build?.rollupOptions,
+        onwarn: (warning, warn) => {
+          if (["MODULE_LEVEL_DIRECTIVE"].includes(warning.code ?? "")) {
+            return;
+          }
+          warn(warning);
+        }
+      }
+    },
+    plugins,
+    resolve: {
+      ...config.resolve,
+      alias: {
+        "@": path5.resolve(process.cwd(), "src"),
+        ...config.resolve?.alias
+      }
+    }
+  };
+};
+async function buildEntriesWithVite(params) {
+  const {
+    entries,
+    outDir,
+    mode = "production",
+    sourcemap = false,
+    minify = true,
+    viteConfig = {}
+  } = params;
+  for (const name of Object.keys(entries)) {
+    const entryPath = entries[name];
+    const config = createViteConfig({
+      ...viteConfig,
+      mode,
+      build: {
+        ...viteConfig.build,
+        lib: {
+          entry: entryPath,
+          name,
+          fileName: () => `${name}.js`,
+          formats: ["iife"]
+        },
+        rollupOptions: {
+          ...viteConfig.build?.rollupOptions,
+          output: {
+            assetFileNames: `${name}.[ext]`,
+            ...viteConfig.build?.rollupOptions?.output
+          }
+        },
+        outDir,
+        emptyOutDir: false,
+        sourcemap,
+        minify,
+        cssCodeSplit: false
+      }
+    });
+    await viteBuild(config);
+  }
+}
+var ENTRY_FILE_NAMES = ["index.ts", "index.tsx", "index.js", "index.jsx", "index.mjs"];
+function getEntryPointsFromDir(inputDir) {
+  const entries = {};
+  if (!fs2.existsSync(inputDir)) {
+    throw new Error(`Input directory not found: ${inputDir}`);
+  }
+  const dirs = fs2.readdirSync(inputDir, { withFileTypes: true });
+  for (const dirent of dirs) {
+    if (!dirent.isDirectory()) continue;
+    const dirName = dirent.name;
+    const dirPath = path5.join(inputDir, dirName);
+    for (const filename of ENTRY_FILE_NAMES) {
+      const entryPath = path5.join(dirPath, filename);
+      if (fs2.existsSync(entryPath)) {
+        entries[dirName] = entryPath;
+        break;
+      }
+    }
+  }
+  return entries;
+}
+
 // src/commands/build.ts
 function command() {
-  program.command("build").option("-o, --outdir <outdir>", "Output directory.", path6.join(WORKSPACE_DIRECTORY, "prod")).option("-i, --input <input>", "Input directory.", path6.join("src", "apps")).option("--config <config>", "k2 config file path").description("Build the project for production. (It's a wrapper of webpack build command.)").action(action2);
+  program.command("build").option("-o, --outdir <outdir>", "Output directory.", path6.join(WORKSPACE_DIRECTORY, "prod")).option("-i, --input <input>", "Input directory.", path6.join("src", "apps")).option("--config <config>", "k2 config file path").description("Build the project for production with Vite.").action(action);
 }
-async function action2(options) {
+async function action(options) {
   console.group("\u{1F373} Build the project for production");
   try {
     const { outdir, input, config } = options;
     const outDir = path6.resolve(outdir);
-    const allProjects = fs2.readdirSync(path6.resolve(input));
-    const entries = allProjects.reduce((acc, dir) => {
-      for (const filename of ["index.ts", "index.js", "index.mjs"]) {
-        if (fs2.existsSync(path6.join(input, dir, filename))) {
-          return { ...acc, [dir]: path6.join(input, dir, filename) };
-        }
-      }
-      return acc;
-    }, {});
+    const entries = getEntryPointsFromDir(path6.resolve(input));
+    const entryNames = Object.keys(entries);
+    if (entryNames.length === 0) {
+      throw new Error(`No entry points found in ${input}`);
+    }
+    console.log(chalk2.gray(`  Entry points: ${entryNames.join(", ")}`));
     const k2Config = config ? await importK2Config(config) : getDefaultK2Config();
     const fullConfig = { ...k2Config, outDir };
+    await fs3.emptyDir(outDir);
     const results = await Promise.allSettled([
-      action({ entries, outDir }),
+      buildEntriesWithVite({
+        entries,
+        outDir,
+        mode: "production",
+        sourcemap: false,
+        minify: true
+      }),
       buildTailwind(fullConfig)
     ]);
     for (const result of results) {
@@ -258,75 +285,15 @@ async function action2(options) {
 
 // src/commands/dev/index.ts
 import { program as program2 } from "commander";
-import "esbuild";
-import fs4 from "fs-extra";
+import { createServer } from "vite";
+import fs6 from "fs-extra";
 import path9 from "path";
-
-// src/commands/dev-base-esbuild.ts
-import "esbuild";
-import path7 from "path";
-
-// src/lib/esbuild.ts
-import chalk2 from "chalk";
-import esbuild from "esbuild";
-var completeBuildOptions = (params) => {
-  return {
-    bundle: true,
-    platform: "browser",
-    ...params,
-    plugins: [...params.plugins ?? []]
-  };
-};
-var completeDevBuildOptions = (params) => {
-  return completeBuildOptions({
-    ...params,
-    plugins: [
-      ...params.plugins ?? [],
-      {
-        name: "on-end",
-        setup: ({ onEnd }) => onEnd(
-          () => console.log(
-            chalk2.hex("#e5e7eb")(`${(/* @__PURE__ */ new Date()).toLocaleTimeString()} `) + chalk2.cyan(`[js] `) + `rebuilt`
-          )
-        )
-      }
-    ]
-  });
-};
-var getEsbuildContext = async (params) => {
-  return esbuild.context(completeDevBuildOptions(params));
-};
-var buildWithEsbuild = async (params) => {
-  const { watch = false, ...rest } = params;
-  if (watch) {
-    const context = await getEsbuildContext(rest);
-    context.watch();
-  } else {
-    const options = completeBuildOptions(rest);
-    await esbuild.build(options);
-  }
-};
-
-// src/commands/dev-base-esbuild.ts
-async function action3(params) {
-  const { entryPoints, staticDir: outdir, certDir, port } = params;
-  const context = await getEsbuildContext({ sourcemap: "inline", entryPoints, outdir });
-  const [_, serveResult] = await Promise.all([
-    context.watch(),
-    context.serve({
-      port,
-      keyfile: path7.join(certDir, "localhost-key.pem"),
-      certfile: path7.join(certDir, "localhost-cert.pem"),
-      servedir: outdir
-    })
-  ]);
-  console.log(`\u{1F680} Start development server at https://localhost:${serveResult.port}`);
-}
+import chalk4 from "chalk";
 
 // src/commands/dev/tailwind.ts
-import path8 from "path";
+import path7 from "path";
 import chalk3 from "chalk";
-import fs3 from "fs-extra";
+import fs4 from "fs-extra";
 var watchCss = async (params) => {
   const { k2Config, outdir } = params;
   if (!k2Config.tailwind?.css || !k2Config.tailwind?.config) {
@@ -334,17 +301,17 @@ var watchCss = async (params) => {
     return;
   }
   const tailwindConfig = await getTailwindConfigFromK2Config(k2Config.tailwind);
-  const input = path8.resolve(k2Config.tailwind.css);
-  const output = path8.join(outdir, "tailwind.css");
-  if (!await fs3.pathExists(output)) {
-    await fs3.outputFile(output, "");
+  const input = path7.resolve(k2Config.tailwind.css);
+  const output = path7.join(outdir, "tailwind.css");
+  if (!await fs4.pathExists(output)) {
+    await fs4.outputFile(output, "");
   }
   return watchTailwindCSS({
     input,
-    output: path8.join(outdir, "tailwind.css"),
+    output: path7.join(outdir, "tailwind.css"),
     config: tailwindConfig,
     onChanges: ({ output: output2, type }) => {
-      const outputFileName = path8.basename(output2);
+      const outputFileName = path7.basename(output2);
       console.log(
         chalk3.hex("#e5e7eb")(`${(/* @__PURE__ */ new Date()).toLocaleTimeString()} `) + chalk3.cyan(`[css] `) + outputFileName + (type === "init" ? " init" : ` rebuilt(${type})`)
       );
@@ -352,11 +319,46 @@ var watchCss = async (params) => {
   });
 };
 
+// src/lib/exec.ts
+import { exec as defaultExec } from "child_process";
+import { promisify } from "util";
+var exec = promisify(defaultExec);
+
+// src/lib/cert.ts
+import fs5 from "fs-extra";
+import path8 from "path";
+var CERT_KEY_FILENAME = "localhost-key.pem";
+var CERT_FILENAME = "localhost-cert.pem";
+var generateCert = async (outDir) => {
+  await fs5.ensureDir(outDir);
+  const { stdout } = await exec(`mkcert localhost 127.0.0.1 ::1`);
+  [
+    { input: "localhost+2.pem", output: CERT_FILENAME },
+    { input: "localhost+2-key.pem", output: CERT_KEY_FILENAME }
+  ].forEach(({ input, output }) => {
+    if (fs5.existsSync(input)) {
+      fs5.moveSync(`./${input}`, path8.join(outDir, output), {
+        overwrite: true
+      });
+    }
+  });
+  return { stdout };
+};
+function hasCertificates(certDir) {
+  return fs5.existsSync(path8.join(certDir, CERT_KEY_FILENAME)) && fs5.existsSync(path8.join(certDir, CERT_FILENAME));
+}
+function loadCertificates(certDir) {
+  return {
+    key: fs5.readFileSync(path8.join(certDir, CERT_KEY_FILENAME)),
+    cert: fs5.readFileSync(path8.join(certDir, CERT_FILENAME))
+  };
+}
+
 // src/commands/dev/index.ts
 function command2() {
-  program2.command("dev").description("Start development server.").option("-i, --input <input>", "Input directory", "src/apps").option("-o, --outdir <outdir>", "Output directory.", DEVELOPMENT_DIRECTORY).option("-c, --certdir <certdir>", "Certificate directory", WORKSPACE_DIRECTORY).option("--config <config>", "k2 config file path").option("-p, --port <port>", "Port number").action(action4);
+  program2.command("dev").description("Start development server with Vite.").option("-i, --input <input>", "Input directory", "src/apps").option("-o, --outdir <outdir>", "Output directory.", DEVELOPMENT_DIRECTORY).option("-c, --certdir <certdir>", "Certificate directory", WORKSPACE_DIRECTORY).option("--config <config>", "k2 config file path").option("-p, --port <port>", "Port number").action(action2);
 }
-async function action4(options) {
+async function action2(options) {
   const { certdir, outdir, config, port: specifiedPort, input } = options;
   console.group("\u{1F373} Start development server");
   try {
@@ -369,60 +371,85 @@ async function action4(options) {
       console.log(`\u2699 ${CONFIG_FILE_NAME} not found. use default settings.`);
     }
     const port = Number(specifiedPort ?? k2Config?.server?.port ?? DEFAULT_PORT);
-    await Promise.all([
-      build({ certdir, outdir, port, input }),
-      watchCss({ k2Config: k2Config ?? {}, outdir })
-    ]);
+    const certDirPath = path9.resolve(certdir);
+    const outputDir = path9.resolve(outdir);
+    const inputDir = path9.resolve(input);
+    if (!hasCertificates(certDirPath)) {
+      console.log(chalk4.yellow("\u{1F4DC} SSL certificates not found. Generating..."));
+      try {
+        await generateCert(certDirPath);
+        console.log(chalk4.green("\u2705 SSL certificates generated successfully"));
+      } catch (error) {
+        console.log(
+          chalk4.red("\u274C Failed to generate SSL certificates. Make sure mkcert is installed.")
+        );
+        console.log(chalk4.gray("   Install mkcert: https://github.com/FiloSottile/mkcert"));
+        throw error;
+      }
+    }
+    const entries = getEntryPointsFromDir(inputDir);
+    const entryNames = Object.keys(entries);
+    if (entryNames.length === 0) {
+      throw new Error(`No entry points found in ${input}`);
+    }
+    console.log(chalk4.gray(`  Entry points: ${entryNames.join(", ")}`));
+    await fs6.emptyDir(outputDir);
+    const { key, cert } = loadCertificates(certDirPath);
+    console.log(chalk4.gray("  Building..."));
+    await buildEntriesWithVite({
+      entries,
+      outDir: outputDir,
+      mode: "development",
+      sourcemap: "inline",
+      minify: false
+    });
+    const serverConfig = createViteConfig({
+      root: outputDir,
+      server: {
+        port,
+        https: { key, cert }
+      }
+    });
+    const server = await createServer(serverConfig);
+    await server.listen();
+    console.log(chalk4.green(`
+\u2728 Development server ready!`));
+    console.log(chalk4.cyan(`   Local: https://localhost:${port}`));
+    console.log(chalk4.gray(`   Output: ${outputDir}`));
+    console.log(chalk4.gray("\n   Watching for changes...\n"));
+    const chokidar2 = await import("chokidar");
+    const watcher = chokidar2.watch([`${input}/**/*.{ts,tsx,js,jsx,css,scss}`], {
+      ignored: /node_modules/,
+      persistent: true
+    });
+    const rebuild = async () => {
+      console.log(chalk4.gray("  Rebuilding..."));
+      await buildEntriesWithVite({
+        entries,
+        outDir: outputDir,
+        mode: "development",
+        sourcemap: "inline",
+        minify: false
+      });
+    };
+    watcher.on("change", rebuild);
+    watcher.on("add", rebuild);
+    watcher.on("unlink", rebuild);
+    if (k2Config) {
+      await watchCss({ k2Config, outdir });
+    }
   } catch (error) {
     throw error;
   } finally {
     console.groupEnd();
   }
 }
-var build = async (params) => {
-  const { outdir, certdir, port, input } = params;
-  const srcDir = path9.resolve(input);
-  const dirs = fs4.readdirSync(srcDir);
-  const entryPoints = dirs.reduce(
-    (acc, dir) => {
-      for (const filename of ["index.ts", "index.js", "index.mjs"]) {
-        if (fs4.existsSync(path9.join(srcDir, dir, filename))) {
-          return [...acc, { in: path9.join(srcDir, dir, filename), out: dir }];
-        }
-      }
-      return acc;
-    },
-    []
-  );
-  return action3({ port, entryPoints, certDir: certdir, staticDir: outdir });
-};
 
 // src/commands/genkey.ts
 import { program as program3 } from "commander";
 
-// src/lib/exec.ts
-import { exec as defaultExec } from "child_process";
-import { promisify } from "util";
-var exec = promisify(defaultExec);
-
-// src/lib/cert.ts
-import fs5 from "fs-extra";
-import path10 from "path";
-var generateCert = async (outDir) => {
-  const { stdout } = await exec(`mkcert localhost 127.0.0.1 ::1`);
-  [
-    { input: "localhost+2.pem", output: "localhost-cert.pem" },
-    { input: "localhost+2-key.pem", output: "localhost-key.pem" }
-  ].forEach(({ input, output }) => {
-    fs5.moveSync(`./${input}`, path10.join(outDir, output), {
-      overwrite: true
-    });
-  });
-  return { stdout };
-};
-
 // src/commands/genkey-base.ts
-async function action5(options) {
+async function action3(options) {
   const { output } = options;
   console.group("\u{1F373} Generate SSL key for localhost");
   try {
@@ -440,47 +467,41 @@ async function action5(options) {
 
 // src/commands/genkey.ts
 function command3() {
-  program3.command("genkey").description("Generate SSL key for localhost. (Require mkcert)").option("-o, --output <output>", "Output directory.", WORKSPACE_DIRECTORY).action(action6);
+  program3.command("genkey").description("Generate SSL key for localhost. (Require mkcert)").option("-o, --output <output>", "Output directory.", WORKSPACE_DIRECTORY).action(action4);
 }
-async function action6(options) {
-  await action5(options);
+async function action4(options) {
+  await action3(options);
 }
 
 // src/commands/build-esbuild.ts
 import { program as program4 } from "commander";
-import fs6 from "fs-extra";
-import path11 from "path";
-import "esbuild";
+import fs7 from "fs-extra";
+import path10 from "path";
+import chalk5 from "chalk";
 function command4() {
-  program4.command("esbuild-build").option("-o, --outdir <outdir>", "Output directory.", path11.join(WORKSPACE_DIRECTORY, "prod")).option("-i, --input <input>", "Input directory.", path11.join("src", "apps")).option("--config <config>", "k2 config file path").description("Build the project for production. (It's a wrapper of webpack build command.)").action(action7);
+  program4.command("esbuild-build").option("-o, --outdir <outdir>", "Output directory.", path10.join(WORKSPACE_DIRECTORY, "prod")).option("-i, --input <input>", "Input directory.", path10.join("src", "apps")).option("--config <config>", "k2 config file path").description("Build the project for production with Vite. (Legacy command name, now uses Vite)").action(action5);
 }
-async function action7(options) {
+async function action5(options) {
   console.group("\u{1F373} Build the project for production");
   try {
     const { outdir, input, config } = options;
-    const outDir = path11.resolve(outdir);
-    if (!fs6.existsSync(outDir)) {
-      fs6.mkdirSync(outDir, { recursive: true });
+    const outDir = path10.resolve(outdir);
+    const entries = getEntryPointsFromDir(path10.resolve(input));
+    const entryNames = Object.keys(entries);
+    if (entryNames.length === 0) {
+      throw new Error(`No entry points found in ${input}`);
     }
-    const allProjects = fs6.readdirSync(path11.resolve(input));
-    const entryPoints = allProjects.reduce((acc, dir) => {
-      for (const filename of ["index.ts", "index.js", "index.mjs"]) {
-        if (fs6.existsSync(path11.join(input, dir, filename))) {
-          return { ...acc, [dir]: path11.join(input, dir, filename) };
-        }
-      }
-      return acc;
-    }, {});
-    console.log(`\u{1F4C1} ${Object.keys(entryPoints).length} entry points`);
+    console.log(chalk5.gray(`  Entry points: ${entryNames.join(", ")}`));
+    await fs7.emptyDir(outDir);
     const k2Config = config ? await importK2Config(config) : getDefaultK2Config();
     const fullConfig = { ...k2Config, outDir };
     const results = await Promise.allSettled([
-      buildWithEsbuild({
-        entryPoints,
-        outdir,
+      buildEntriesWithVite({
+        entries,
+        outDir,
+        mode: "production",
         sourcemap: false,
-        minify: true,
-        legalComments: "none"
+        minify: true
       }),
       buildTailwind(fullConfig)
     ]);
@@ -531,9 +552,9 @@ async function lint() {
 
 // src/commands/lint.ts
 function command5() {
-  program5.command("lint").description("Lint source files").option("-c, --config <config>", "Config file path").action(action8);
+  program5.command("lint").description("Lint source files").option("-c, --config <config>", "Config file path").action(action6);
 }
-async function action8(options) {
+async function action6(options) {
   try {
     lint();
   } catch (error) {