stackkit-cli 0.4.3 → 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

@@ -1,2 +1,11 @@
 #!/usr/bin/env node
-require("../dist/index.js");
+
+try {
+  // eslint-disable-next-line
+  require("ts-node/register");
+  // eslint-disable-next-line
+  require("../src/index.ts");
+} catch {
+  // eslint-disable-next-line
+  require("../dist/index.js");
+}

package/dist/commands/add.js

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.addCommand = addCommand;
 const chalk_1 = __importDefault(require("chalk"));
+const child_process_1 = require("child_process");
 const fs_extra_1 = __importDefault(require("fs-extra"));
 const inquirer_1 = __importDefault(require("inquirer"));
 const path_1 = __importDefault(require("path"));
@@ -27,6 +28,62 @@ async function addCommand(module, options) {
             logger_1.logger.error(`Module "${module}" not found`);
             process.exit(1);
         }
+        // For database modules, ensure provider is selected
+        let selectedProvider = options.provider;
+        if (moduleMetadata.category === "database" && !selectedProvider) {
+            if (typeof moduleMetadata.dependencies === "object" &&
+                "providers" in moduleMetadata.dependencies) {
+                const providers = Object.keys(moduleMetadata.dependencies.providers || {});
+                if (providers.length > 0) {
+                    const { provider } = await inquirer_1.default.prompt([
+                        {
+                            type: "list",
+                            name: "provider",
+                            message: "Select database provider:",
+                            choices: providers.map((p) => ({ name: p, value: p })),
+                        },
+                    ]);
+                    selectedProvider = provider;
+                }
+            }
+        }
+        // Merge dependencies based on provider
+        const mergedDeps = {};
+        const mergedDevDeps = {};
+        // Add shared dependencies
+        if (moduleMetadata.frameworkConfigs?.shared?.dependencies) {
+            Object.assign(mergedDeps, moduleMetadata.frameworkConfigs.shared.dependencies);
+        }
+        if (moduleMetadata.frameworkConfigs?.shared?.devDependencies) {
+            Object.assign(mergedDevDeps, moduleMetadata.frameworkConfigs.shared.devDependencies);
+        }
+        // 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;
+        moduleMetadata.devDependencies = mergedDevDeps;
+        // Set variables for replacements
+        const variables = {};
+        if (selectedProvider) {
+            variables.provider = selectedProvider;
+            if (selectedProvider === "postgresql") {
+                variables.connectionString = "postgresql://user:password@localhost:5432/mydb?schema=public";
+            }
+            else if (selectedProvider === "mongodb") {
+                variables.connectionString = "mongodb://localhost:27017/mydb";
+            }
+            else if (selectedProvider === "mysql") {
+                variables.connectionString = "mysql://user:password@localhost:3306/mydb";
+            }
+            else if (selectedProvider === "sqlite") {
+                variables.connectionString = "file:./dev.db";
+            }
+        }
         // Check if framework is supported
         if (!moduleMetadata.supportedFrameworks.includes(projectInfo.framework)) {
             logger_1.logger.error(`Module "${module}" does not support ${projectInfo.framework}. Supported: ${moduleMetadata.supportedFrameworks.join(", ")}`);
@@ -54,9 +111,27 @@ async function addCommand(module, options) {
         }
         // Apply module patches
         await applyModulePatches(projectRoot, projectInfo, moduleMetadata, modulesDir, module, options);
+        // Apply framework patches
+        if (moduleMetadata.frameworkPatches && !options.dryRun) {
+            await applyFrameworkPatches(projectRoot, moduleMetadata.frameworkPatches, projectInfo.framework);
+        }
+        // Run post-install commands
+        if (moduleMetadata.postInstall && moduleMetadata.postInstall.length > 0 && !options.dryRun) {
+            const postInstallSpinner = logger_1.logger.startSpinner("Running post-install commands...");
+            try {
+                for (const command of moduleMetadata.postInstall) {
+                    (0, child_process_1.execSync)(command, { cwd: projectRoot, stdio: "pipe" });
+                }
+                postInstallSpinner.succeed("Post-install commands completed");
+            }
+            catch (error) {
+                postInstallSpinner.fail("Failed to run post-install commands");
+                throw error;
+            }
+        }
         // 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);
             }
@@ -65,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);
             }
@@ -77,9 +150,14 @@ 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,
+                value: envVar.value?.replace(/\{\{(\w+)\}\}/g, (match, key) => variables[key] || match),
+            }));
             if (!options.dryRun) {
-                await (0, env_editor_1.addEnvVariables)(projectRoot, moduleMetadata.envVars, { force: options.force });
+                await (0, env_editor_1.addEnvVariables)(projectRoot, processedEnvVars, { force: options.force });
             }
             else {
                 logger_1.logger.log(`  ${chalk_1.default.dim("~")} .env.example`);
@@ -89,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();
@@ -136,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) {
@@ -208,3 +288,41 @@ async function findModulePath(modulesDir, moduleName, provider) {
     }
     return null;
 }
+async function applyFrameworkPatches(projectRoot, patches, framework) {
+    const frameworkKey = framework;
+    const frameworkPatches = patches[frameworkKey];
+    if (!frameworkPatches)
+        return;
+    for (const [filename, patchConfig] of Object.entries(frameworkPatches)) {
+        const filePath = path_1.default.join(projectRoot, filename);
+        if (await fs_extra_1.default.pathExists(filePath)) {
+            const fileContent = await fs_extra_1.default.readJson(filePath);
+            if (patchConfig.merge) {
+                const merged = deepMerge(fileContent, patchConfig.merge);
+                await fs_extra_1.default.writeJson(filePath, merged, { spaces: 2 });
+                const relativePath = path_1.default.relative(projectRoot, filePath);
+                logger_1.logger.log(`  ${chalk_1.default.blue("~")} ${relativePath}`);
+            }
+        }
+    }
+}
+function deepMerge(target, source) {
+    const output = { ...target };
+    for (const key in source) {
+        if (source[key] && typeof source[key] === "object" && !Array.isArray(source[key])) {
+            if (target[key]) {
+                output[key] = deepMerge(target[key], source[key]);
+            }
+            else {
+                output[key] = source[key];
+            }
+        }
+        else if (Array.isArray(source[key])) {
+            output[key] = Array.from(new Set([...(target[key] || []), ...source[key]]));
+        }
+        else {
+            output[key] = source[key];
+        }
+    }
+    return output;
+}

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