@revealui/core 0.0.1-pre.0 → 0.0.1-pre.2

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

@@ -1,144 +0,0 @@
-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

@@ -1,156 +0,0 @@
-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

@@ -1,127 +0,0 @@
-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

@@ -1,136 +0,0 @@
-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

@@ -1,47 +0,0 @@
-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

@@ -1,44 +0,0 @@
-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

@@ -1,16 +0,0 @@
-/**
- * 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;
-}
-