stackkit-cli 0.4.3 → 0.4.5

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>;

package/dist/commands/list.js

@@ -9,37 +9,35 @@ const fs_extra_1 = __importDefault(require("fs-extra"));
 const path_1 = __importDefault(require("path"));
 const logger_1 = require("../utils/logger");
 async function listCommand(options) {
-    const showTemplates = !options.modules || options.templates;
-    const showModules = !options.templates || options.modules;
+    const showFrameworks = !options.modules || options.frameworks;
+    const showModules = !options.frameworks || options.modules;
     try {
+        logger_1.logger.header("StackKit Resources");
         logger_1.logger.newLine();
-        // List templates
-        if (showTemplates) {
+        let hasFrameworks = false;
+        let hasModules = false;
+        // List frameworks
+        if (showFrameworks) {
             const templatesDir = path_1.default.join(__dirname, "..", "..", "templates");
-            const templates = await getAvailableTemplates(templatesDir);
-            logger_1.logger.log(chalk_1.default.bold.cyan("▸ TEMPLATES") + chalk_1.default.gray(` (${templates.length})`));
-            logger_1.logger.newLine();
-            if (templates.length === 0) {
-                logger_1.logger.log(chalk_1.default.dim("  No templates available"));
-            }
-            else {
-                templates.forEach((template) => {
-                    logger_1.logger.log(`  ${chalk_1.default.cyan("•")} ${template.displayName}`);
+            const frameworks = await getAvailableFrameworks(templatesDir);
+            if (frameworks.length > 0) {
+                hasFrameworks = true;
+                logger_1.logger.log(chalk_1.default.bold.blue("FRAMEWORKS"));
+                frameworks.forEach((framework, index) => {
+                    const isLast = index === frameworks.length - 1;
+                    const prefix = isLast ? "└──" : "├──";
+                    logger_1.logger.log(`  ${chalk_1.default.gray(prefix)} ${chalk_1.default.cyan(framework.displayName)}`);
                 });
+                logger_1.logger.newLine();
             }
-            logger_1.logger.newLine();
         }
         // List modules
         if (showModules) {
             const modulesDir = path_1.default.join(__dirname, "..", "..", "modules");
             const modules = await getAvailableModules(modulesDir);
-            logger_1.logger.log(chalk_1.default.bold.cyan("▸ MODULES") + chalk_1.default.gray(` (${modules.length})`));
-            if (modules.length === 0) {
-                logger_1.logger.newLine();
-                logger_1.logger.log(chalk_1.default.dim("  No modules available"));
-                logger_1.logger.newLine();
-            }
-            else {
+            if (modules.length > 0) {
+                hasModules = true;
+                logger_1.logger.log(chalk_1.default.bold.magenta("MODULES"));
                 // Group by category
                 const grouped = modules.reduce((acc, mod) => {
                     if (!acc[mod.category]) {
@@ -48,36 +46,59 @@ async function listCommand(options) {
                     acc[mod.category].push(mod);
                     return acc;
                 }, {});
-                for (const [category, mods] of Object.entries(grouped)) {
-                    logger_1.logger.newLine();
-                    logger_1.logger.log(`  ${chalk_1.default.yellow("→")} ${chalk_1.default.bold.yellow(category.toUpperCase())} ${chalk_1.default.dim(`(${mods.length})`)}`);
-                    mods.forEach((mod) => {
-                        logger_1.logger.log(`    ${chalk_1.default.cyan("•")} ${mod.displayName}`);
+                const categories = Object.keys(grouped);
+                categories.forEach((category, categoryIndex) => {
+                    const mods = grouped[category];
+                    const isLastCategory = categoryIndex === categories.length - 1;
+                    const categoryPrefix = isLastCategory ? "└──" : "├──";
+                    logger_1.logger.log(`  ${chalk_1.default.gray(categoryPrefix)} ${chalk_1.default.yellow(formatCategoryName(category))} ${chalk_1.default.dim(`(${mods.length})`)}`);
+                    mods.forEach((mod, modIndex) => {
+                        const isLastMod = modIndex === mods.length - 1;
+                        const modPrefix = isLastCategory ? (isLastMod ? "    └──" : "    ├──") : (isLastMod ? "│   └──" : "│   ├──");
+                        logger_1.logger.log(`  ${chalk_1.default.gray(modPrefix)} ${chalk_1.default.green(mod.displayName)}`);
+                        // Show additional details for database modules
+                        if (mod.category === "database" && mod.name === "prisma") {
+                            const providerPrefix = isLastCategory ? (isLastMod ? "        └──" : "        ├──") : (isLastMod ? "│       └──" : "│       ├──");
+                            logger_1.logger.log(`  ${chalk_1.default.gray(providerPrefix)} ${chalk_1.default.dim("Providers: PostgreSQL, MongoDB, MySQL, SQLite")}`);
+                        }
                     });
-                }
+                });
                 logger_1.logger.newLine();
             }
         }
+        if (!hasFrameworks && !hasModules) {
+            logger_1.logger.log(chalk_1.default.dim("No resources available"));
+            logger_1.logger.newLine();
+        }
+        logger_1.logger.log(chalk_1.default.dim("Use 'stackkit add <module>' to add modules to your project"));
+        logger_1.logger.newLine();
     }
     catch (error) {
         logger_1.logger.error(`Failed to list resources: ${error.message}`);
         process.exit(1);
     }
 }
-async function getAvailableTemplates(templatesDir) {
+async function getAvailableFrameworks(templatesDir) {
     if (!(await fs_extra_1.default.pathExists(templatesDir))) {
         return [];
     }
-    const templateDirs = await fs_extra_1.default.readdir(templatesDir);
-    const templates = [];
-    for (const dir of templateDirs) {
-        const metadataPath = path_1.default.join(templatesDir, dir, "template.json");
-        if (await fs_extra_1.default.pathExists(metadataPath)) {
-            const metadata = await fs_extra_1.default.readJSON(metadataPath);
-            templates.push(metadata);
-        }
-    }
-    return templates;
+    const frameworkDirs = await fs_extra_1.default.readdir(templatesDir);
+    const frameworks = frameworkDirs
+        .filter((dir) => dir !== "node_modules" && dir !== ".git")
+        .map((dir) => ({
+        name: dir,
+        displayName: formatFrameworkName(dir),
+    }));
+    return frameworks;
+}
+function formatFrameworkName(name) {
+    return name
+        .split("-")
+        .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+        .join(" ");
+}
+function formatCategoryName(name) {
+    return name.charAt(0).toUpperCase() + name.slice(1);
 }
 async function getAvailableModules(modulesDir) {
     if (!(await fs_extra_1.default.pathExists(modulesDir))) {

package/dist/index.js

@@ -7,28 +7,18 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const chalk_1 = __importDefault(require("chalk"));
 const commander_1 = require("commander");
 const add_1 = require("./commands/add");
-const init_1 = require("./commands/init");
+const doctor_1 = require("./commands/doctor");
 const list_1 = require("./commands/list");
 const program = new commander_1.Command();
 program
     .name("stackkit")
     .description("Production-ready project generator and module CLI")
     .version("0.3.2");
-// Init command
-program
-    .command("init [project-name]")
-    .description("Create a new project from a template")
-    .option("-t, --template <template>", "Template to use")
-    .option("--pm <pm>", "Package manager to use (npm, yarn, pnpm, bun)")
-    .option("--no-install", "Skip installing dependencies")
-    .option("--no-git", "Skip git initialization")
-    .option("-y, --yes", "Skip prompts and use defaults")
-    .action(init_1.initCommand);
 // List command
 program
     .command("list")
-    .description("List available templates and modules")
-    .option("-t, --templates", "List only templates")
+    .description("List available frameworks and modules")
+    .option("-f, --frameworks", "List only frameworks")
     .option("-m, --modules", "List only modules")
     .action(list_1.listCommand);
 // Add command
@@ -40,6 +30,14 @@ program
     .option("--dry-run", "Show what would be changed without making changes")
     .option("--no-install", "Skip installing dependencies")
     .action(add_1.addCommand);
+// Doctor command
+program
+    .command("doctor")
+    .description("Check project health and compatibility with StackKit modules")
+    .option("--json", "Output results in JSON format")
+    .option("--verbose", "Show detailed information")
+    .option("--strict", "Treat warnings as errors")
+    .action(doctor_1.doctorCommand);
 // Error handling
 program.on("command:*", () => {
     // Use logger for error and info