stackkit-cli 0.4.4 → 0.4.5

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

package/dist/types/index.d.ts

@@ -28,6 +28,21 @@ export interface ModuleMetadata {
         };
     }>;
     postInstall?: string[];
+    databaseAdapters?: {
+        common?: {
+            dependencies?: Record<string, string>;
+            devDependencies?: Record<string, string>;
+        };
+        providers?: Record<string, Record<string, {
+            dependencies?: Record<string, string>;
+            devDependencies?: Record<string, string>;
+        }>>;
+    };
+    frameworkConfigs?: Record<string, {
+        dependencies?: Record<string, string>;
+        devDependencies?: Record<string, string>;
+        patches?: ModulePatch[];
+    }>;
 }
 export interface EnvVar {
     key: string;

package/dist/utils/config-utils.d.ts

@@ -0,0 +1,2 @@
+export declare function deepMerge(target: Record<string, unknown>, source: Record<string, unknown>): Record<string, unknown>;
+export declare function applyFrameworkPatches(targetDir: string, patches: Record<string, unknown>): Promise<void>;

package/dist/utils/config-utils.js

@@ -0,0 +1,88 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deepMerge = deepMerge;
+exports.applyFrameworkPatches = applyFrameworkPatches;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = require("path");
+function deepMerge(target, source) {
+    const result = { ...target };
+    for (const key in source) {
+        if (source[key] && typeof source[key] === "object" && !Array.isArray(source[key])) {
+            result[key] = deepMerge(result[key] || {}, source[key]);
+        }
+        else {
+            result[key] = source[key];
+        }
+    }
+    return result;
+}
+async function applyFrameworkPatches(targetDir, patches) {
+    for (const [filename, patchConfig] of Object.entries(patches)) {
+        const filePath = (0, path_1.join)(targetDir, filename);
+        if (await fs_extra_1.default.pathExists(filePath)) {
+            if (patchConfig && typeof patchConfig === "object" && "merge" in patchConfig) {
+                const fileContent = await fs_extra_1.default.readJson(filePath);
+                const merged = deepMerge(fileContent, patchConfig.merge);
+                await fs_extra_1.default.writeJson(filePath, merged, { spaces: 2 });
+            }
+            else if (patchConfig && typeof patchConfig === "object" && "replace" in patchConfig) {
+                let fileContent = await fs_extra_1.default.readFile(filePath, "utf-8");
+                const replaceConfig = patchConfig;
+                for (const [oldStr, newStr] of Object.entries(replaceConfig.replace)) {
+                    fileContent = fileContent.replace(new RegExp(oldStr.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "g"), newStr);
+                }
+                await fs_extra_1.default.writeFile(filePath, fileContent);
+            }
+            else if (patchConfig &&
+                typeof patchConfig === "object" &&
+                ("operations" in patchConfig ||
+                    ("type" in patchConfig && patchConfig.type === "patch-file"))) {
+                let fileContent = await fs_extra_1.default.readFile(filePath, "utf-8");
+                const operations = patchConfig.operations;
+                for (const operation of operations) {
+                    if (operation && typeof operation === "object" && "type" in operation) {
+                        const op = operation;
+                        if (op.type === "add-import" && "imports" in op && Array.isArray(op.imports)) {
+                            const imports = op.imports;
+                            // Add imports at the top after existing imports
+                            const importLines = imports.join("\n");
+                            // Find the last import statement
+                            const lines = fileContent.split("\n");
+                            let lastImportIndex = -1;
+                            for (let i = 0; i < lines.length; i++) {
+                                if (lines[i].trim().startsWith("import")) {
+                                    lastImportIndex = i;
+                                }
+                                else if (lines[i].trim() !== "" && !lines[i].trim().startsWith("//")) {
+                                    break;
+                                }
+                            }
+                            if (lastImportIndex >= 0) {
+                                lines.splice(lastImportIndex + 1, 0, "", importLines);
+                                fileContent = lines.join("\n");
+                            }
+                        }
+                        else if (op.type === "add-code" && "after" in op && "code" in op) {
+                            const after = op.after;
+                            const code = op.code;
+                            const afterIndex = fileContent.indexOf(after);
+                            if (afterIndex >= 0) {
+                                const insertPos = afterIndex + after.length;
+                                fileContent = fileContent.slice(0, insertPos) + code + fileContent.slice(insertPos);
+                            }
+                        }
+                        else if (op.type === "replace" && "oldString" in op && "newString" in op) {
+                            const oldString = op.oldString;
+                            const newString = op.newString;
+                            fileContent = fileContent.replace(oldString, newString);
+                        }
+                    }
+                }
+                await fs_extra_1.default.writeFile(filePath, fileContent);
+            }
+        }
+    }
+}

package/dist/utils/detect.js

@@ -54,7 +54,18 @@ async function detectProjectInfo(targetDir) {
     }
     // Detect TypeScript vs JavaScript
     const tsconfigExists = await fs_extra_1.default.pathExists(path_1.default.join(targetDir, "tsconfig.json"));
-    const language = tsconfigExists ? "ts" : "js";
+    const jsconfigExists = await fs_extra_1.default.pathExists(path_1.default.join(targetDir, "jsconfig.json"));
+    let language;
+    if (tsconfigExists) {
+        language = "ts";
+    }
+    else if (jsconfigExists) {
+        language = "js";
+    }
+    else {
+        // Default to TypeScript if neither exists
+        language = "ts";
+    }
     // Detect package manager
     const yarnLockExists = await fs_extra_1.default.pathExists(path_1.default.join(targetDir, "yarn.lock"));
     const pnpmLockExists = await fs_extra_1.default.pathExists(path_1.default.join(targetDir, "pnpm-lock.yaml"));
@@ -73,7 +84,6 @@ async function detectProjectInfo(targetDir) {
     const hasAuth = !!(packageJson.dependencies?.["next-auth"] ||
         packageJson.dependencies?.["better-auth"] ||
         packageJson.dependencies?.["@auth/core"] ||
-        packageJson.dependencies?.["@clerk/nextjs"] ||
         packageJson.dependencies?.["@kinde-oss/kinde-auth-nextjs"] ||
         packageJson.dependencies?.["passport"]);
     const hasPrisma = !!(packageJson.dependencies?.["@prisma/client"] || packageJson.devDependencies?.["prisma"]);

package/dist/utils/env-editor.d.ts

@@ -1,7 +1,6 @@
 export interface EnvVariable {
     key: string;
     value?: string;
-    description: string;
     required: boolean;
 }
 export declare function addEnvVariables(projectRoot: string, variables: EnvVariable[], options?: {

package/dist/utils/env-editor.js

@@ -13,9 +13,7 @@ const ENV_MARKER_END = "# End StackKit";
 async function addEnvVariables(projectRoot, variables, options = {}) {
     const envExamplePath = path_1.default.join(projectRoot, ".env.example");
     const envPath = path_1.default.join(projectRoot, ".env");
-    // Add to .env.example
     await appendToEnvFile(envExamplePath, variables, "example", options);
-    // Add to .env if it exists or create it
     const envExists = await fs_extra_1.default.pathExists(envPath);
     if (envExists || options.force) {
         await appendToEnvFile(envPath, variables, "local", options);
@@ -23,11 +21,28 @@ async function addEnvVariables(projectRoot, variables, options = {}) {
     logger_1.logger.success("Environment variables added");
 }
 async function appendToEnvFile(filePath, variables, fileType, options = {}) {
+    // Validate environment variable keys
+    for (const variable of variables) {
+        if (!/^[A-Z_][A-Z0-9_]*$/.test(variable.key)) {
+            throw new Error(`Invalid environment variable key: ${variable.key}`);
+        }
+    }
     let content = "";
     if (await fs_extra_1.default.pathExists(filePath)) {
         content = await fs_extra_1.default.readFile(filePath, "utf-8");
     }
-    // Check if variables already exist
+    // If force, remove existing keys first to avoid duplicates
+    if (options.force) {
+        const keysToRemove = variables.map((v) => v.key);
+        await removeFromEnvFile(filePath, keysToRemove);
+        if (await fs_extra_1.default.pathExists(filePath)) {
+            content = await fs_extra_1.default.readFile(filePath, "utf-8");
+        }
+        else {
+            content = "";
+        }
+    }
+    // Check if variables already exist (after potential removal)
     const existingKeys = new Set();
     const lines = content.split("\n");
     for (const line of lines) {
@@ -36,15 +51,7 @@ async function appendToEnvFile(filePath, variables, fileType, options = {}) {
             existingKeys.add(match[1]);
         }
     }
-    const newVariables = variables.filter((v) => {
-        if (existingKeys.has(v.key)) {
-            if (!options.force) {
-                logger_1.logger.warn(`Variable ${v.key} already exists in ${filePath}`);
-                return false;
-            }
-        }
-        return true;
-    });
+    const newVariables = variables.filter((v) => !existingKeys.has(v.key));
     if (newVariables.length === 0) {
         return;
     }
@@ -56,13 +63,11 @@ async function appendToEnvFile(filePath, variables, fileType, options = {}) {
     content += "\n";
     content += `${ENV_MARKER_START} Added by StackKit\n`;
     for (const variable of newVariables) {
-        if (variable.description) {
-            content += `# ${variable.description}\n`;
-        }
-        const value = fileType === "example" ? variable.value || "" : variable.value || "";
+        const value = fileType === "example" ? (variable.value || "") : (variable.value || "");
         content += `${variable.key}=${value}\n`;
     }
     content += `${ENV_MARKER_END}\n`;
+    await fs_extra_1.default.ensureDir(path_1.default.dirname(filePath));
     await fs_extra_1.default.writeFile(filePath, content, "utf-8");
 }
 async function removeEnvVariables(projectRoot, keys) {
@@ -77,15 +82,35 @@ async function removeFromEnvFile(filePath, keys) {
     if (!(await fs_extra_1.default.pathExists(filePath))) {
         return;
     }
-    const content = await fs_extra_1.default.readFile(filePath, "utf-8");
-    const lines = content.split("\n");
-    const newLines = [];
-    for (const line of lines) {
-        const match = line.match(/^([A-Z_][A-Z0-9_]*)=/);
-        if (match && keys.includes(match[1])) {
-            continue; // Skip this line
+    try {
+        const content = await fs_extra_1.default.readFile(filePath, "utf-8");
+        const lines = content.split("\n");
+        const newLines = [];
+        let inStackKitBlock = false;
+        for (const line of lines) {
+            if (line.includes(ENV_MARKER_START)) {
+                inStackKitBlock = true;
+                continue;
+            }
+            if (line.includes(ENV_MARKER_END)) {
+                inStackKitBlock = false;
+                continue;
+            }
+            const match = line.match(/^([A-Z_][A-Z0-9_]*)=/);
+            if (match && keys.includes(match[1])) {
+                continue;
+            }
+            if (!inStackKitBlock || !line.startsWith("#")) {
+                newLines.push(line);
+            }
         }
-        newLines.push(line);
+        while (newLines.length > 0 && newLines[newLines.length - 1].trim() === "") {
+            newLines.pop();
+        }
+        await fs_extra_1.default.writeFile(filePath, newLines.join("\n"), "utf-8");
+    }
+    catch (error) {
+        logger_1.logger.error(`Failed to remove env variables from ${filePath}: ${error}`);
+        throw error;
     }
-    await fs_extra_1.default.writeFile(filePath, newLines.join("\n"), "utf-8");
 }

package/dist/utils/files.d.ts

@@ -1,3 +1,11 @@
+export interface PackageJsonConfig {
+    dependencies?: Record<string, string>;
+    devDependencies?: Record<string, string>;
+    scripts?: Record<string, string>;
+}
+export declare function copyBaseFramework(templatesDir: string, targetDir: string, framework: string): Promise<void>;
+export declare function mergePackageJson(targetDir: string, config: PackageJsonConfig): Promise<void>;
+export declare function mergeEnvFile(targetDir: string, envVars: Record<string, string>): Promise<void>;
 export declare function copyTemplate(templatePath: string, targetPath: string, projectName: string): Promise<void>;
 export declare function createFile(targetPath: string, content: string, options?: {
     force?: boolean;

package/dist/utils/files.js

@@ -3,6 +3,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.copyBaseFramework = copyBaseFramework;
+exports.mergePackageJson = mergePackageJson;
+exports.mergeEnvFile = mergeEnvFile;
 exports.copyTemplate = copyTemplate;
 exports.createFile = createFile;
 exports.readFile = readFile;
@@ -10,6 +13,54 @@ exports.fileExists = fileExists;
 const fs_extra_1 = __importDefault(require("fs-extra"));
 const path_1 = __importDefault(require("path"));
 const logger_1 = require("./logger");
+async function copyBaseFramework(templatesDir, targetDir, framework) {
+    const baseDir = path_1.default.join(templatesDir, framework);
+    if (!(await fs_extra_1.default.pathExists(baseDir))) {
+        throw new Error(`Base template not found for framework: ${framework}\n` + `Expected at: ${baseDir}`);
+    }
+    await fs_extra_1.default.copy(baseDir, targetDir, {
+        filter: (src) => {
+            const basename = path_1.default.basename(src);
+            return !["template.json", "config.json", "node_modules", ".git"].includes(basename);
+        },
+    });
+}
+async function mergePackageJson(targetDir, config) {
+    const pkgPath = path_1.default.join(targetDir, "package.json");
+    if (!(await fs_extra_1.default.pathExists(pkgPath))) {
+        return;
+    }
+    const pkg = await fs_extra_1.default.readJson(pkgPath);
+    if (config.dependencies) {
+        pkg.dependencies = { ...pkg.dependencies, ...config.dependencies };
+    }
+    if (config.devDependencies) {
+        pkg.devDependencies = { ...pkg.devDependencies, ...config.devDependencies };
+    }
+    if (config.scripts) {
+        pkg.scripts = { ...pkg.scripts, ...config.scripts };
+    }
+    await fs_extra_1.default.writeJson(pkgPath, pkg, { spaces: 2 });
+}
+async function mergeEnvFile(targetDir, envVars) {
+    const envPath = path_1.default.join(targetDir, ".env");
+    let existingEnv = "";
+    if (await fs_extra_1.default.pathExists(envPath)) {
+        existingEnv = await fs_extra_1.default.readFile(envPath, "utf-8");
+    }
+    const envLines = existingEnv.split("\n").filter((line) => line.trim() !== "");
+    // Add new variables
+    for (const [key, value] of Object.entries(envVars)) {
+        const existingIndex = envLines.findIndex((line) => line.startsWith(`${key}=`));
+        if (existingIndex !== -1) {
+            envLines[existingIndex] = `${key}=${value}`;
+        }
+        else {
+            envLines.push(`${key}=${value}`);
+        }
+    }
+    await fs_extra_1.default.writeFile(envPath, envLines.join("\n") + "\n", "utf-8");
+}
 async function copyTemplate(templatePath, targetPath, projectName) {
     if (!(await fs_extra_1.default.pathExists(templatePath))) {
         throw new Error(`Template not found: ${templatePath}`);

package/dist/utils/js-conversion.d.ts

@@ -0,0 +1 @@
+export declare function convertToJavaScript(targetDir: string, framework: string): Promise<void>;