@revealui/core 0.0.1-pre.0

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

@@ -0,0 +1,144 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import type { DiagnosticResult } from "../types.js";
+
+/**
+ * Check package.json exists and has reveal package
+ */
+export async function checkRevealPackage(
+  cwd: string
+): Promise<DiagnosticResult[]> {
+  const results: DiagnosticResult[] = [];
+  const packageJsonPath = path.join(cwd, "package.json");
+
+  try {
+    const content = await fs.readFile(packageJsonPath, "utf-8");
+    const packageJson = JSON.parse(content);
+
+    if (packageJson.dependencies?.reveal || packageJson.devDependencies?.reveal) {
+      const version =
+        packageJson.dependencies?.reveal || packageJson.devDependencies?.reveal;
+      results.push({
+        check: "reveal package installed",
+        status: "pass",
+        message: `RevealUI package is installed (${version})`,
+      });
+    } else {
+      results.push({
+        check: "reveal package installed",
+        status: "fail",
+        message: "RevealUI package not found in dependencies",
+        suggestion: "Run 'pnpm add reveal' to install",
+      });
+    }
+  } catch {
+    results.push({
+      check: "package.json exists",
+      status: "fail",
+      message: "package.json not found",
+      suggestion: "Initialize a Node.js project first",
+    });
+  }
+
+  return results;
+}
+
+/**
+ * Check required dependencies
+ */
+export async function checkRequiredDependencies(
+  cwd: string
+): Promise<DiagnosticResult[]> {
+  const results: DiagnosticResult[] = [];
+  const packageJsonPath = path.join(cwd, "package.json");
+
+  try {
+    const content = await fs.readFile(packageJsonPath, "utf-8");
+    const packageJson = JSON.parse(content);
+
+    const deps = {
+      ...packageJson.dependencies,
+      ...packageJson.devDependencies,
+    };
+
+    // Check for React 19
+    const requiredDeps = ["react", "react-dom"];
+    const missingDeps = requiredDeps.filter((dep) => !deps[dep]);
+
+    if (missingDeps.length === 0) {
+      const reactVersion = deps.react;
+      if (reactVersion?.includes("19")) {
+        results.push({
+          check: "required dependencies",
+          status: "pass",
+          message: `All required dependencies installed (React ${reactVersion})`,
+        });
+      } else {
+        results.push({
+          check: "React version",
+          status: "warn",
+          message: `React ${reactVersion} detected, React 19 recommended`,
+          suggestion: "Update to React 19: 'pnpm add react@^19.2.0 react-dom@^19.2.0'",
+        });
+      }
+    } else {
+      results.push({
+        check: "required dependencies",
+        status: "fail",
+        message: `Missing dependencies: ${missingDeps.join(", ")}`,
+        suggestion: `Run 'pnpm add ${missingDeps.join(" ")}'`,
+      });
+    }
+  } catch {
+    // package.json check handled elsewhere
+  }
+
+  return results;
+}
+
+/**
+ * Check for outdated packages
+ */
+export async function checkOutdatedPackages(
+  cwd: string
+): Promise<DiagnosticResult[]> {
+  const results: DiagnosticResult[] = [];
+  const packageJsonPath = path.join(cwd, "package.json");
+
+  try {
+    const content = await fs.readFile(packageJsonPath, "utf-8");
+    const packageJson = JSON.parse(content);
+
+    // Check for common outdated patterns
+    const deps = { ...packageJson.dependencies, ...packageJson.devDependencies };
+    const outdated: string[] = [];
+
+    // Check for specific packages that should be updated
+    if (deps.react && !deps.react.includes("19")) {
+      outdated.push("react");
+    }
+    if (deps["react-dom"] && !deps["react-dom"].includes("19")) {
+      outdated.push("react-dom");
+    }
+
+    if (outdated.length > 0) {
+      results.push({
+        check: "package versions",
+        status: "warn",
+        message: `Some packages may be outdated: ${outdated.join(", ")}`,
+        suggestion: "Run 'pnpm outdated' to check for updates",
+      });
+    } else {
+      results.push({
+        check: "package versions",
+        status: "pass",
+        message: "Package versions appear up to date",
+      });
+    }
+  } catch {
+    // package.json check handled elsewhere
+  }
+
+  return results;
+}
+

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

@@ -0,0 +1,156 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import type { DiagnosticResult } from "../types.js";
+
+/**
+ * Check .gitignore is properly configured
+ */
+export async function checkGitignore(cwd: string): Promise<DiagnosticResult[]> {
+  const results: DiagnosticResult[] = [];
+  const gitignorePath = path.join(cwd, ".gitignore");
+
+  try {
+    const content = await fs.readFile(gitignorePath, "utf-8");
+
+    const requiredPatterns = ["node_modules", ".env"];
+    const missingPatterns = requiredPatterns.filter(
+      (pattern) => !content.includes(pattern)
+    );
+
+    if (missingPatterns.length === 0) {
+      results.push({
+        check: ".gitignore configuration",
+        status: "pass",
+        message: ".gitignore properly configured",
+      });
+    } else {
+      results.push({
+        check: ".gitignore configuration",
+        status: "warn",
+        message: `.gitignore missing patterns: ${missingPatterns.join(", ")}`,
+        suggestion: `Add ${missingPatterns.join(", ")} to .gitignore`,
+      });
+    }
+  } catch {
+    results.push({
+      check: ".gitignore configuration",
+      status: "warn",
+      message: ".gitignore not found",
+      suggestion: "Create .gitignore to prevent committing sensitive files",
+    });
+  }
+
+  return results;
+}
+
+/**
+ * Check environment files are not committed
+ */
+export async function checkEnvFilesNotCommitted(
+  cwd: string
+): Promise<DiagnosticResult[]> {
+  const results: DiagnosticResult[] = [];
+  const envFiles = [".env", ".env.local", ".env.development.local"];
+
+  for (const envFile of envFiles) {
+    try {
+      const envPath = path.join(cwd, envFile);
+      await fs.access(envPath);
+
+      // Check if .gitignore mentions it
+      try {
+        const gitignorePath = path.join(cwd, ".gitignore");
+        const gitignoreContent = await fs.readFile(gitignorePath, "utf-8");
+        if (gitignoreContent.includes(envFile) || gitignoreContent.includes(".env*")) {
+          results.push({
+            check: `Environment file: ${envFile}`,
+            status: "pass",
+            message: `${envFile} exists and is gitignored`,
+          });
+        } else {
+          results.push({
+            check: `Environment file: ${envFile}`,
+            status: "warn",
+            message: `${envFile} exists but may not be gitignored`,
+            suggestion: `Add ${envFile} to .gitignore`,
+          });
+        }
+      } catch {
+        results.push({
+          check: `Environment file: ${envFile}`,
+          status: "warn",
+          message: `${envFile} exists but .gitignore not found`,
+          suggestion: "Create .gitignore and add .env* patterns",
+        });
+      }
+    } catch {
+      // File doesn't exist, which is fine
+    }
+  }
+
+  return results;
+}
+
+/**
+ * Check security best practices
+ */
+export async function checkSecurityPractices(
+  cwd: string
+): Promise<DiagnosticResult[]> {
+  const results: DiagnosticResult[] = [];
+
+  // Check for hardcoded secrets in code (basic check)
+  try {
+    const { readdir, readFile } = await import("fs/promises");
+    const srcPath = path.join(cwd, "src");
+
+    try {
+      const files = await readdir(srcPath, { recursive: true });
+      const suspiciousPatterns = [
+        /password\s*=\s*["'][^"']+["']/i,
+        /api[_-]?key\s*=\s*["'][^"']+["']/i,
+        /secret\s*=\s*["'][^"']+["']/i,
+      ];
+
+      let foundIssues = false;
+      for (const file of files) {
+        if (typeof file === "string" && (file.endsWith(".ts") || file.endsWith(".tsx") || file.endsWith(".js"))) {
+          const filePath = path.join(srcPath, file);
+          try {
+            const content = await readFile(filePath, "utf-8");
+            for (const pattern of suspiciousPatterns) {
+              if (pattern.test(content) && !content.includes("process.env")) {
+                foundIssues = true;
+                break;
+              }
+            }
+          } catch {
+            // Skip files we can't read
+          }
+        }
+      }
+
+      if (!foundIssues) {
+        results.push({
+          check: "Security: hardcoded secrets",
+          status: "pass",
+          message: "No obvious hardcoded secrets detected",
+        });
+      } else {
+        results.push({
+          check: "Security: hardcoded secrets",
+          status: "warn",
+          message: "Potential hardcoded secrets detected",
+          suggestion: "Use environment variables instead of hardcoding secrets",
+        });
+      }
+    } catch {
+      // src directory might not exist
+    }
+  } catch {
+    // Could not check
+  }
+
+  return results;
+}
+

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

@@ -0,0 +1,127 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import type { DiagnosticResult } from "../types.js";
+
+/**
+ * Check pages directory exists with content
+ */
+export async function checkPagesDirectory(
+  cwd: string
+): Promise<DiagnosticResult[]> {
+  const results: DiagnosticResult[] = [];
+  const pagesDirs = [
+    path.join(cwd, "src/pages"),
+    path.join(cwd, "src/app"),
+    path.join(cwd, "pages"),
+  ];
+
+  let pagesFound = false;
+  for (const pagesDir of pagesDirs) {
+    try {
+      await fs.access(pagesDir);
+      const files = await fs.readdir(pagesDir, { withFileTypes: true });
+      const hasFiles = files.some((file) => {
+        const name = file.name.toLowerCase();
+        return (
+          name.includes("page") ||
+          name.includes("index") ||
+          name.includes(".tsx") ||
+          name.includes(".jsx")
+        );
+      });
+
+      if (hasFiles) {
+        pagesFound = true;
+        results.push({
+          check: "pages directory",
+          status: "pass",
+          message: `Pages directory found at ${path.relative(cwd, pagesDir)} with content`,
+        });
+        break;
+      }
+    } catch {
+      // Continue to next directory
+    }
+  }
+
+  if (!pagesFound) {
+    results.push({
+      check: "pages directory",
+      status: "fail",
+      message: "No pages directory found or empty",
+      suggestion:
+        "Create src/pages/ or src/app/ directory and add at least one page",
+    });
+  }
+
+  return results;
+}
+
+/**
+ * Check components directory structure
+ */
+export async function checkComponentsDirectory(
+  cwd: string
+): Promise<DiagnosticResult[]> {
+  const results: DiagnosticResult[] = [];
+  const componentsDirs = [
+    path.join(cwd, "src/components"),
+    path.join(cwd, "components"),
+  ];
+
+  let componentsFound = false;
+  for (const compDir of componentsDirs) {
+    try {
+      await fs.access(compDir);
+      componentsFound = true;
+      results.push({
+        check: "components directory",
+        status: "pass",
+        message: `Components directory found at ${path.relative(cwd, compDir)}`,
+      });
+      break;
+    } catch {
+      // Continue
+    }
+  }
+
+  if (!componentsFound) {
+    results.push({
+      check: "components directory",
+      status: "warn",
+      message: "Components directory not found",
+      suggestion: "Consider creating src/components/ for reusable components",
+    });
+  }
+
+  return results;
+}
+
+/**
+ * Check public assets directory
+ */
+export async function checkPublicDirectory(
+  cwd: string
+): Promise<DiagnosticResult[]> {
+  const results: DiagnosticResult[] = [];
+  const publicDir = path.join(cwd, "public");
+
+  try {
+    await fs.access(publicDir);
+    results.push({
+      check: "public directory",
+      status: "pass",
+      message: "Public directory found",
+    });
+  } catch {
+    results.push({
+      check: "public directory",
+      status: "warn",
+      message: "Public directory not found",
+      suggestion: "Create public/ directory for static assets",
+    });
+  }
+
+  return results;
+}
+

package/dist/core/cli/commands/doctor/fixes/index.ts

@@ -0,0 +1,136 @@
+import pc from "@brillout/picocolors";
+import { execSync } from "child_process";
+import fs from "node:fs/promises";
+import path from "node:path";
+import type { DiagnosticResult } from "../types.js";
+
+/**
+ * Apply automatic fixes for diagnostic issues
+ */
+export async function applyFixes(results: DiagnosticResult[]): Promise<void> {
+	const fixableResults = results.filter(
+		(r) => r.fix && (r.status === "fail" || r.status === "warn"),
+	);
+
+	if (fixableResults.length === 0) {
+		console.log(pc.yellow("No auto-fixable issues found."));
+		return;
+	}
+
+	console.log(pc.cyan(`\nFound ${fixableResults.length} fixable issue(s):\n`));
+
+	for (const result of fixableResults) {
+		console.log(pc.yellow(`Fixing: ${result.check}`));
+		if (result.fix) {
+			try {
+				await result.fix();
+				console.log(pc.green(`  ✓ Fixed: ${result.check}\n`));
+			} catch (error) {
+				console.log(
+					pc.red(
+						`  ✗ Failed to fix: ${error instanceof Error ? error.message : String(error)}\n`,
+					),
+				);
+			}
+		}
+	}
+}
+
+/**
+ * Create missing reveal.config.ts
+ */
+export async function fixMissingRevealConfig(cwd: string): Promise<void> {
+	const configPath = path.join(cwd, "reveal.config.ts");
+	const configContent = `import { defineConfig } from "@revealui/core/config";
+import react from "@revealui/core/plugins/react";
+import vercel from "@revealui/core/plugins/vercel";
+
+export default defineConfig({
+  plugins: [
+    react(),
+    vercel(),
+  ],
+  vike: {
+    prerender: true,
+  },
+});
+`;
+
+	await fs.writeFile(configPath, configContent, "utf-8");
+}
+
+/**
+ * Add missing dependencies
+ */
+export async function fixMissingDependencies(
+	cwd: string,
+	dependencies: string[],
+): Promise<void> {
+	if (dependencies.length === 0) return;
+
+	const depsString = dependencies.join(" ");
+	execSync(`pnpm add ${depsString}`, {
+		cwd,
+		stdio: "inherit",
+	});
+}
+
+/**
+ * Create missing directories
+ */
+export async function fixMissingDirectories(
+	cwd: string,
+	dirs: string[],
+): Promise<void> {
+	for (const dir of dirs) {
+		await fs.mkdir(path.join(cwd, dir), { recursive: true });
+	}
+}
+
+/**
+ * Add patterns to .gitignore
+ */
+export async function fixGitignore(
+	cwd: string,
+	patterns: string[],
+): Promise<void> {
+	const gitignorePath = path.join(cwd, ".gitignore");
+	let content = "";
+
+	try {
+		content = await fs.readFile(gitignorePath, "utf-8");
+	} catch {
+		// .gitignore doesn't exist, we'll create it
+	}
+
+	const lines = content.split("\n").filter((line) => line.trim());
+	const newPatterns = patterns.filter((pattern) => !content.includes(pattern));
+
+	if (newPatterns.length > 0) {
+		const updatedContent = [...lines, ...newPatterns].join("\n") + "\n";
+		await fs.writeFile(gitignorePath, updatedContent, "utf-8");
+	}
+}
+
+/**
+ * Create .env.template
+ */
+export async function fixMissingEnvTemplate(cwd: string): Promise<void> {
+	const envTemplatePath = path.join(cwd, ".env.template");
+	const templateContent = `# PayloadCMS Configuration
+PAYLOAD_SECRET=your-secret-key-here
+PAYLOAD_PUBLIC_SERVER_URL=http://localhost:3000
+NEXT_PUBLIC_SERVER_URL=http://localhost:3000
+
+# Database (optional - uses SQLite by default)
+POSTGRES_URL=
+
+# Storage (optional - required for media uploads)
+BLOB_READ_WRITE_TOKEN=
+
+# Generate a secure secret with:
+# node -e "console.log(require('crypto').randomBytes(32).toString('hex'))"
+`;
+
+	await fs.writeFile(envTemplatePath, templateContent, "utf-8");
+}

package/dist/core/cli/commands/doctor/index.ts

@@ -0,0 +1,47 @@
+import * as configChecks from "./checks/config.js";
+import * as dependencyChecks from "./checks/dependencies.js";
+import * as structureChecks from "./checks/structure.js";
+import * as buildChecks from "./checks/build.js";
+import * as practiceChecks from "./checks/practices.js";
+import type { DiagnosticResult } from "./types.js";
+import { printDiagnostics } from "./print.js";
+
+/**
+ * Runs comprehensive health diagnostics on the RevealUI project
+ */
+export async function runDiagnostics(): Promise<DiagnosticResult[]> {
+  const cwd = process.cwd();
+  const results: DiagnosticResult[] = [];
+
+  // Configuration checks
+  results.push(...(await configChecks.checkRevealConfig(cwd)));
+  results.push(...(await configChecks.checkTypeScriptConfig(cwd)));
+  results.push(...(await configChecks.checkEnvironmentVariables(cwd)));
+
+  // Dependency checks
+  results.push(...(await dependencyChecks.checkRevealPackage(cwd)));
+  results.push(...(await dependencyChecks.checkRequiredDependencies(cwd)));
+  results.push(...(await dependencyChecks.checkOutdatedPackages(cwd)));
+
+  // Structure checks
+  results.push(...(await structureChecks.checkPagesDirectory(cwd)));
+  results.push(...(await structureChecks.checkComponentsDirectory(cwd)));
+  results.push(...(await structureChecks.checkPublicDirectory(cwd)));
+
+  // Build checks
+  results.push(...(await buildChecks.checkTypeScriptCompilation(cwd)));
+  results.push(...(await buildChecks.checkBuildProcess(cwd)));
+
+  // Best practices checks
+  results.push(...(await practiceChecks.checkGitignore(cwd)));
+  results.push(...(await practiceChecks.checkEnvFilesNotCommitted(cwd)));
+  results.push(...(await practiceChecks.checkSecurityPractices(cwd)));
+
+  return results;
+}
+
+/**
+ * Print diagnostic results to console
+ */
+export { printDiagnostics };
+

package/dist/core/cli/commands/doctor/print.ts

@@ -0,0 +1,44 @@
+import pc from "@brillout/picocolors";
+import type { DiagnosticResult } from "./types.js";
+
+/**
+ * Prints diagnostic results to the console
+ */
+export function printDiagnostics(results: DiagnosticResult[]): void {
+  console.log(pc.cyan("\nRevealUI Project Diagnostics\n"));
+  console.log(pc.gray("─".repeat(50) + "\n"));
+
+  for (const result of results) {
+    const icon =
+      result.status === "pass"
+        ? pc.green("✓")
+        : result.status === "warn"
+          ? pc.yellow("⚠")
+          : pc.red("✗");
+
+    console.log(`${icon} ${pc.bold(result.check)}`);
+    console.log(`  ${result.message}`);
+    if (result.suggestion) {
+      console.log(pc.gray(`  → ${result.suggestion}`));
+    }
+    console.log();
+  }
+
+  const passCount = results.filter((r) => r.status === "pass").length;
+  const warnCount = results.filter((r) => r.status === "warn").length;
+  const failCount = results.filter((r) => r.status === "fail").length;
+
+  console.log(pc.gray("─".repeat(50)));
+  console.log(
+    `Summary: ${pc.green(`${passCount} passed`)}, ${pc.yellow(`${warnCount} warnings`)}, ${pc.red(`${failCount} failed`)}`
+  );
+  console.log();
+
+  if (failCount > 0) {
+    console.log(
+      pc.yellow("💡 Tip: Run 'reveal fix' to automatically fix some issues")
+    );
+    console.log();
+  }
+}
+

package/dist/core/cli/commands/doctor/types.ts

@@ -0,0 +1,16 @@
+/**
+ * Diagnostic result from health check
+ */
+export interface DiagnosticResult {
+  /** Name of the diagnostic check */
+  check: string;
+  /** Status of the check */
+  status: "pass" | "warn" | "fail";
+  /** Diagnostic message */
+  message: string;
+  /** Optional suggestion for fixing issues */
+  suggestion?: string;
+  /** Optional fix action that can be applied */
+  fix?: () => Promise<void> | void;
+}
+