@revealui/cli 0.0.1-pre.1

package/dist/commands/doctor/checks/dependencies.js

@@ -0,0 +1,126 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+/**
+ * Check package.json exists and has reveal package
+ */
+export async function checkRevealPackage(cwd) {
+    const results = [];
+    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) {
+    const results = [];
+    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) {
+    const results = [];
+    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 = [];
+        // 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/commands/doctor/checks/practices.d.ts

@@ -0,0 +1,14 @@
+import type { DiagnosticResult } from "../types.js";
+/**
+ * Check .gitignore is properly configured
+ */
+export declare function checkGitignore(cwd: string): Promise<DiagnosticResult[]>;
+/**
+ * Check environment files are not committed
+ */
+export declare function checkEnvFilesNotCommitted(cwd: string): Promise<DiagnosticResult[]>;
+/**
+ * Check security best practices
+ */
+export declare function checkSecurityPractices(cwd: string): Promise<DiagnosticResult[]>;
+//# sourceMappingURL=practices.d.ts.map

package/dist/commands/doctor/checks/practices.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"practices.d.ts","sourceRoot":"","sources":["../../../../src/commands/doctor/checks/practices.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAEpD;;GAEG;AACH,wBAAsB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,EAAE,CAAC,CAoC7E;AAED;;GAEG;AACH,wBAAsB,yBAAyB,CAC7C,GAAG,EAAE,MAAM,GACV,OAAO,CAAC,gBAAgB,EAAE,CAAC,CAyC7B;AAED;;GAEG;AACH,wBAAsB,sBAAsB,CAC1C,GAAG,EAAE,MAAM,GACV,OAAO,CAAC,gBAAgB,EAAE,CAAC,CAwD7B"}

package/dist/commands/doctor/checks/practices.js

@@ -0,0 +1,142 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+/**
+ * Check .gitignore is properly configured
+ */
+export async function checkGitignore(cwd) {
+    const results = [];
+    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) {
+    const results = [];
+    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) {
+    const results = [];
+    // 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/commands/doctor/checks/structure.d.ts

@@ -0,0 +1,14 @@
+import type { DiagnosticResult } from "../types.js";
+/**
+ * Check pages directory exists with content
+ */
+export declare function checkPagesDirectory(cwd: string): Promise<DiagnosticResult[]>;
+/**
+ * Check components directory structure
+ */
+export declare function checkComponentsDirectory(cwd: string): Promise<DiagnosticResult[]>;
+/**
+ * Check public assets directory
+ */
+export declare function checkPublicDirectory(cwd: string): Promise<DiagnosticResult[]>;
+//# sourceMappingURL=structure.d.ts.map

package/dist/commands/doctor/checks/structure.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"structure.d.ts","sourceRoot":"","sources":["../../../../src/commands/doctor/checks/structure.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAEpD;;GAEG;AACH,wBAAsB,mBAAmB,CACvC,GAAG,EAAE,MAAM,GACV,OAAO,CAAC,gBAAgB,EAAE,CAAC,CAgD7B;AAED;;GAEG;AACH,wBAAsB,wBAAwB,CAC5C,GAAG,EAAE,MAAM,GACV,OAAO,CAAC,gBAAgB,EAAE,CAAC,CAiC7B;AAED;;GAEG;AACH,wBAAsB,oBAAoB,CACxC,GAAG,EAAE,MAAM,GACV,OAAO,CAAC,gBAAgB,EAAE,CAAC,CAqB7B"}

package/dist/commands/doctor/checks/structure.js

@@ -0,0 +1,107 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+/**
+ * Check pages directory exists with content
+ */
+export async function checkPagesDirectory(cwd) {
+    const results = [];
+    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) {
+    const results = [];
+    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) {
+    const results = [];
+    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/commands/doctor/fixes/index.d.ts

@@ -0,0 +1,26 @@
+import type { DiagnosticResult } from "../types.js";
+/**
+ * Apply automatic fixes for diagnostic issues
+ */
+export declare function applyFixes(results: DiagnosticResult[]): Promise<void>;
+/**
+ * Create missing reveal.config.ts
+ */
+export declare function fixMissingRevealConfig(cwd: string): Promise<void>;
+/**
+ * Add missing dependencies
+ */
+export declare function fixMissingDependencies(cwd: string, dependencies: string[]): Promise<void>;
+/**
+ * Create missing directories
+ */
+export declare function fixMissingDirectories(cwd: string, dirs: string[]): Promise<void>;
+/**
+ * Add patterns to .gitignore
+ */
+export declare function fixGitignore(cwd: string, patterns: string[]): Promise<void>;
+/**
+ * Create .env.template
+ */
+export declare function fixMissingEnvTemplate(cwd: string): Promise<void>;
+//# sourceMappingURL=index.d.ts.map

package/dist/commands/doctor/fixes/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/commands/doctor/fixes/index.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAEpD;;GAEG;AACH,wBAAsB,UAAU,CAAC,OAAO,EAAE,gBAAgB,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CA2B3E;AAED;;GAEG;AACH,wBAAsB,sBAAsB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAkBvE;AAED;;GAEG;AACH,wBAAsB,sBAAsB,CAC3C,GAAG,EAAE,MAAM,EACX,YAAY,EAAE,MAAM,EAAE,GACpB,OAAO,CAAC,IAAI,CAAC,CAQf;AAED;;GAEG;AACH,wBAAsB,qBAAqB,CAC1C,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,MAAM,EAAE,GACZ,OAAO,CAAC,IAAI,CAAC,CAIf;AAED;;GAEG;AACH,wBAAsB,YAAY,CACjC,GAAG,EAAE,MAAM,EACX,QAAQ,EAAE,MAAM,EAAE,GAChB,OAAO,CAAC,IAAI,CAAC,CAiBf;AAED;;GAEG;AACH,wBAAsB,qBAAqB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAkBtE"}

package/dist/commands/doctor/fixes/index.js

@@ -0,0 +1,108 @@
+import pc from "@brillout/picocolors";
+import { execSync } from "child_process";
+import fs from "node:fs/promises";
+import path from "node:path";
+/**
+ * Apply automatic fixes for diagnostic issues
+ */
+export async function applyFixes(results) {
+    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) {
+    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, dependencies) {
+    if (dependencies.length === 0)
+        return;
+    const depsString = dependencies.join(" ");
+    execSync(`pnpm add ${depsString}`, {
+        cwd,
+        stdio: "inherit",
+    });
+}
+/**
+ * Create missing directories
+ */
+export async function fixMissingDirectories(cwd, dirs) {
+    for (const dir of dirs) {
+        await fs.mkdir(path.join(cwd, dir), { recursive: true });
+    }
+}
+/**
+ * Add patterns to .gitignore
+ */
+export async function fixGitignore(cwd, patterns) {
+    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) {
+    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/commands/doctor/index.d.ts

@@ -0,0 +1,11 @@
+import type { DiagnosticResult } from "./types.js";
+import { printDiagnostics } from "./print.js";
+/**
+ * Runs comprehensive health diagnostics on the RevealUI project
+ */
+export declare function runDiagnostics(): Promise<DiagnosticResult[]>;
+/**
+ * Print diagnostic results to console
+ */
+export { printDiagnostics };
+//# sourceMappingURL=index.d.ts.map

package/dist/commands/doctor/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/commands/doctor/index.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AACnD,OAAO,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAE9C;;GAEG;AACH,wBAAsB,cAAc,IAAI,OAAO,CAAC,gBAAgB,EAAE,CAAC,CA6BlE;AAED;;GAEG;AACH,OAAO,EAAE,gBAAgB,EAAE,CAAC"}

package/dist/commands/doctor/index.js

@@ -0,0 +1,37 @@
+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 { printDiagnostics } from "./print.js";
+/**
+ * Runs comprehensive health diagnostics on the RevealUI project
+ */
+export async function runDiagnostics() {
+    const cwd = process.cwd();
+    const results = [];
+    // 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/commands/doctor/print.d.ts

@@ -0,0 +1,6 @@
+import type { DiagnosticResult } from "./types.js";
+/**
+ * Prints diagnostic results to the console
+ */
+export declare function printDiagnostics(results: DiagnosticResult[]): void;
+//# sourceMappingURL=print.d.ts.map

package/dist/commands/doctor/print.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"print.d.ts","sourceRoot":"","sources":["../../../src/commands/doctor/print.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAEnD;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,gBAAgB,EAAE,GAAG,IAAI,CAoClE"}

package/dist/commands/doctor/print.js

@@ -0,0 +1,31 @@
+import pc from "@brillout/picocolors";
+/**
+ * Prints diagnostic results to the console
+ */
+export function printDiagnostics(results) {
+    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/commands/doctor/types.d.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;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/commands/doctor/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/commands/doctor/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,mCAAmC;IACnC,KAAK,EAAE,MAAM,CAAC;IACd,0BAA0B;IAC1B,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAAC;IACjC,yBAAyB;IACzB,OAAO,EAAE,MAAM,CAAC;IAChB,4CAA4C;IAC5C,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,8CAA8C;IAC9C,GAAG,CAAC,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;CAClC"}

package/dist/commands/doctor/types.js

@@ -0,0 +1 @@
+export {};