stackkit 0.1.0

package/dist/cli/doctor.js

@@ -0,0 +1,569 @@
+"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("../lib/ui/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(", ")}`,
+    TSCONFIG_MISSING: "tsconfig.json missing (required for TypeScript)",
+    TSCONFIG_FOUND: "tsconfig.json found",
+    ESLINT_CONFIG_MISSING: "ESLint config missing (recommended for code quality)",
+    ESLINT_CONFIG_FOUND: "ESLint config found",
+    BUILD_SCRIPT_MISSING: "Build script missing in package.json",
+    BUILD_SCRIPT_FOUND: "Build script found",
+    DEPENDENCY_OUTDATED: (deps) => `Outdated dependencies: ${deps.join(", ")}`,
+    DEPENDENCY_UP_TO_DATE: "Dependencies are up to date",
+    GIT_REPO_MISSING: "Not a git repository (recommended for version control)",
+    GIT_REPO_FOUND: "Git repository initialized",
+};
+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);
+        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);
+    }
+}
+async function runDoctorChecks() {
+    const checks = [];
+    const projectRoot = await findProjectRoot();
+    checks.push({
+        status: "success",
+        message: `Found project root: ${projectRoot}`,
+    });
+    const packageJson = await readPackageJson(projectRoot);
+    const packageManager = await detectPackageManager(projectRoot);
+    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}`,
+        });
+    }
+    const nodeVersionCheck = checkNodeVersion();
+    checks.push(nodeVersionCheck);
+    const authModules = detectAuthModules(packageJson);
+    const databaseModules = detectDatabaseModules(packageJson);
+    const filesCheck = await checkKeyFiles(projectRoot, projectType, authModules, databaseModules);
+    checks.push(...filesCheck);
+    const envCheck = await checkEnvFiles(projectRoot, authModules, databaseModules);
+    checks.push(...envCheck.checks);
+    const configChecks = await checkConfigFiles(projectRoot, projectType, packageJson);
+    checks.push(...configChecks);
+    const dependencyCheck = await checkDependencies(packageJson);
+    checks.push(dependencyCheck);
+    const gitCheck = await checkGitRepo(projectRoot);
+    checks.push(gitCheck);
+    const conflicts = checkConflicts(authModules, databaseModules);
+    conflicts.forEach(conflict => {
+        checks.push({
+            status: "warning",
+            message: conflict,
+        });
+    });
+    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,
+            tsconfig: await fs_extra_1.default.pathExists(path_1.default.join(projectRoot, "tsconfig.json")),
+            eslintConfig: await checkEslintConfigExists(projectRoot),
+            git: await fs_extra_1.default.pathExists(path_1.default.join(projectRoot, ".git")),
+        },
+        env: envCheck.envStatus,
+        dependencies: {
+            outdated: dependencyCheck.outdated,
+        },
+        conflicts,
+        checks,
+        summary: {
+            errors: checks.filter(c => c.status === "error").length,
+            warnings: checks.filter(c => c.status === "warning").length,
+            suggestions: generateSuggestions(),
+        },
+    };
+    return report;
+}
+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);
+}
+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";
+    }
+    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;
+}
+async function checkConfigFiles(projectRoot, projectType, packageJson) {
+    const checks = [];
+    // Check tsconfig.json
+    const tsconfigExists = await fs_extra_1.default.pathExists(path_1.default.join(projectRoot, "tsconfig.json"));
+    checks.push({
+        status: tsconfigExists ? "success" : "error",
+        message: tsconfigExists ? MESSAGES.TSCONFIG_FOUND : MESSAGES.TSCONFIG_MISSING,
+    });
+    // Check ESLint config
+    const eslintExists = await checkEslintConfigExists(projectRoot);
+    checks.push({
+        status: eslintExists ? "success" : "warning",
+        message: eslintExists ? MESSAGES.ESLINT_CONFIG_FOUND : MESSAGES.ESLINT_CONFIG_MISSING,
+    });
+    // Check build script
+    const hasBuildScript = packageJson.scripts && typeof packageJson.scripts === "object" && "build" in packageJson.scripts;
+    checks.push({
+        status: hasBuildScript ? "success" : "warning",
+        message: hasBuildScript ? MESSAGES.BUILD_SCRIPT_FOUND : MESSAGES.BUILD_SCRIPT_MISSING,
+    });
+    return checks;
+}
+async function checkDependencies(packageJson) {
+    const outdated = [];
+    // Simple check: if dependencies have ^ or ~, assume up to date for now
+    // In production, integrate with npm outdated or similar
+    const deps = { ...packageJson.dependencies, ...packageJson.devDependencies };
+    for (const [name, version] of Object.entries(deps || {})) {
+        if (typeof version === "string" && (version.startsWith("^") || version.startsWith("~"))) {
+            // Assume up to date
+        }
+        else {
+            outdated.push(name);
+        }
+    }
+    return {
+        status: outdated.length > 0 ? "warning" : "success",
+        message: outdated.length > 0 ? MESSAGES.DEPENDENCY_OUTDATED(outdated) : MESSAGES.DEPENDENCY_UP_TO_DATE,
+        outdated,
+    };
+}
+async function checkGitRepo(projectRoot) {
+    const gitExists = await fs_extra_1.default.pathExists(path_1.default.join(projectRoot, ".git"));
+    return {
+        status: gitExists ? "success" : "warning",
+        message: gitExists ? MESSAGES.GIT_REPO_FOUND : MESSAGES.GIT_REPO_MISSING,
+    };
+}
+async function checkEslintConfigExists(projectRoot) {
+    const possibleConfigs = [
+        ".eslintrc.js",
+        ".eslintrc.json",
+        ".eslintrc.yml",
+        ".eslintrc.yaml",
+        "eslint.config.js",
+        "eslint.config.mjs",
+    ];
+    for (const config of possibleConfigs) {
+        if (await fs_extra_1.default.pathExists(path_1.default.join(projectRoot, config))) {
+            return true;
+        }
+    }
+    return false;
+}
+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;
+}
+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");
+        }
+    }
+    if (report.files.tsconfig !== undefined) {
+        if (report.files.tsconfig) {
+            logger_1.logger.success(MESSAGES.TSCONFIG_FOUND);
+        }
+        else {
+            logger_1.logger.error(MESSAGES.TSCONFIG_MISSING);
+            logger_1.logger.log("  Hint: Required for TypeScript compilation");
+        }
+    }
+    if (report.files.eslintConfig !== undefined) {
+        if (report.files.eslintConfig) {
+            logger_1.logger.success(MESSAGES.ESLINT_CONFIG_FOUND);
+        }
+        else {
+            logger_1.logger.warn(MESSAGES.ESLINT_CONFIG_MISSING);
+            logger_1.logger.log("  Hint: Helps maintain code quality");
+        }
+    }
+    if (report.files.git !== undefined) {
+        if (report.files.git) {
+            logger_1.logger.success(MESSAGES.GIT_REPO_FOUND);
+        }
+        else {
+            logger_1.logger.warn(MESSAGES.GIT_REPO_MISSING);
+            logger_1.logger.log("  Hint: Recommended for version control");
+        }
+    }
+    logger_1.logger.newLine();
+    // Dependencies
+    if (report.dependencies.outdated.length > 0) {
+        logger_1.logger.log(chalk_1.default.bold("Dependencies"));
+        logger_1.logger.warn(MESSAGES.DEPENDENCY_OUTDATED(report.dependencies.outdated));
+        logger_1.logger.log("  Hint: Run package manager update command");
+        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/cli/list.d.ts

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