stackkit-cli 0.4.4 → 0.4.5

package/README.md

@@ -5,6 +5,9 @@ Add authentication and database modules to existing projects.
 ## Usage
 
 ```bash
+# Check project health and compatibility
+npx stackkit-cli doctor
+
 # Add authentication
 npx stackkit-cli add auth
 
@@ -21,19 +24,40 @@ npx stackkit-cli list
 - **Shows compatible modules** for your project
 - **Installs dependencies** automatically
 - **Configures everything** - files, env vars, and setup
+- **Health checks** with `doctor` command
 
 ## Available Modules
 
 ### Authentication
 
 - Better Auth (Next.js, Express, React)
-- Clerk (Next.js, Express, React)
 
 ### Database
 
 - Prisma with PostgreSQL or MongoDB (Next.js, Express)
 - Mongoose with MongoDB (Next.js, Express)
 
+## Commands
+
+### `doctor`
+
+Check your project's health and compatibility with StackKit modules.
+
+```bash
+stackkit doctor                    # Basic health check
+stackkit doctor --verbose         # Detailed output
+stackkit doctor --json            # Machine-readable JSON output
+stackkit doctor --strict          # Treat warnings as errors
+```
+
+The doctor command:
+- Detects your project type and framework
+- Checks Node.js version compatibility
+- Identifies installed StackKit modules
+- Validates environment variables
+- Checks for configuration conflicts
+- Provides actionable next steps
+
 ## Documentation
 
-Full documentation: [stackkit.dev](https://stackkit.dev) | [GitHub](https://github.com/tariqul420/stackkit)
+Full documentation: [stackkit.dev](https://stackkit.dev) | [GitHub](https://github.com/tariqul420/stackkit/issues)

package/bin/stackkit.js

@@ -8,4 +8,4 @@ try {
 } catch {
   // eslint-disable-next-line
   require("../dist/index.js");
-}
+}

package/dist/commands/add.js

@@ -50,38 +50,19 @@ async function addCommand(module, options) {
         // Merge dependencies based on provider
         const mergedDeps = {};
         const mergedDevDeps = {};
-        if (typeof moduleMetadata.dependencies === "object" &&
-            !("common" in moduleMetadata.dependencies)) {
-            // Already flat
-            Object.assign(mergedDeps, moduleMetadata.dependencies);
+        // Add shared dependencies
+        if (moduleMetadata.frameworkConfigs?.shared?.dependencies) {
+            Object.assign(mergedDeps, moduleMetadata.frameworkConfigs.shared.dependencies);
         }
-        else if (typeof moduleMetadata.dependencies === "object" &&
-            "common" in moduleMetadata.dependencies) {
-            Object.assign(mergedDeps, moduleMetadata.dependencies.common);
-            if (selectedProvider &&
-                typeof moduleMetadata.dependencies === "object" &&
-                "providers" in moduleMetadata.dependencies &&
-                typeof moduleMetadata.dependencies.providers === "object" &&
-                selectedProvider in moduleMetadata.dependencies.providers) {
-                Object.assign(mergedDeps, moduleMetadata.dependencies.providers[selectedProvider]);
-            }
+        if (moduleMetadata.frameworkConfigs?.shared?.devDependencies) {
+            Object.assign(mergedDevDeps, moduleMetadata.frameworkConfigs.shared.devDependencies);
         }
-        if (moduleMetadata.devDependencies) {
-            if (typeof moduleMetadata.devDependencies === "object" &&
-                !("common" in moduleMetadata.devDependencies)) {
-                Object.assign(mergedDevDeps, moduleMetadata.devDependencies);
-            }
-            else if (typeof moduleMetadata.devDependencies === "object" &&
-                "common" in moduleMetadata.devDependencies) {
-                Object.assign(mergedDevDeps, moduleMetadata.devDependencies.common);
-                if (selectedProvider &&
-                    typeof moduleMetadata.devDependencies === "object" &&
-                    "providers" in moduleMetadata.devDependencies &&
-                    typeof moduleMetadata.devDependencies.providers === "object" &&
-                    selectedProvider in moduleMetadata.devDependencies.providers) {
-                    Object.assign(mergedDevDeps, moduleMetadata.devDependencies.providers[selectedProvider]);
-                }
-            }
+        // Add provider specific dependencies
+        if (selectedProvider && moduleMetadata.databaseAdapters?.providers?.[selectedProvider]?.dependencies) {
+            Object.assign(mergedDeps, moduleMetadata.databaseAdapters.providers[selectedProvider].dependencies);
+        }
+        if (selectedProvider && moduleMetadata.databaseAdapters?.providers?.[selectedProvider]?.devDependencies) {
+            Object.assign(mergedDevDeps, moduleMetadata.databaseAdapters.providers[selectedProvider].devDependencies);
         }
         // Update metadata with merged deps
         moduleMetadata.dependencies = mergedDeps;
@@ -149,8 +130,8 @@ async function addCommand(module, options) {
             }
         }
         // Add dependencies
-        if (Object.keys(moduleMetadata.dependencies).length > 0 && options.install !== false) {
-            const deps = Object.entries(moduleMetadata.dependencies).map(([name, version]) => `${name}@${version}`);
+        if (Object.keys(mergedDeps).length > 0 && options.install !== false) {
+            const deps = Object.entries(mergedDeps).map(([name, version]) => `${name}@${version}`);
             if (!options.dryRun) {
                 await (0, package_manager_1.addDependencies)(projectRoot, projectInfo.packageManager, deps, false);
             }
@@ -159,10 +140,8 @@ async function addCommand(module, options) {
             }
         }
         // Add dev dependencies
-        if (moduleMetadata.devDependencies &&
-            Object.keys(moduleMetadata.devDependencies).length > 0 &&
-            options.install !== false) {
-            const devDeps = Object.entries(moduleMetadata.devDependencies).map(([name, version]) => `${name}@${version}`);
+        if (Object.keys(mergedDevDeps).length > 0 && options.install !== false) {
+            const devDeps = Object.entries(mergedDevDeps).map(([name, version]) => `${name}@${version}`);
             if (!options.dryRun) {
                 await (0, package_manager_1.addDependencies)(projectRoot, projectInfo.packageManager, devDeps, true);
             }
@@ -171,7 +150,7 @@ async function addCommand(module, options) {
             }
         }
         // Add environment variables
-        if (moduleMetadata.envVars.length > 0) {
+        if (moduleMetadata.envVars && moduleMetadata.envVars.length > 0) {
             // Replace variables in envVars
             const processedEnvVars = moduleMetadata.envVars.map((envVar) => ({
                 ...envVar,
@@ -188,7 +167,7 @@ async function addCommand(module, options) {
         logger_1.logger.success(`Added ${chalk_1.default.bold(moduleMetadata.displayName)}`);
         logger_1.logger.newLine();
         // Print next steps
-        if (moduleMetadata.envVars.some((v) => v.required)) {
+        if (moduleMetadata.envVars && moduleMetadata.envVars.some((v) => v.required)) {
             logger_1.logger.log("Next: Fill in environment variables in .env");
         }
         logger_1.logger.newLine();
@@ -235,8 +214,10 @@ async function loadModuleMetadata(modulesDir, moduleName, provider) {
     }
     return null;
 }
-// (removed duplicate import)
 async function applyModulePatches(projectRoot, projectInfo, moduleMetadata, modulesDir, moduleName, options) {
+    if (!moduleMetadata.patches || !Array.isArray(moduleMetadata.patches)) {
+        return;
+    }
     // Find the module path
     const moduleBasePath = await findModulePath(modulesDir, moduleName, options.provider);
     if (!moduleBasePath) {

package/dist/commands/doctor.d.ts

@@ -0,0 +1,11 @@
+interface DoctorOptions {
+    json?: boolean;
+    verbose?: boolean;
+    strict?: boolean;
+}
+/**
+ * Main doctor command function that performs health checks on a StackKit project
+ * @param options Command line options
+ */
+export declare function doctorCommand(options: DoctorOptions): Promise<void>;
+export {};

package/dist/commands/doctor.js

@@ -0,0 +1,483 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.doctorCommand = doctorCommand;
+const chalk_1 = __importDefault(require("chalk"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const logger_1 = require("../utils/logger");
+// Constants for consistent messaging
+const MESSAGES = {
+    NO_PACKAGE_JSON: "No package.json found in current directory or any parent directory.",
+    UNSUPPORTED_PROJECT: "Unsupported project type. Only Next.js, Express, and React projects are supported.",
+    NODE_TOO_OLD: (version) => `Node.js version ${version} is not supported. Minimum required: Node 18.`,
+    NODE_WARNING: (version) => `Node.js version ${version} is supported but Node 20+ is recommended.`,
+    NODE_SUCCESS: (version) => `Node.js version ${version} is supported.`,
+    ENV_EXAMPLE_MISSING: ".env.example file missing (recommended for documentation)",
+    ENV_EXAMPLE_FOUND: ".env.example file found",
+    ENV_MISSING: "No .env or .env.local file found",
+    ENV_FOUND: ".env/.env.local file found",
+    PRISMA_SCHEMA_MISSING: "Prisma schema missing (required for Prisma)",
+    PRISMA_SCHEMA_FOUND: "Prisma schema found",
+    AUTH_ROUTES_MISSING: "Auth routes not found (may need configuration)",
+    AUTH_ROUTES_FOUND: "Auth routes configured",
+    ENV_VARS_MISSING: (vars) => `Missing: ${vars.join(", ")}`,
+    ENV_VARS_PRESENT: (vars) => `Present: ${vars.join(", ")}`,
+};
+/**
+ * Main doctor command function that performs health checks on a StackKit project
+ * @param options Command line options
+ */
+async function doctorCommand(options) {
+    try {
+        const report = await runDoctorChecks();
+        if (options.json) {
+            process.stdout.write(JSON.stringify(report, null, 2) + "\n");
+            return;
+        }
+        printDoctorReport(report, options.verbose || false);
+        // Exit with proper codes
+        const hasErrors = report.summary.errors > 0;
+        const hasWarnings = report.summary.warnings > 0;
+        const strictMode = options.strict || false;
+        if (hasErrors || (strictMode && hasWarnings)) {
+            process.exit(1);
+        }
+        else {
+            process.exit(0);
+        }
+    }
+    catch (error) {
+        logger_1.logger.error(`Doctor check failed: ${error instanceof Error ? error.message : String(error)}`);
+        process.exit(1);
+    }
+}
+/**
+ * Runs all doctor checks and generates a comprehensive health report
+ * @returns Promise resolving to a DoctorReport
+ */
+async function runDoctorChecks() {
+    const checks = [];
+    // Find project root
+    const projectRoot = await findProjectRoot();
+    checks.push({
+        status: "success",
+        message: `Found project root: ${projectRoot}`,
+    });
+    // Read package.json
+    const packageJson = await readPackageJson(projectRoot);
+    // Detect package manager
+    const packageManager = await detectPackageManager(projectRoot);
+    // Detect project type
+    const projectType = detectProjectType(packageJson);
+    if (projectType === "unknown") {
+        checks.push({
+            status: "error",
+            message: MESSAGES.UNSUPPORTED_PROJECT,
+        });
+    }
+    else {
+        checks.push({
+            status: "success",
+            message: `Detected project type: ${projectType}`,
+        });
+    }
+    // Check Node version
+    const nodeVersionCheck = checkNodeVersion();
+    checks.push(nodeVersionCheck);
+    // Detect installed modules
+    const authModules = detectAuthModules(packageJson);
+    const databaseModules = detectDatabaseModules(packageJson);
+    // Check key files
+    const filesCheck = await checkKeyFiles(projectRoot, projectType, authModules, databaseModules);
+    checks.push(...filesCheck);
+    // Check env files
+    const envCheck = await checkEnvFiles(projectRoot, authModules, databaseModules);
+    checks.push(...envCheck.checks);
+    // Check conflicts
+    const conflicts = checkConflicts(authModules, databaseModules);
+    conflicts.forEach(conflict => {
+        checks.push({
+            status: "warning",
+            message: conflict,
+        });
+    });
+    // Build report
+    const report = {
+        project: {
+            type: projectType,
+            root: projectRoot,
+            packageManager,
+        },
+        runtime: {
+            nodeVersion: process.version,
+            nodeVersionStatus: nodeVersionCheck.status,
+        },
+        modules: {
+            auth: authModules,
+            database: databaseModules,
+        },
+        files: {
+            envExample: await fs_extra_1.default.pathExists(path_1.default.join(projectRoot, ".env.example")),
+            env: await fs_extra_1.default.pathExists(path_1.default.join(projectRoot, ".env")) || await fs_extra_1.default.pathExists(path_1.default.join(projectRoot, ".env.local")),
+            prismaSchema: databaseModules.includes("prisma") ? await fs_extra_1.default.pathExists(path_1.default.join(projectRoot, "prisma", "schema.prisma")) : undefined,
+            authRoutes: authModules.length > 0 ? await checkAuthRoutesExist(projectRoot, projectType) : undefined,
+        },
+        env: envCheck.envStatus,
+        conflicts,
+        checks,
+        summary: {
+            errors: checks.filter(c => c.status === "error").length,
+            warnings: checks.filter(c => c.status === "warning").length,
+            suggestions: generateSuggestions(),
+        },
+    };
+    return report;
+}
+/**
+ * Finds the project root by walking up directories until package.json is found
+ * @returns Promise resolving to the absolute path of the project root
+ * @throws Error if no package.json is found
+ */
+async function findProjectRoot() {
+    let currentDir = process.cwd();
+    while (currentDir !== path_1.default.dirname(currentDir)) {
+        const packageJsonPath = path_1.default.join(currentDir, "package.json");
+        if (await fs_extra_1.default.pathExists(packageJsonPath)) {
+            return currentDir;
+        }
+        currentDir = path_1.default.dirname(currentDir);
+    }
+    throw new Error(MESSAGES.NO_PACKAGE_JSON);
+}
+/**
+ * Reads and parses package.json from the project root
+ * @param projectRoot Absolute path to the project root
+ * @returns Promise resolving to the parsed package.json object
+ */
+async function readPackageJson(projectRoot) {
+    const packageJsonPath = path_1.default.join(projectRoot, "package.json");
+    return await fs_extra_1.default.readJSON(packageJsonPath);
+}
+async function detectPackageManager(projectRoot) {
+    const checks = [
+        { file: "pnpm-lock.yaml", manager: "pnpm" },
+        { file: "yarn.lock", manager: "yarn" },
+        { file: "package-lock.json", manager: "npm" },
+    ];
+    for (const check of checks) {
+        if (await fs_extra_1.default.pathExists(path_1.default.join(projectRoot, check.file))) {
+            return check.manager;
+        }
+    }
+    return "npm";
+}
+function detectProjectType(packageJson) {
+    const deps = { ...packageJson.dependencies, ...packageJson.devDependencies };
+    if (deps.next) {
+        return "nextjs";
+    }
+    else if (deps.express) {
+        return "express";
+    }
+    else if (deps.vite && deps.react) {
+        return "react-vite";
+    }
+    else if (deps.react) {
+        return "react";
+    }
+    return "unknown";
+}
+function checkNodeVersion() {
+    const version = process.version;
+    const majorVersion = parseInt(version.slice(1).split(".")[0]);
+    if (majorVersion < 18) {
+        return {
+            status: "error",
+            message: MESSAGES.NODE_TOO_OLD(version),
+        };
+    }
+    else if (majorVersion < 20) {
+        return {
+            status: "warning",
+            message: MESSAGES.NODE_WARNING(version),
+        };
+    }
+    else {
+        return {
+            status: "success",
+            message: MESSAGES.NODE_SUCCESS(version),
+        };
+    }
+}
+function detectAuthModules(packageJson) {
+    const deps = { ...packageJson.dependencies, ...packageJson.devDependencies };
+    const modules = [];
+    if (deps["better-auth"]) {
+        modules.push("better-auth");
+    }
+    if (deps["next-auth"]) {
+        modules.push("authjs");
+    }
+    return modules;
+}
+function detectDatabaseModules(packageJson) {
+    const deps = { ...packageJson.dependencies, ...packageJson.devDependencies };
+    const modules = [];
+    if (deps["@prisma/client"] || deps["prisma"]) {
+        modules.push("prisma");
+    }
+    if (deps["mongoose"]) {
+        modules.push("mongoose");
+    }
+    return modules;
+}
+async function checkKeyFiles(projectRoot, projectType, authModules, databaseModules) {
+    const checks = [];
+    // Check .env.example
+    const envExampleExists = await fs_extra_1.default.pathExists(path_1.default.join(projectRoot, ".env.example"));
+    checks.push({
+        status: envExampleExists ? "success" : "warning",
+        message: envExampleExists ? ".env.example file found" : ".env.example file missing (recommended for documentation)",
+    });
+    // Check Prisma schema
+    if (databaseModules.includes("prisma")) {
+        const schemaExists = await fs_extra_1.default.pathExists(path_1.default.join(projectRoot, "prisma", "schema.prisma"));
+        checks.push({
+            status: schemaExists ? "success" : "error",
+            message: schemaExists ? "Prisma schema found" : "Prisma schema missing (required for Prisma)",
+        });
+    }
+    // Check auth routes
+    if (authModules.length > 0 && projectType === "nextjs") {
+        const authRoutesExist = await checkAuthRoutesExist(projectRoot, projectType);
+        checks.push({
+            status: authRoutesExist ? "success" : "warning",
+            message: authRoutesExist ? "Auth routes configured" : "Auth routes not found (may need configuration)",
+        });
+    }
+    return checks;
+}
+async function checkAuthRoutesExist(projectRoot, projectType) {
+    if (projectType !== "nextjs")
+        return true; // Skip for non-Next.js
+    const possiblePaths = [
+        "app/api/auth/[...nextauth]/route.ts",
+        "app/api/auth/[...nextauth]/route.js",
+        "src/app/api/auth/[...nextauth]/route.ts",
+        "src/app/api/auth/[...nextauth]/route.js",
+        "pages/api/auth/[...nextauth].ts",
+        "pages/api/auth/[...nextauth].js",
+        "src/pages/api/auth/[...nextauth].ts",
+        "src/pages/api/auth/[...nextauth].js",
+    ];
+    for (const routePath of possiblePaths) {
+        if (await fs_extra_1.default.pathExists(path_1.default.join(projectRoot, routePath))) {
+            return true;
+        }
+    }
+    return false;
+}
+async function checkEnvFiles(projectRoot, authModules, databaseModules) {
+    const checks = [];
+    const requiredKeys = [];
+    const missing = [];
+    const present = [];
+    // Determine required env keys
+    if (databaseModules.includes("prisma")) {
+        requiredKeys.push("DATABASE_URL");
+    }
+    if (authModules.includes("authjs")) {
+        requiredKeys.push("NEXTAUTH_SECRET", "NEXTAUTH_URL");
+    }
+    if (authModules.includes("better-auth")) {
+        requiredKeys.push("BETTER_AUTH_SECRET", "BETTER_AUTH_URL");
+    }
+    // Check env files
+    const envPaths = [".env", ".env.local"];
+    let envContent = "";
+    for (const envPath of envPaths) {
+        const fullPath = path_1.default.join(projectRoot, envPath);
+        if (await fs_extra_1.default.pathExists(fullPath)) {
+            envContent = await fs_extra_1.default.readFile(fullPath, "utf-8");
+            break;
+        }
+    }
+    if (!envContent) {
+        checks.push({
+            status: "warning",
+            message: "No .env or .env.local file found",
+        });
+        return { checks, envStatus: { missing: requiredKeys, present: [] } };
+    }
+    // Parse env content
+    const envLines = envContent.split("\n").map(line => line.trim()).filter(line => line && !line.startsWith("#"));
+    const envVars = new Set(envLines.map(line => line.split("=")[0]));
+    for (const key of requiredKeys) {
+        if (envVars.has(key)) {
+            present.push(key);
+        }
+        else {
+            missing.push(key);
+        }
+    }
+    if (missing.length > 0) {
+        checks.push({
+            status: "error",
+            message: `Missing required environment variables: ${missing.join(", ")}`,
+        });
+    }
+    else if (requiredKeys.length > 0) {
+        checks.push({
+            status: "success",
+            message: "All required environment variables are present",
+        });
+    }
+    return { checks, envStatus: { missing, present } };
+}
+function checkConflicts(authModules, databaseModules) {
+    const conflicts = [];
+    if (authModules.length > 1) {
+        conflicts.push(`Multiple auth providers detected: ${authModules.join(", ")}. Consider using only one.`);
+    }
+    if (databaseModules.length > 1) {
+        conflicts.push(`Multiple database providers detected: ${databaseModules.join(", ")}. Consider using only one.`);
+    }
+    return conflicts;
+}
+function generateSuggestions() {
+    const suggestions = [];
+    // Always show available commands
+    suggestions.push("stackkit add auth     - Add authentication module");
+    suggestions.push("stackkit add db       - Add database module");
+    suggestions.push("stackkit list         - View available modules");
+    return suggestions;
+}
+/**
+ * Prints the doctor report to the console with appropriate formatting
+ * @param report The doctor report to print
+ * @param verbose Whether to show detailed check information
+ */
+function printDoctorReport(report, verbose) {
+    logger_1.logger.header("🔍 StackKit Doctor Report");
+    logger_1.logger.newLine();
+    // Project info
+    logger_1.logger.log(chalk_1.default.bold("Project"));
+    logger_1.logger.log(`  Type: ${report.project.type}`);
+    logger_1.logger.log(`  Root: ${report.project.root}`);
+    logger_1.logger.log(`  Package Manager: ${report.project.packageManager}`);
+    logger_1.logger.newLine();
+    // Runtime
+    logger_1.logger.log(chalk_1.default.bold("Runtime"));
+    if (report.runtime.nodeVersionStatus === "success") {
+        logger_1.logger.success(`Node.js: ${report.runtime.nodeVersion}`);
+    }
+    else if (report.runtime.nodeVersionStatus === "warning") {
+        logger_1.logger.warn(`Node.js: ${report.runtime.nodeVersion}`);
+    }
+    else {
+        logger_1.logger.error(`Node.js: ${report.runtime.nodeVersion}`);
+    }
+    logger_1.logger.newLine();
+    // Modules
+    logger_1.logger.log(chalk_1.default.bold("Modules"));
+    if (report.modules.auth.length > 0) {
+        logger_1.logger.log(`  Auth: ${report.modules.auth.join(", ")}`);
+    }
+    else {
+        logger_1.logger.info("Auth: None");
+    }
+    if (report.modules.database.length > 0) {
+        logger_1.logger.log(`  Database: ${report.modules.database.join(", ")}`);
+    }
+    else {
+        logger_1.logger.info("Database: None");
+    }
+    logger_1.logger.newLine();
+    // Files
+    logger_1.logger.log(chalk_1.default.bold("Files"));
+    if (report.files.envExample) {
+        logger_1.logger.success(MESSAGES.ENV_EXAMPLE_FOUND);
+    }
+    else {
+        logger_1.logger.warn(MESSAGES.ENV_EXAMPLE_MISSING);
+        logger_1.logger.log("  Hint: Helps other developers understand required environment variables");
+    }
+    if (report.files.env) {
+        logger_1.logger.success(MESSAGES.ENV_FOUND);
+    }
+    else {
+        logger_1.logger.warn(MESSAGES.ENV_MISSING);
+        logger_1.logger.log("  Hint: Required for local development and production deployment");
+    }
+    if (report.files.prismaSchema !== undefined) {
+        if (report.files.prismaSchema) {
+            logger_1.logger.success(MESSAGES.PRISMA_SCHEMA_FOUND);
+        }
+        else {
+            logger_1.logger.error(MESSAGES.PRISMA_SCHEMA_MISSING);
+            logger_1.logger.log("  Hint: Defines your database schema and is required for Prisma to work");
+        }
+    }
+    if (report.files.authRoutes !== undefined) {
+        if (report.files.authRoutes) {
+            logger_1.logger.success(MESSAGES.AUTH_ROUTES_FOUND);
+        }
+        else {
+            logger_1.logger.warn(MESSAGES.AUTH_ROUTES_MISSING);
+            logger_1.logger.log("  Hint: Authentication routes handle login/logout flows");
+        }
+    }
+    logger_1.logger.newLine();
+    // Environment
+    if (report.env.missing.length > 0 || report.env.present.length > 0) {
+        logger_1.logger.log(chalk_1.default.bold("Environment Variables"));
+        if (report.env.present.length > 0) {
+            logger_1.logger.success(MESSAGES.ENV_VARS_PRESENT(report.env.present));
+        }
+        if (report.env.missing.length > 0) {
+            logger_1.logger.error(MESSAGES.ENV_VARS_MISSING(report.env.missing));
+        }
+        logger_1.logger.newLine();
+    }
+    // Conflicts
+    if (report.conflicts.length > 0) {
+        logger_1.logger.log(chalk_1.default.bold("Conflicts"));
+        report.conflicts.forEach(conflict => {
+            logger_1.logger.warn(conflict);
+        });
+        logger_1.logger.newLine();
+    }
+    // Detailed checks if verbose
+    if (verbose) {
+        logger_1.logger.log(chalk_1.default.bold("Detailed Checks"));
+        report.checks.forEach(check => {
+            if (check.status === "success") {
+                logger_1.logger.success(check.message);
+            }
+            else if (check.status === "warning") {
+                logger_1.logger.warn(check.message);
+            }
+            else {
+                logger_1.logger.error(check.message);
+            }
+            if (check.details) {
+                logger_1.logger.log(`    ${chalk_1.default.gray(check.details)}`);
+            }
+        });
+        logger_1.logger.newLine();
+    }
+    // Summary
+    logger_1.logger.log(chalk_1.default.bold("Summary"));
+    logger_1.logger.log(`  Errors: ${report.summary.errors}`);
+    logger_1.logger.log(`  Warnings: ${report.summary.warnings}`);
+    logger_1.logger.newLine();
+    if (report.summary.suggestions.length > 0) {
+        logger_1.logger.log(chalk_1.default.bold("Suggestions"));
+        report.summary.suggestions.forEach(suggestion => {
+            logger_1.logger.log(`  • ${suggestion}`);
+        });
+    }
+}

package/dist/commands/list.d.ts

@@ -1,5 +1,5 @@
 interface ListOptions {
-    templates?: boolean;
+    frameworks?: boolean;
     modules?: boolean;
 }
 export declare function listCommand(options: ListOptions): Promise<void>;