@adddog/build-configs 0.0.1

package/dist/cli/index.mjs

@@ -0,0 +1,832 @@
+#!/usr/bin/env node
+import { cac } from 'cac';
+import { consola } from 'consola';
+import pc from 'picocolors';
+import { execa } from 'execa';
+import { existsSync, writeFileSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { readFile, writeFile } from 'node:fs/promises';
+import { createJiti } from 'jiti';
+import { defu } from 'defu';
+import { getPreset, listPresets } from '../presets/index.mjs';
+import { makeTsupConfig } from '../tsup.config.mjs';
+import { makeUnbuildConfig } from '../unbuild.config.mjs';
+import * as p from '@clack/prompts';
+import { z } from 'zod';
+import 'tsup';
+import 'unbuild';
+
+const version = "0.0.1";
+
+const logger = consola.create({
+  formatOptions: {
+    colors: true,
+    compact: false,
+    date: false
+  }
+});
+const colors = {
+  primary: pc.cyan,
+  success: pc.green,
+  warning: pc.yellow,
+  error: pc.red,
+  info: pc.blue,
+  dim: pc.dim,
+  bold: pc.bold,
+  bundler: pc.magenta,
+  file: pc.yellow,
+  command: pc.green
+};
+function logSuccess(message) {
+  logger.success(colors.success(message));
+}
+function logError(message, error) {
+  logger.error(colors.error(message));
+  if (error) {
+    logger.error(colors.dim(error.message));
+    if (error.stack) {
+      logger.error(colors.dim(error.stack));
+    }
+  }
+}
+function logBundler(bundler) {
+  logger.info(`Using bundler: ${colors.bundler(bundler)}`);
+}
+function logBox(title, content) {
+  const maxLength = Math.max(
+    title.length,
+    ...content.map((line) => line.length)
+  );
+  const border = "\u2500".repeat(maxLength + 4);
+  console.log(colors.primary(`\u250C${border}\u2510`));
+  console.log(
+    colors.primary(`\u2502  ${colors.bold(title.padEnd(maxLength))}  \u2502`)
+  );
+  console.log(colors.primary(`\u251C${border}\u2524`));
+  content.forEach((line) => {
+    console.log(colors.primary(`\u2502  ${line.padEnd(maxLength)}  \u2502`));
+  });
+  console.log(colors.primary(`\u2514${border}\u2518`));
+}
+
+const CONFIG_FILES = [
+  "build.config.ts",
+  "build.config.js",
+  "build.config.mjs",
+  "build.config.cjs",
+  "tsup.config.ts",
+  "tsup.config.js",
+  "tsup.config.mjs",
+  ".radbuildrc.ts",
+  ".radbuildrc.js",
+  ".radbuildrc.json"
+];
+async function detectBundler(cwd = process.cwd()) {
+  for (const file of ["tsup.config.ts", "tsup.config.js", "tsup.config.mjs"]) {
+    if (existsSync(join(cwd, file))) {
+      return "tsup";
+    }
+  }
+  for (const file of [
+    "build.config.ts",
+    "build.config.js",
+    "build.config.mjs"
+  ]) {
+    if (existsSync(join(cwd, file))) {
+      const configPath = join(cwd, file);
+      try {
+        const jiti = createJiti(cwd, {
+          interopDefault: true
+        });
+        const config = await jiti.import(configPath);
+        if (config.entries || config.rollup || config[0] && config[0].entries) {
+          return "unbuild";
+        }
+      } catch {
+      }
+    }
+  }
+  try {
+    const pkgPath = join(cwd, "package.json");
+    if (existsSync(pkgPath)) {
+      const pkg = JSON.parse(await readFile(pkgPath, "utf-8"));
+      if (pkg.scripts?.build) {
+        if (pkg.scripts.build.includes("tsup")) return "tsup";
+        if (pkg.scripts.build.includes("unbuild")) return "unbuild";
+      }
+    }
+  } catch {
+  }
+  return null;
+}
+async function discoverConfigFile(cwd = process.cwd(), customPath) {
+  if (customPath) {
+    const fullPath = resolve(cwd, customPath);
+    if (existsSync(fullPath)) {
+      return fullPath;
+    }
+    logger.warn(`Custom config file not found: ${customPath}`);
+    return null;
+  }
+  for (const file of CONFIG_FILES) {
+    const fullPath = join(cwd, file);
+    if (existsSync(fullPath)) {
+      return fullPath;
+    }
+  }
+  const pkgPath = join(cwd, "package.json");
+  if (existsSync(pkgPath)) {
+    try {
+      const pkg = JSON.parse(await readFile(pkgPath, "utf-8"));
+      if (pkg.radbuild) {
+        return pkgPath;
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+async function loadConfigFile(configPath, cwd = process.cwd()) {
+  try {
+    if (configPath.endsWith("package.json")) {
+      const pkg = JSON.parse(await readFile(configPath, "utf-8"));
+      return pkg.radbuild || null;
+    }
+    if (configPath.endsWith(".json")) {
+      return JSON.parse(await readFile(configPath, "utf-8"));
+    }
+    const jiti = createJiti(cwd, {
+      interopDefault: true
+    });
+    const config = await jiti.import(configPath);
+    return config;
+  } catch (error) {
+    logger.error(
+      `Failed to load config from ${configPath}`,
+      error
+    );
+    return null;
+  }
+}
+async function loadConfig(options) {
+  const cwd = options.cwd ?? process.cwd();
+  let bundler = options.bundler === "auto" ? null : options.bundler;
+  if (!bundler) {
+    bundler = await detectBundler(cwd) ?? "unbuild";
+  }
+  let presetConfig = {};
+  if (options.preset) {
+    const preset = getPreset(options.preset);
+    if (preset) {
+      presetConfig = bundler === "tsup" ? preset.tsup ?? {} : preset.unbuild ?? {};
+      logger.info(`Using preset: ${preset.name}`);
+    } else {
+      logger.warn(`Preset not found: ${options.preset}`);
+    }
+  }
+  const configPath = await discoverConfigFile(cwd, options.configPath);
+  let projectConfig = {};
+  if (configPath) {
+    const loaded = await loadConfigFile(configPath, cwd);
+    if (loaded) {
+      projectConfig = loaded;
+      logger.info(`Loaded config from: ${configPath}`);
+    }
+  }
+  const config = defu(
+    options.cliFlags ?? {},
+    projectConfig,
+    presetConfig,
+    {}
+    // Default config is applied in the makers
+  );
+  return {
+    config,
+    bundler,
+    configPath
+  };
+}
+async function getPackageJson(cwd = process.cwd()) {
+  try {
+    const pkgPath = join(cwd, "package.json");
+    if (!existsSync(pkgPath)) return null;
+    return JSON.parse(await readFile(pkgPath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+async function updatePackageJson(updates, cwd = process.cwd()) {
+  const { writeFile } = await import('node:fs/promises');
+  const pkgPath = join(cwd, "package.json");
+  const pkg = await getPackageJson(cwd) ?? {};
+  const updated = defu(updates, pkg);
+  await writeFile(pkgPath, JSON.stringify(updated, null, 2) + "\n");
+}
+
+async function buildCommand(entries, options) {
+  try {
+    logger.start("Building project...");
+    const cliFlags = {};
+    if (options.format) {
+      cliFlags.format = options.format.split(",");
+    }
+    if (options.minify !== void 0) {
+      cliFlags.minify = options.minify;
+    }
+    if (options.sourcemap !== void 0) {
+      cliFlags.sourcemap = options.sourcemap;
+    }
+    if (options.dts !== void 0) {
+      cliFlags.dts = options.dts;
+      cliFlags.declaration = options.dts;
+    }
+    if (options.clean !== void 0) {
+      cliFlags.clean = options.clean;
+    }
+    if (entries.length > 0) {
+      cliFlags.entry = entries;
+      cliFlags.entries = entries;
+    }
+    const { config, bundler, configPath } = await loadConfig({
+      ...options.config && { configPath: options.config },
+      ...options.preset && { preset: options.preset },
+      bundler: options.bundler ?? "auto",
+      cliFlags
+    });
+    logBundler(bundler);
+    const tempConfigPath = join(
+      process.cwd(),
+      `.rad-build-temp.${bundler === "tsup" ? "tsup" : "build"}.config.js`
+    );
+    try {
+      const finalConfig = bundler === "tsup" ? makeTsupConfig(config) : makeUnbuildConfig(config);
+      const configContent = `export default ${JSON.stringify(finalConfig, null, 2)}`;
+      writeFileSync(tempConfigPath, configContent);
+      if (bundler === "tsup") {
+        await execa(
+          "tsup",
+          [
+            "--config",
+            tempConfigPath,
+            ...options.watch ? ["--watch"] : []
+          ],
+          {
+            stdio: "inherit",
+            cwd: process.cwd()
+          }
+        );
+      } else {
+        await execa(
+          "unbuild",
+          [
+            ...options.watch ? ["--watch"] : [],
+            ...configPath ? [] : ["--config", tempConfigPath]
+          ],
+          {
+            stdio: "inherit",
+            cwd: process.cwd()
+          }
+        );
+      }
+      logSuccess("Build completed successfully!");
+    } finally {
+      if (existsSync(tempConfigPath)) {
+        try {
+          const { unlinkSync } = await import('node:fs');
+          unlinkSync(tempConfigPath);
+        } catch {
+        }
+      }
+    }
+  } catch (error) {
+    logError("Build failed", error);
+    process.exit(1);
+  }
+}
+
+function generateTsupConfig(options = {}) {
+  const config = {
+    entry: options.entry ?? ["src/index.ts"],
+    format: options.format ?? ["esm", "cjs"],
+    dts: options.dts ?? true,
+    sourcemap: options.sourcemap ?? true,
+    clean: options.clean ?? true,
+    ...options
+  };
+  return `import { makeTsupConfig } from "@adddog/build-configs/tsup";
+
+export default makeTsupConfig(${JSON.stringify(config, null, 2)});
+`;
+}
+function generateUnbuildConfig(options = {}) {
+  const config = {
+    entries: options.entries ?? ["src/index"],
+    declaration: options.declaration ?? true,
+    rollup: {
+      emitCJS: options.rollup?.emitCJS ?? false,
+      ...options.rollup
+    },
+    ...options
+  };
+  return `import { makeUnbuildConfig } from "@adddog/build-configs/unbuild";
+
+export default makeUnbuildConfig(${JSON.stringify(config, null, 2)});
+`;
+}
+function generatePackageJsonScripts(bundler) {
+  const buildCommand = bundler === "tsup" ? "tsup" : "unbuild";
+  const watchCommand = bundler === "tsup" ? "tsup --watch" : "unbuild --watch";
+  return {
+    build: buildCommand,
+    "build:watch": watchCommand,
+    prepublishOnly: "pnpm build"
+  };
+}
+function generatePackageJsonExports(_bundler, formats) {
+  const hasESM = formats.includes("esm");
+  const hasCJS = formats.includes("cjs");
+  if (hasESM && hasCJS) {
+    return {
+      ".": {
+        types: "./dist/index.d.ts",
+        import: "./dist/index.mjs",
+        require: "./dist/index.cjs"
+      }
+    };
+  } else if (hasESM) {
+    return {
+      ".": {
+        types: "./dist/index.d.ts",
+        import: "./dist/index.mjs"
+      }
+    };
+  } else {
+    return {
+      ".": {
+        types: "./dist/index.d.ts",
+        require: "./dist/index.cjs"
+      }
+    };
+  }
+}
+
+async function initCommand(options) {
+  try {
+    p.intro(colors.bold("Welcome to @adddog/build-configs!"));
+    const tsupConfigExists = existsSync("tsup.config.ts");
+    const buildConfigExists = existsSync("build.config.ts");
+    if ((tsupConfigExists || buildConfigExists) && !options.force) {
+      const shouldOverwrite = await p.confirm({
+        message: "Config file already exists. Overwrite?",
+        initialValue: false
+      });
+      if (p.isCancel(shouldOverwrite) || !shouldOverwrite) {
+        p.cancel("Operation cancelled");
+        process.exit(0);
+      }
+    }
+    const bundler = options.bundler ?? await p.select({
+      message: "Which bundler do you prefer?",
+      options: [
+        {
+          value: "unbuild",
+          label: "unbuild",
+          hint: "Preserves file structure, better for libraries"
+        },
+        {
+          value: "tsup",
+          label: "tsup",
+          hint: "Faster builds, bundles everything"
+        }
+      ]
+    });
+    if (p.isCancel(bundler)) {
+      p.cancel("Operation cancelled");
+      process.exit(0);
+    }
+    const usePreset = await p.select({
+      message: "Start with a preset or custom config?",
+      options: [
+        { value: "preset", label: "Use a preset" },
+        { value: "custom", label: "Custom configuration" }
+      ]
+    });
+    if (p.isCancel(usePreset)) {
+      p.cancel("Operation cancelled");
+      process.exit(0);
+    }
+    let selectedPreset;
+    let finalConfig = {};
+    if (usePreset === "preset") {
+      const availablePresets = listPresets().filter((name) => {
+        const preset2 = getPreset(name);
+        return preset2 && (preset2.bundler === bundler || preset2.bundler === "both");
+      });
+      const presetChoice = await p.select({
+        message: "Select a preset:",
+        options: availablePresets.map((name) => {
+          const preset2 = getPreset(name);
+          return {
+            value: name,
+            label: name,
+            hint: preset2.description
+          };
+        })
+      });
+      selectedPreset = String(presetChoice);
+      if (p.isCancel(selectedPreset)) {
+        p.cancel("Operation cancelled");
+        process.exit(0);
+      }
+      const preset = getPreset(selectedPreset);
+      if (preset) {
+        finalConfig = bundler === "tsup" ? preset.tsup ?? {} : preset.unbuild ?? {};
+      }
+    } else {
+      const formats = await p.multiselect({
+        message: "Output formats?",
+        options: [
+          { value: "esm", label: "ESM (modern)" },
+          { value: "cjs", label: "CommonJS (compatibility)" },
+          ...bundler === "tsup" ? [{ value: "iife", label: "IIFE (browser global)" }] : []
+        ],
+        initialValues: ["esm"],
+        required: true
+      });
+      if (p.isCancel(formats)) {
+        p.cancel("Operation cancelled");
+        process.exit(0);
+      }
+      const features = await p.multiselect({
+        message: "Additional features?",
+        options: [
+          { value: "sourcemaps", label: "Generate sourcemaps" },
+          { value: "minify", label: "Minify output" },
+          { value: "declarations", label: "TypeScript declarations" }
+        ],
+        initialValues: ["sourcemaps", "declarations"]
+      });
+      if (p.isCancel(features)) {
+        p.cancel("Operation cancelled");
+        process.exit(0);
+      }
+      finalConfig = {
+        format: formats,
+        sourcemap: features.includes("sourcemaps"),
+        minify: features.includes("minify")
+      };
+      if (bundler === "tsup") {
+        finalConfig.dts = features.includes("declarations");
+      } else {
+        finalConfig.declaration = features.includes(
+          "declarations"
+        );
+        finalConfig.rollup = {
+          emitCJS: formats.includes("cjs")
+        };
+      }
+    }
+    const spinner = p.spinner();
+    spinner.start("Creating configuration files...");
+    try {
+      const configFileName = bundler === "tsup" ? "tsup.config.ts" : "build.config.ts";
+      const configContent = bundler === "tsup" ? generateTsupConfig(finalConfig) : generateUnbuildConfig(finalConfig);
+      await writeFile(join(process.cwd(), configFileName), configContent);
+      const pkg = await getPackageJson();
+      if (pkg) {
+        const scripts = generatePackageJsonScripts(bundler);
+        const exports = generatePackageJsonExports(
+          bundler,
+          finalConfig.format ?? ["esm", "cjs"]
+        );
+        await updatePackageJson({
+          scripts: { ...pkg.scripts, ...scripts },
+          exports,
+          main: finalConfig.format?.includes("cjs") || finalConfig.rollup?.emitCJS ? "./dist/index.cjs" : void 0,
+          module: "./dist/index.mjs",
+          types: "./dist/index.d.ts",
+          files: ["dist"]
+        });
+      }
+      spinner.stop("Configuration created successfully!");
+      p.outro(
+        colors.success(`
+Next steps:
+  1. ${colors.command("pnpm install")} - Install dependencies
+  2. ${colors.command("pnpm build")} - Build your project
+  3. Edit ${colors.file(configFileName)} to customize
+
+${selectedPreset ? `Using preset: ${colors.primary(selectedPreset)}` : ""}
+
+Happy building! \u{1F680}
+            `)
+      );
+    } catch (error) {
+      spinner.stop("Failed to create configuration");
+      throw error;
+    }
+  } catch (error) {
+    logError("Initialization failed", error);
+    process.exit(1);
+  }
+}
+
+const TsupFormatSchema = z.enum(["cjs", "esm", "iife"]);
+const TsupPlatformSchema = z.enum(["node", "browser", "neutral"]);
+const TsupDtsSchema = z.union([
+  z.boolean(),
+  z.string(),
+  z.object({
+    entry: z.any().optional(),
+    resolve: z.union([z.boolean(), z.array(z.union([z.string(), z.instanceof(RegExp)]))]).optional(),
+    only: z.boolean().optional(),
+    banner: z.string().optional(),
+    footer: z.string().optional(),
+    compilerOptions: z.any().optional()
+  })
+]);
+const TsupEntrySchema = z.union([
+  z.array(z.string()),
+  z.record(z.string(), z.string())
+]);
+const TsupConfigSchema = z.object({
+  name: z.string().optional(),
+  entry: TsupEntrySchema.optional(),
+  entryPoints: TsupEntrySchema.optional(),
+  format: z.union([TsupFormatSchema, z.array(TsupFormatSchema)]).optional(),
+  outDir: z.string().optional(),
+  target: z.union([z.string(), z.array(z.string())]).optional(),
+  platform: TsupPlatformSchema.optional(),
+  dts: TsupDtsSchema.optional(),
+  experimentalDts: z.union([
+    z.boolean(),
+    z.string(),
+    z.object({
+      entry: z.any().optional(),
+      compilerOptions: z.any().optional()
+    })
+  ]).optional(),
+  sourcemap: z.union([z.boolean(), z.literal("inline")]).optional(),
+  minify: z.union([z.boolean(), z.literal("terser")]).optional(),
+  bundle: z.boolean().optional(),
+  splitting: z.boolean().optional(),
+  clean: z.union([z.boolean(), z.array(z.string())]).optional(),
+  treeshake: z.any().optional(),
+  external: z.array(z.union([z.string(), z.instanceof(RegExp)])).optional(),
+  noExternal: z.array(z.union([z.string(), z.instanceof(RegExp)])).optional(),
+  skipNodeModulesBundle: z.boolean().optional(),
+  keepNames: z.boolean().optional(),
+  watch: z.union([z.boolean(), z.string(), z.array(z.union([z.string(), z.boolean()]))]).optional(),
+  ignoreWatch: z.union([z.array(z.string()), z.string()]).optional(),
+  tsconfig: z.string().optional(),
+  shims: z.boolean().optional(),
+  cjsInterop: z.boolean().optional(),
+  removeNodeProtocol: z.boolean().optional()
+});
+const UnbuildBuilderSchema = z.enum(["rollup", "mkdist", "copy", "untyped"]);
+const UnbuildDeclarationSchema = z.union([
+  z.boolean(),
+  z.literal("compatible"),
+  z.literal("node16")
+]);
+const UnbuildEntrySchema = z.union([
+  z.string(),
+  z.object({
+    builder: UnbuildBuilderSchema.optional(),
+    input: z.string(),
+    name: z.string().optional(),
+    outDir: z.string().optional(),
+    declaration: UnbuildDeclarationSchema.optional(),
+    format: z.enum(["esm", "cjs"]).optional(),
+    ext: z.string().optional()
+  })
+]);
+const UnbuildConfigSchema = z.object({
+  name: z.string().optional(),
+  rootDir: z.string().optional(),
+  entries: z.array(UnbuildEntrySchema).optional(),
+  outDir: z.string().optional(),
+  clean: z.boolean().optional(),
+  declaration: UnbuildDeclarationSchema.optional(),
+  sourcemap: z.boolean().optional(),
+  stub: z.boolean().optional(),
+  watch: z.boolean().optional(),
+  parallel: z.boolean().optional(),
+  externals: z.array(z.union([z.string(), z.instanceof(RegExp)])).optional(),
+  alias: z.record(z.string(), z.string()).optional(),
+  replace: z.record(z.string(), z.string()).optional(),
+  failOnWarn: z.boolean().optional(),
+  rollup: z.object({
+    emitCJS: z.boolean().optional(),
+    cjsBridge: z.boolean().optional(),
+    preserveDynamicImports: z.boolean().optional(),
+    inlineDependencies: z.union([z.boolean(), z.array(z.union([z.string(), z.instanceof(RegExp)]))]).optional()
+  }).optional()
+});
+function validateTsupConfig(config) {
+  return TsupConfigSchema.safeParse(config);
+}
+function validateUnbuildConfig(config) {
+  return UnbuildConfigSchema.safeParse(config);
+}
+function validateConfig(config, bundler) {
+  if (bundler === "tsup") {
+    return validateTsupConfig(config);
+  }
+  return validateUnbuildConfig(config);
+}
+
+async function validateCommand(options) {
+  try {
+    logger.start("Validating configuration...");
+    const configPath = await discoverConfigFile(
+      process.cwd(),
+      options.config
+    );
+    if (!configPath) {
+      logError("No configuration file found");
+      logger.info("Run 'rad-build init' to create a configuration file");
+      process.exit(1);
+    }
+    logger.info(`Found config: ${colors.file(configPath)}`);
+    const { config, bundler } = await loadConfig({
+      ...options.config && { configPath: options.config },
+      bundler: options.bundler ?? "auto"
+    });
+    logger.info(`Detected bundler: ${colors.bundler(bundler)}`);
+    const result = validateConfig(config, bundler);
+    if (result.success) {
+      logSuccess("\u2713 Configuration is valid!");
+      logger.info("\nConfiguration summary:");
+      if (bundler === "tsup") {
+        const tsupConfig = config;
+        logger.info(`  Entry: ${JSON.stringify(tsupConfig.entry ?? ["src/index.ts"])}`);
+        logger.info(`  Format: ${JSON.stringify(tsupConfig.format ?? ["esm", "cjs"])}`);
+        logger.info(`  DTS: ${tsupConfig.dts !== false ? "enabled" : "disabled"}`);
+        logger.info(
+          `  Sourcemap: ${tsupConfig.sourcemap !== false ? "enabled" : "disabled"}`
+        );
+      } else {
+        const unbuildConfig = config;
+        logger.info(
+          `  Entries: ${JSON.stringify(unbuildConfig.entries ?? ["src/index"])}`
+        );
+        logger.info(
+          `  Declaration: ${unbuildConfig.declaration !== false ? "enabled" : "disabled"}`
+        );
+        logger.info(
+          `  CJS: ${unbuildConfig.rollup?.emitCJS ? "enabled" : "disabled"}`
+        );
+      }
+    } else {
+      logError("\u2717 Configuration validation failed");
+      if (result.error) {
+        logger.error("\nValidation errors:");
+        result.error.errors.forEach((err) => {
+          logger.error(`  ${colors.error("\u2022")} ${err.path.join(".")}: ${err.message}`);
+        });
+      }
+      process.exit(1);
+    }
+  } catch (error) {
+    logError("Validation failed", error);
+    process.exit(1);
+  }
+}
+
+async function infoCommand(options) {
+  try {
+    logger.start("Gathering project information...\n");
+    const pkg = await getPackageJson();
+    const projectName = pkg?.name ?? "unknown";
+    const projectVersion = pkg?.version ?? "0.0.0";
+    const configPath = await discoverConfigFile(
+      process.cwd(),
+      options.config
+    );
+    let bundler = "none";
+    let config = {};
+    if (configPath) {
+      const loaded = await loadConfig({
+        ...options.config && { configPath: options.config },
+        bundler: "auto"
+      });
+      bundler = loaded.bundler;
+      config = loaded.config;
+    }
+    logBox("Project Information", [
+      `Name:    ${colors.primary(projectName)}`,
+      `Version: ${colors.primary(projectVersion)}`,
+      `Config:  ${configPath ? colors.file(configPath) : colors.dim("not found")}`,
+      `Bundler: ${bundler !== "none" ? colors.bundler(bundler) : colors.dim("not configured")}`
+    ]);
+    if (bundler !== "none") {
+      console.log("\n" + colors.bold("Build Configuration:"));
+      if (bundler === "tsup") {
+        const tsupConfig = config;
+        console.log(colors.dim("\u251C\u2500") + " Entry:      " + JSON.stringify(tsupConfig.entry ?? ["src/index.ts"]));
+        console.log(colors.dim("\u251C\u2500") + " Format:     " + JSON.stringify(tsupConfig.format ?? ["esm", "cjs"]));
+        console.log(
+          colors.dim("\u251C\u2500") + " Target:     " + (tsupConfig.target ?? "node18")
+        );
+        console.log(
+          colors.dim("\u251C\u2500") + " Platform:   " + (tsupConfig.platform ?? "node")
+        );
+        console.log(
+          colors.dim("\u251C\u2500") + " DTS:        " + (tsupConfig.dts !== false ? colors.success("\u2713") : colors.dim("\u2717"))
+        );
+        console.log(
+          colors.dim("\u251C\u2500") + " Sourcemap:  " + (tsupConfig.sourcemap !== false ? colors.success("\u2713") : colors.dim("\u2717"))
+        );
+        console.log(
+          colors.dim("\u251C\u2500") + " Minify:     " + (tsupConfig.minify ? colors.success("\u2713") : colors.dim("\u2717"))
+        );
+        console.log(
+          colors.dim("\u2514\u2500") + " Clean:      " + (tsupConfig.clean !== false ? colors.success("\u2713") : colors.dim("\u2717"))
+        );
+      } else {
+        const unbuildConfig = config;
+        console.log(
+          colors.dim("\u251C\u2500") + " Entries:      " + JSON.stringify(unbuildConfig.entries ?? ["src/index"])
+        );
+        console.log(
+          colors.dim("\u251C\u2500") + " Out Dir:      " + (unbuildConfig.outDir ?? "dist")
+        );
+        console.log(
+          colors.dim("\u251C\u2500") + " Declaration:  " + (unbuildConfig.declaration !== false ? colors.success("\u2713") : colors.dim("\u2717"))
+        );
+        console.log(
+          colors.dim("\u251C\u2500") + " Emit CJS:     " + (unbuildConfig.rollup?.emitCJS ? colors.success("\u2713") : colors.dim("\u2717"))
+        );
+        console.log(
+          colors.dim("\u251C\u2500") + " Sourcemap:    " + (unbuildConfig.sourcemap ? colors.success("\u2713") : colors.dim("\u2717"))
+        );
+        console.log(
+          colors.dim("\u251C\u2500") + " Parallel:     " + (unbuildConfig.parallel !== false ? colors.success("\u2713") : colors.dim("\u2717"))
+        );
+        console.log(
+          colors.dim("\u2514\u2500") + " Clean:        " + (unbuildConfig.clean !== false ? colors.success("\u2713") : colors.dim("\u2717"))
+        );
+      }
+    }
+    if (pkg?.exports) {
+      console.log("\n" + colors.bold("Package Exports:"));
+      console.log(JSON.stringify(pkg.exports, null, 2));
+    }
+    if (pkg?.scripts) {
+      const buildScripts = Object.entries(pkg.scripts).filter(
+        ([key]) => key.includes("build") || key.includes("watch")
+      );
+      if (buildScripts.length > 0) {
+        console.log("\n" + colors.bold("Build Scripts:"));
+        buildScripts.forEach(([name, script]) => {
+          console.log(`  ${colors.command(name.padEnd(20))} ${colors.dim(script)}`);
+        });
+      }
+    }
+    if (bundler === "none") {
+      console.log("\n" + colors.warning("\u26A0 No build configuration found"));
+      console.log(
+        colors.info("\nRun ") + colors.command("rad-build init") + colors.info(" to set up your project")
+      );
+    }
+  } catch (error) {
+    logger.error("Failed to gather information", error);
+    process.exit(1);
+  }
+}
+
+async function watchCommand(options) {
+  logger.info("Starting watch mode...");
+  await buildCommand([], {
+    ...options,
+    watch: true
+  });
+}
+
+const cli = cac("rad-build");
+cli.version(version).help();
+cli.command("[...entries]", "Build your project").option("--config <path>", "Path to config file").option("--preset <name>", "Use a preset configuration").option("--bundler <bundler>", "Specify bundler: tsup or unbuild").option("--format <formats>", "Output formats (comma-separated)").option("--minify", "Minify output").option("--watch", "Watch mode").option("--sourcemap", "Generate sourcemaps").option("--dts", "Generate TypeScript declarations").option("--clean", "Clean output directory before build").action(buildCommand);
+cli.command("init", "Initialize build configuration").option("--bundler <bundler>", "Specify bundler: tsup or unbuild").option("--preset <name>", "Use a preset configuration").option("--force", "Overwrite existing config").action(initCommand);
+cli.command("validate", "Validate build configuration").option("--config <path>", "Path to config file").option("--bundler <bundler>", "Specify bundler: tsup or unbuild").action(validateCommand);
+cli.command("info", "Show build configuration and environment info").option("--config <path>", "Path to config file").action(infoCommand);
+cli.command("watch", "Watch and rebuild on file changes").option("--config <path>", "Path to config file").option("--preset <name>", "Use a preset configuration").option("--bundler <bundler>", "Specify bundler: tsup or unbuild").action(watchCommand);
+cli.command("list-presets", "List all available presets").action(async () => {
+  const { presetCategories } = await import('../presets/index.mjs');
+  logBox("Available Presets", [
+    "",
+    ...Object.entries(presetCategories).flatMap(([category, presets]) => [
+      colors.bold(category.toUpperCase()),
+      ...Object.entries(presets).map(
+        ([name, preset]) => `  ${colors.primary(name.padEnd(25))} - ${colors.dim(preset.description)}`
+      ),
+      ""
+    ])
+  ]);
+});
+cli.parse();
+process.on("unhandledRejection", (error) => {
+  logger.error("Unhandled error:", error);
+  process.exit(1);
+});
+//# sourceMappingURL=index.mjs.map