@revealui/core 0.0.1-pre.0

package/dist/core/cli/bin.ts

@@ -0,0 +1,161 @@
+import { cac } from "cac"
+import { resolve } from "path"
+import {
+  runPrerenderFromCLI,
+  runPrerender_forceExit,
+} from "../renderer/prerender/runPrerender.js"
+
+import pc from "@brillout/picocolors"
+import { assertUsage } from "../gaurds/assertions/assertUsage/index.js"
+import { assertWarning } from "../gaurds/assertions/assertWarning/index.js"
+import { projectInfo } from "./utils.js"
+import { generateTypes, watchTypes } from "../types/generator.js"
+import { initProject } from "./commands/init.js"
+import { addPlugin } from "./commands/add.js"
+import { runDiagnostics, printDiagnostics } from "./commands/doctor/index.js"
+import { runFix } from "./commands/fix.js"
+import { runCheck } from "./commands/check.js"
+import { runUpgrade } from "./commands/upgrade.js"
+
+const cli = cac(projectInfo.projectName)
+
+cli
+  .command("prerender", "Pre-render the HTML of your pages", {
+    allowUnknownOptions: true,
+  })
+  .option("--configFile <path>", "[string] Path to vite.config.js")
+  .action(async (options) => {
+    assertOptions()
+    const { partial, noExtraDir, base, parallel, outDir, configFile } = options
+    const root = options.root && resolve(options.root)
+    await runPrerenderFromCLI({
+      partial,
+      noExtraDir,
+      base,
+      root,
+      parallel,
+      outDir,
+      configFile,
+    })
+    runPrerender_forceExit()
+  })
+
+cli
+  .command("generate", "Generate types from routes and PayloadCMS collections")
+  .option("--watch", "[boolean] Watch for changes and regenerate types")
+  .option("--output <dir>", "[string] Output directory for generated types")
+  .action(async (options) => {
+    const outputDir = options.output
+      ? resolve(options.output)
+      : resolve(process.cwd(), ".reveal", "types")
+
+    if (options.watch) {
+      console.log(pc.cyan("Watching for changes..."))
+      await watchTypes(outputDir, () => {
+        console.log(pc.green("Types regenerated"))
+      })
+    } else {
+      await generateTypes(outputDir)
+    }
+  })
+
+cli
+  .command("init", "Initialize a new RevealUI project")
+  .option("--template <name>", "[string] Project template (basic, blog, e-commerce, portfolio)")
+  .option("--typescript", "[boolean] Use TypeScript")
+  .option("--tailwind", "[boolean] Use Tailwind CSS")
+  .option("--payload", "[boolean] Include PayloadCMS")
+  .action(async (options) => {
+    await initProject({
+      template: options.template,
+      useTypeScript: options.typescript,
+      useTailwind: options.tailwind,
+      usePayload: options.payload,
+    })
+  })
+
+cli
+  .command("add <plugin>", "Add a plugin to your project")
+  .action(async (pluginName) => {
+    if (!pluginName) {
+      console.error(pc.red("Error: Plugin name is required"))
+      console.log("Usage: reveal add <plugin-name>")
+      process.exit(1)
+    }
+    await addPlugin({ pluginName })
+  })
+
+cli
+  .command("doctor", "Run health diagnostics on your project")
+  .action(async () => {
+    const results = await runDiagnostics()
+    printDiagnostics(results)
+    
+    const hasFailures = results.some((r) => r.status === "fail")
+    if (hasFailures) {
+      process.exit(1)
+    }
+  })
+
+cli
+  .command("check", "Quick health check (for CI/CD)")
+  .action(async () => {
+    const exitCode = await runCheck()
+    process.exit(exitCode)
+  })
+
+cli
+  .command("fix", "Automatically fix common issues")
+  .action(async () => {
+    await runFix()
+  })
+
+cli
+  .command("upgrade", "Upgrade RevealUI Framework to the latest version")
+  .action(async () => {
+    await runUpgrade()
+  })
+
+function assertOptions() {
+  // Using process.argv because cac convert names to camelCase
+  const rawOptions = process.argv.slice(3)
+  Object.values(rawOptions).forEach((option) => {
+    assertUsage(
+      !option.startsWith("--") ||
+        [
+          "--root",
+          "--partial",
+          "--noExtraDir",
+          "--clientRouter",
+          "--base",
+          "--parallel",
+          "--outDir",
+          "--configFile",
+        ].includes(option),
+      "Unknown option: " + option
+    )
+    assertWarning(
+      false,
+      `You set ${pc.cyan(option)}, but passing options to ${pc.cyan(
+        "$ reveal prerender"
+      )} is deprecated: use the config file instead. See https://reveal.dev/command-prerender.`,
+      { onlyOnce: true }
+    )
+  })
+}
+
+// Listen to unknown commands
+cli.on("command:*", () => {
+  assertUsage(false, "Unknown command: " + cli.args.join(" "))
+})
+
+cli.help()
+cli.version(projectInfo.projectVersion)
+
+cli.parse(
+  process.argv.length === 2 ? [...process.argv, "--help"] : process.argv
+)
+
+process.on("unhandledRejection", (rejectValue) => {
+  throw rejectValue
+})

package/dist/core/cli/commands/add.ts

@@ -0,0 +1,158 @@
+/**
+ * reveal add <plugin> command
+ * Install and configure RevealUI plugins
+ */
+
+import { execSync } from "node:child_process";
+import fs from "node:fs/promises";
+import path from "node:path";
+import pc from "@brillout/picocolors";
+
+/**
+ * Options for adding a plugin
+ */
+export interface AddPluginOptions {
+  /** Name of the plugin to add */
+  pluginName: string;
+  /** Plugin-specific options */
+  options?: Record<string, unknown>;
+}
+
+/**
+ * Available plugins
+ */
+const AVAILABLE_PLUGINS: Record<
+  string,
+  {
+    package: string;
+    importPath: string;
+    config?: (options?: Record<string, unknown>) => string;
+  }
+> = {
+  react: {
+    package: "reveal",
+    importPath: "reveal/plugins/react",
+    config: () => "react()",
+  },
+  payload: {
+    package: "reveal",
+    importPath: "reveal/plugins/payload",
+    config: () => "payload()",
+  },
+  vercel: {
+    package: "reveal",
+    importPath: "reveal/plugins/vercel",
+    config: () => "vercel()",
+  },
+};
+
+/**
+ * Adds a plugin to the project
+ * Installs the plugin package and updates reveal.config.ts
+ *
+ * @param options - Plugin addition options
+ * @example
+ * ```ts
+ * await addPlugin({
+ *   pluginName: 'react',
+ *   options: {},
+ * })
+ * ```
+ */
+export async function addPlugin(
+  options: AddPluginOptions
+): Promise<void> {
+  const { pluginName, options: pluginOptions = {} } = options;
+
+  if (!AVAILABLE_PLUGINS[pluginName]) {
+    throw new Error(
+      `Unknown plugin: ${pluginName}. Available plugins: ${Object.keys(AVAILABLE_PLUGINS).join(", ")}`
+    );
+  }
+
+  const plugin = AVAILABLE_PLUGINS[pluginName];
+
+  console.log(pc.cyan(`Adding plugin: ${pluginName}...`));
+
+  // Install package if needed (for future external plugins)
+  if (plugin.package !== "reveal") {
+    try {
+      execSync(`pnpm add ${plugin.package}`, { stdio: "inherit" });
+    } catch (error) {
+      console.warn(
+        pc.yellow(`Failed to install ${plugin.package}, continuing anyway...`)
+      );
+    }
+  }
+
+  // Update reveal.config.ts
+  const configPath = path.join(process.cwd(), "reveal.config.ts");
+
+  try {
+    let configContent = await fs.readFile(configPath, "utf-8");
+
+    // Check if plugin is already added
+    if (configContent.includes(plugin.importPath)) {
+      console.log(pc.yellow(`Plugin ${pluginName} is already configured`));
+      return;
+    }
+
+    // Add import
+    const importLine = `import ${pluginName} from "${plugin.importPath}";`;
+    if (!configContent.includes(importLine)) {
+      // Find the last import statement
+      const importMatch = configContent.match(/^import .+ from .+;$/gm);
+      if (importMatch && importMatch.length > 0) {
+        const lastImport = importMatch[importMatch.length - 1];
+        if (lastImport) {
+          const lastImportIndex = configContent.lastIndexOf(lastImport);
+          const insertIndex = lastImportIndex + lastImport.length;
+          configContent =
+            configContent.slice(0, insertIndex) +
+            "\n" +
+            importLine +
+            configContent.slice(insertIndex);
+        }
+      } else {
+        // No imports, add at the top
+        configContent = importLine + "\n" + configContent;
+      }
+    }
+
+    // Add to plugins array
+    const pluginConfig = plugin.config
+      ? plugin.config(pluginOptions)
+      : `${pluginName}()`;
+
+    // Find plugins array and add plugin
+    const pluginsMatch = configContent.match(/plugins:\s*\[([^\]]*)\]/);
+    if (pluginsMatch && pluginsMatch[1] !== undefined) {
+      const pluginsContent = pluginsMatch[1];
+      const newPluginsContent =
+        pluginsContent.trim() === ""
+          ? pluginConfig
+          : `${pluginsContent.trim()},\n    ${pluginConfig}`;
+      configContent = configContent.replace(
+        /plugins:\s*\[([^\]]*)\]/,
+        `plugins: [\n    ${newPluginsContent}\n  ]`
+      );
+    } else {
+      // No plugins array, add it
+      configContent = configContent.replace(
+        /defineConfig\(\{/,
+        `defineConfig({\n  plugins: [\n    ${pluginConfig}\n  ],`
+      );
+    }
+
+    await fs.writeFile(configPath, configContent, "utf-8");
+    console.log(pc.green(`✓ Plugin ${pluginName} added successfully!`));
+  } catch (error) {
+    if ((error as { code?: string }).code === "ENOENT") {
+      throw new Error(
+        "reveal.config.ts not found. Run 'reveal init' first to create a project."
+      );
+    }
+    throw error;
+  }
+}
+

package/dist/core/cli/commands/check.ts

@@ -0,0 +1,47 @@
+import { runDiagnostics } from "./doctor/index.js";
+import type { DiagnosticResult } from "./doctor/types.js";
+
+/**
+ * Quick health check command (lightweight version of doctor)
+ * Returns exit code 0 if all critical checks pass, 1 otherwise
+ * Designed for CI/CD integration
+ */
+export async function runCheck(): Promise<number> {
+  const results = await runDiagnostics();
+
+  // Filter to only critical failures
+  const criticalFailures = results.filter(
+    (r) => r.status === "fail" && isCriticalCheck(r.check)
+  );
+
+  if (criticalFailures.length === 0) {
+    // All critical checks passed
+    return 0;
+  }
+
+  // At least one critical check failed
+  console.error(
+    `\n✗ ${criticalFailures.length} critical check(s) failed:\n`
+  );
+  for (const result of criticalFailures) {
+    console.error(`  ✗ ${result.check}: ${result.message}`);
+  }
+  console.error();
+
+  return 1;
+}
+
+/**
+ * Determine if a check is critical (blocks development/deployment)
+ */
+function isCriticalCheck(check: string): boolean {
+  const criticalChecks = [
+    "reveal.config.ts exists",
+    "reveal package installed",
+    "package.json exists",
+    "required dependencies",
+  ];
+
+  return criticalChecks.some((critical) => check.includes(critical));
+}
+

package/dist/core/cli/commands/doctor/checks/build.ts

@@ -0,0 +1,83 @@
+import { execSync } from "child_process";
+import type { DiagnosticResult } from "../types.js";
+
+/**
+ * Check TypeScript compilation
+ */
+export async function checkTypeScriptCompilation(
+  cwd: string
+): Promise<DiagnosticResult[]> {
+  const results: DiagnosticResult[] = [];
+
+  try {
+    execSync("pnpm typecheck 2>&1", {
+      cwd,
+      stdio: "pipe",
+      timeout: 30000,
+    });
+    results.push({
+      check: "TypeScript compilation",
+      status: "pass",
+      message: "TypeScript compiles without errors",
+    });
+  } catch (error) {
+    const errorOutput = error instanceof Error ? error.message : String(error);
+    if (errorOutput.includes("command not found") || errorOutput.includes("Missing script")) {
+      results.push({
+        check: "TypeScript compilation",
+        status: "warn",
+        message: "TypeScript check script not found",
+        suggestion: "Add 'typecheck' script to package.json",
+      });
+    } else {
+      results.push({
+        check: "TypeScript compilation",
+        status: "fail",
+        message: "TypeScript compilation errors found",
+        suggestion: "Run 'pnpm typecheck' to see detailed errors",
+      });
+    }
+  }
+
+  return results;
+}
+
+/**
+ * Check if build process works
+ */
+export async function checkBuildProcess(
+  cwd: string
+): Promise<DiagnosticResult[]> {
+  const results: DiagnosticResult[] = [];
+
+  // Just check if build script exists, don't actually run it
+  try {
+    const { readFileSync } = await import("fs");
+    const packageJsonPath = `${cwd}/package.json`;
+    const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+
+    if (packageJson.scripts?.build) {
+      results.push({
+        check: "build script",
+        status: "pass",
+        message: "Build script found in package.json",
+      });
+    } else {
+      results.push({
+        check: "build script",
+        status: "warn",
+        message: "Build script not found",
+        suggestion: "Add 'build' script to package.json",
+      });
+    }
+  } catch {
+    results.push({
+      check: "build script",
+      status: "warn",
+      message: "Could not check build script",
+    });
+  }
+
+  return results;
+}
+

package/dist/core/cli/commands/doctor/checks/config.ts

@@ -0,0 +1,130 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import type { DiagnosticResult } from "../types.js";
+
+/**
+ * Check reveal.config.ts exists and is valid
+ */
+export async function checkRevealConfig(
+  cwd: string
+): Promise<DiagnosticResult[]> {
+  const results: DiagnosticResult[] = [];
+  const configPath = path.join(cwd, "reveal.config.ts");
+
+  try {
+    await fs.access(configPath);
+    const content = await fs.readFile(configPath, "utf-8");
+
+    // Basic syntax check (look for export default)
+    if (content.includes("export default")) {
+      results.push({
+        check: "reveal.config.ts exists",
+        status: "pass",
+        message: "Configuration file found and appears valid",
+      });
+    } else {
+      results.push({
+        check: "reveal.config.ts exists",
+        status: "warn",
+        message: "Configuration file found but may be invalid",
+        suggestion: "Ensure 'export default defineConfig({...})' is present",
+      });
+    }
+  } catch {
+    results.push({
+      check: "reveal.config.ts exists",
+      status: "fail",
+      message: "Configuration file not found",
+      suggestion: "Run 'reveal init' to create a configuration file",
+    });
+  }
+
+  return results;
+}
+
+/**
+ * Check TypeScript configuration
+ */
+export async function checkTypeScriptConfig(
+  cwd: string
+): Promise<DiagnosticResult[]> {
+  const results: DiagnosticResult[] = [];
+  const tsconfigPath = path.join(cwd, "tsconfig.json");
+
+  try {
+    await fs.access(tsconfigPath);
+    const tsconfig = JSON.parse(await fs.readFile(tsconfigPath, "utf-8"));
+
+    if (tsconfig.compilerOptions?.strict) {
+      results.push({
+        check: "TypeScript configuration",
+        status: "pass",
+        message: "tsconfig.json found with strict mode enabled",
+      });
+    } else {
+      results.push({
+        check: "TypeScript configuration",
+        status: "warn",
+        message: "tsconfig.json found but strict mode is disabled",
+        suggestion: "Enable 'strict: true' in compilerOptions for better type safety",
+      });
+    }
+  } catch {
+    results.push({
+      check: "TypeScript configuration",
+      status: "warn",
+      message: "tsconfig.json not found",
+      suggestion: "Consider adding TypeScript for better type safety",
+    });
+  }
+
+  return results;
+}
+
+/**
+ * Check environment variables
+ */
+export async function checkEnvironmentVariables(
+  cwd: string
+): Promise<DiagnosticResult[]> {
+  const results: DiagnosticResult[] = [];
+  const envTemplatePath = path.join(cwd, ".env.template");
+  const envLocalPath = path.join(cwd, ".env.local");
+
+  // Check for .env.template
+  try {
+    await fs.access(envTemplatePath);
+    results.push({
+      check: "Environment template",
+      status: "pass",
+      message: ".env.template found",
+    });
+  } catch {
+    results.push({
+      check: "Environment template",
+      status: "warn",
+      message: ".env.template not found",
+      suggestion: "Create .env.template to document required environment variables",
+    });
+  }
+
+  // Check if .env.local exists (user should have this)
+  try {
+    await fs.access(envLocalPath);
+    results.push({
+      check: "Environment configuration",
+      status: "pass",
+      message: ".env.local found",
+    });
+  } catch {
+    results.push({
+      check: "Environment configuration",
+      status: "warn",
+      message: ".env.local not found",
+      suggestion: "Create .env.local from .env.template and fill in your values",
+    });
+  }
+
+  return results;
+}
+