stackkit 0.1.0

package/README.md

@@ -0,0 +1,41 @@
+# StackKit CLI
+
+Production-ready CLI for creating and enhancing JavaScript applications.
+
+## Installation
+
+```bash
+npm install -g stackkit
+# or
+npx stackkit
+```
+
+## Create New Project
+
+```bash
+npx stackkit create my-app
+```
+
+## Add Features to Existing Project
+
+```bash
+npx stackkit add auth
+npx stackkit add database
+```
+
+## Check Project Health
+
+```bash
+npx stackkit doctor
+```
+
+## Supported Technologies
+
+- **Frameworks**: Next.js, React (Vite), Express
+- **Databases**: Prisma (PostgreSQL, MySQL, SQLite), Mongoose (MongoDB)
+- **Auth**: Better Auth, Auth.js
+
+## Documentation
+
+- [StackKit Docs](https://stack-kit.dev)
+- [GitHub Repository](https://github.com/tariqul420/stackkit)

package/bin/stackkit.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+
+// eslint-disable-next-line
+require("../dist/index.js");

package/dist/cli/add.d.ts

@@ -0,0 +1,8 @@
+interface AddOptions {
+    provider?: string;
+    force?: boolean;
+    dryRun?: boolean;
+    install?: boolean;
+}
+export declare function addCommand(module: string, options: AddOptions): Promise<void>;
+export {};

package/dist/cli/add.js

@@ -0,0 +1,313 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": 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"));
+const detect_1 = require("../lib/project/detect");
+const env_editor_1 = require("../lib/env/env-editor");
+const files_1 = require("../lib/fs/files");
+const logger_1 = require("../lib/ui/logger");
+const package_manager_1 = require("../lib/pm/package-manager");
+const database_config_1 = require("../lib/database/database-config");
+async function addCommand(module, options) {
+    try {
+        const projectRoot = process.cwd();
+        const spinner = logger_1.logger.startSpinner("Detecting project...");
+        const projectInfo = await (0, detect_1.detectProjectInfo)(projectRoot);
+        spinner.succeed(`Detected ${projectInfo.framework} (${projectInfo.router} router, ${projectInfo.language})`);
+        const moduleMetadata = await loadModuleMetadata(path_1.default.join(__dirname, "..", "..", "..", "modules"), module, options.provider);
+        if (!moduleMetadata) {
+            logger_1.logger.error(`Module "${module}" not found`);
+            process.exit(1);
+        }
+        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;
+                }
+            }
+        }
+        const mergedDeps = {};
+        const mergedDevDeps = {};
+        if (moduleMetadata.frameworkConfigs?.shared?.dependencies) {
+            Object.assign(mergedDeps, moduleMetadata.frameworkConfigs.shared.dependencies);
+        }
+        if (moduleMetadata.frameworkConfigs?.shared?.devDependencies) {
+            Object.assign(mergedDevDeps, moduleMetadata.frameworkConfigs.shared.devDependencies);
+        }
+        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);
+        }
+        moduleMetadata.dependencies = mergedDeps;
+        moduleMetadata.devDependencies = mergedDevDeps;
+        const variables = {};
+        if (selectedProvider) {
+            variables.provider = selectedProvider;
+            variables.connectionString = database_config_1.DATABASE_CONNECTION_STRINGS[selectedProvider] || "";
+        }
+        if (!moduleMetadata.supportedFrameworks.includes(projectInfo.framework)) {
+            logger_1.logger.error(`Module "${module}" does not support ${projectInfo.framework}. Supported: ${moduleMetadata.supportedFrameworks.join(", ")}`);
+            process.exit(1);
+        }
+        if (module === "auth" && projectInfo.hasAuth && !options.force) {
+            logger_1.logger.warn("Auth library already detected in this project");
+            const { proceed } = await inquirer_1.default.prompt([
+                {
+                    type: "confirm",
+                    name: "proceed",
+                    message: "Continue anyway? (use --force to skip this prompt)",
+                    default: false,
+                },
+            ]);
+            if (!proceed) {
+                logger_1.logger.info("Cancelled");
+                process.exit(0);
+            }
+        }
+        if (options.dryRun) {
+            logger_1.logger.warn("Dry run mode - no changes will be made");
+            logger_1.logger.newLine();
+        }
+        await applyModulePatches(projectRoot, projectInfo, moduleMetadata, path_1.default.join(__dirname, "..", "..", "modules"), module, options);
+        if (moduleMetadata.frameworkPatches && !options.dryRun) {
+            await applyFrameworkPatches(projectRoot, moduleMetadata.frameworkPatches, projectInfo.framework);
+        }
+        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;
+            }
+        }
+        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);
+            }
+            else {
+                logger_1.logger.info(`Would add dependencies: ${deps.join(", ")}`);
+            }
+        }
+        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);
+            }
+            else {
+                logger_1.logger.info(`Would add dev dependencies: ${devDeps.join(", ")}`);
+            }
+        }
+        if (moduleMetadata.envVars && moduleMetadata.envVars.length > 0) {
+            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, processedEnvVars, { force: options.force });
+            }
+            else {
+                logger_1.logger.log(`  ${chalk_1.default.dim("~")} .env.example`);
+            }
+        }
+        logger_1.logger.newLine();
+        logger_1.logger.success(`Added ${chalk_1.default.bold(moduleMetadata.displayName)}`);
+        logger_1.logger.newLine();
+        if (moduleMetadata.envVars && moduleMetadata.envVars.some((v) => v.required)) {
+            logger_1.logger.log("Next: Fill in environment variables in .env");
+        }
+        logger_1.logger.newLine();
+    }
+    catch (error) {
+        logger_1.logger.error(`Failed to add module: ${error.message}`);
+        if (error instanceof Error && error.stack) {
+            logger_1.logger.log(chalk_1.default.gray(error.stack));
+        }
+        process.exit(1);
+    }
+}
+async function loadModuleMetadata(modulesDir, moduleName, provider) {
+    if (!(await fs_extra_1.default.pathExists(modulesDir))) {
+        return null;
+    }
+    const categories = await fs_extra_1.default.readdir(modulesDir);
+    for (const category of categories) {
+        const categoryPath = path_1.default.join(modulesDir, category);
+        const stat = await fs_extra_1.default.stat(categoryPath);
+        if (!stat.isDirectory())
+            continue;
+        const moduleDirs = await fs_extra_1.default.readdir(categoryPath);
+        for (const moduleDir of moduleDirs) {
+            const modulePath = path_1.default.join(categoryPath, moduleDir);
+            const moduleStat = await fs_extra_1.default.stat(modulePath);
+            if (!moduleStat.isDirectory())
+                continue;
+            const metadataPath = path_1.default.join(modulePath, "module.json");
+            if (await fs_extra_1.default.pathExists(metadataPath)) {
+                const metadata = await fs_extra_1.default.readJSON(metadataPath);
+                if (provider && moduleDir === provider) {
+                    return await loadGeneratorAndMerge(metadata, modulePath);
+                }
+                if (!provider && metadata.category === moduleName) {
+                    return await loadGeneratorAndMerge(metadata, modulePath);
+                }
+            }
+        }
+    }
+    return null;
+}
+async function loadGeneratorAndMerge(metadata, modulePath) {
+    const generatorPath = path_1.default.join(modulePath, "generator.json");
+    if (await fs_extra_1.default.pathExists(generatorPath)) {
+        const generator = await fs_extra_1.default.readJSON(generatorPath);
+        // Merge envVars, dependencies, etc.
+        if (generator.envVars) {
+            metadata.envVars = metadata.envVars || [];
+            for (const [key, value] of Object.entries(generator.envVars)) {
+                metadata.envVars.push({ key, value: value, description: `Environment variable for ${key}`, required: true });
+            }
+        }
+        if (generator.dependencies) {
+            metadata.dependencies = { ...metadata.dependencies, ...generator.dependencies };
+        }
+        if (generator.devDependencies) {
+            metadata.devDependencies = { ...metadata.devDependencies, ...generator.devDependencies };
+        }
+        if (generator.scripts) {
+            // Perhaps add to metadata, but currently not used
+        }
+        // For operations, perhaps add to patches or something, but for now, keep manual
+    }
+    return metadata;
+}
+async function applyModulePatches(projectRoot, projectInfo, moduleMetadata, modulesDir, moduleName, options) {
+    if (!moduleMetadata.patches || !Array.isArray(moduleMetadata.patches)) {
+        return;
+    }
+    const moduleBasePath = await findModulePath(modulesDir, moduleName, options.provider);
+    if (!moduleBasePath) {
+        throw new Error("Module files not found");
+    }
+    for (const patch of moduleMetadata.patches) {
+        if (patch.type === "create-file") {
+            const filePatch = patch;
+            if (filePatch.condition) {
+                if (filePatch.condition.router && filePatch.condition.router !== projectInfo.router) {
+                    continue;
+                }
+                if (filePatch.condition.language && filePatch.condition.language !== projectInfo.language) {
+                    continue;
+                }
+            }
+            const sourceFile = path_1.default.join(moduleBasePath, "files", filePatch.source);
+            let destFile = path_1.default.join(projectRoot, filePatch.destination);
+            destFile = destFile
+                .replace("{{router}}", (0, detect_1.getRouterBasePath)(projectInfo))
+                .replace("{{lib}}", (0, detect_1.getLibPath)(projectInfo));
+            if (!options.dryRun) {
+                if (await (0, files_1.fileExists)(sourceFile)) {
+                    const content = await fs_extra_1.default.readFile(sourceFile, "utf-8");
+                    await (0, files_1.createFile)(destFile, content, { force: options.force });
+                    const relativePath = path_1.default.relative(projectRoot, destFile);
+                    logger_1.logger.log(`  ${chalk_1.default.green("+")} ${relativePath}`);
+                }
+                else {
+                    logger_1.logger.warn(`Source file not found: ${filePatch.source}`);
+                }
+            }
+            else {
+                const relativePath = path_1.default.relative(projectRoot, destFile);
+                logger_1.logger.log(`  ${chalk_1.default.dim("+")} ${relativePath}`);
+            }
+        }
+    }
+}
+async function findModulePath(modulesDir, moduleName, provider) {
+    const categories = await fs_extra_1.default.readdir(modulesDir);
+    for (const category of categories) {
+        const categoryPath = path_1.default.join(modulesDir, category);
+        const stat = await fs_extra_1.default.stat(categoryPath);
+        if (!stat.isDirectory())
+            continue;
+        const moduleDirs = await fs_extra_1.default.readdir(categoryPath);
+        for (const moduleDir of moduleDirs) {
+            const modulePath = path_1.default.join(categoryPath, moduleDir);
+            const moduleStat = await fs_extra_1.default.stat(modulePath);
+            if (!moduleStat.isDirectory())
+                continue;
+            const metadataPath = path_1.default.join(modulePath, "module.json");
+            if (await fs_extra_1.default.pathExists(metadataPath)) {
+                const metadata = await fs_extra_1.default.readJSON(metadataPath);
+                if (provider && moduleDir === provider) {
+                    return modulePath;
+                }
+                if (!provider && metadata.name === moduleName) {
+                    return modulePath;
+                }
+            }
+        }
+    }
+    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/cli/create.d.ts

@@ -0,0 +1,22 @@
+interface CliOptions {
+    framework?: string;
+    f?: string;
+    database?: string;
+    d?: string;
+    auth?: string;
+    a?: string;
+    language?: string;
+    l?: string;
+    packageManager?: string;
+    p?: string;
+    install?: boolean;
+    'skip-install'?: boolean;
+    skipInstall?: boolean;
+    git?: boolean;
+    'no-git'?: boolean;
+    noGit?: boolean;
+    yes?: boolean;
+    y?: boolean;
+}
+export declare function createProject(projectName?: string, options?: CliOptions): Promise<void>;
+export {};