stackkit 0.3.4 → 0.3.6

package/dist/cli/create.js

@@ -7,8 +7,8 @@ exports.createProject = createProject;
 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 prompts_1 = __importDefault(require("prompts"));
 const validate_npm_package_name_1 = __importDefault(require("validate-npm-package-name"));
 const js_conversion_1 = require("../lib/conversion/js-conversion");
 const module_discovery_1 = require("../lib/discovery/module-discovery");
@@ -63,6 +63,9 @@ async function getProjectConfig(projectName, options) {
                 auth: defaultAuth,
                 language: "typescript",
                 packageManager: "pnpm",
+                ui: "none",
+                storageProvider: "none",
+                components: false,
             };
         }
         const framework = (options && (options.framework || options.f)) || undefined;
@@ -134,16 +137,42 @@ async function getProjectConfig(projectName, options) {
             auth,
             language: (language || "typescript"),
             packageManager: (pm || "pnpm"),
+            components: false,
         };
     }
     const prismaProviders = (0, shared_1.getPrismaProvidersFromGenerator)((0, package_root_1.getPackageRoot)());
-    const answers = (await inquirer_1.default.prompt([
-        {
-            type: "input",
+    // Sequential prompts using `prompts` to avoid bundling heavy inquirer code
+    const result = {};
+    const promptSelect = async (name, message, choices, initial) => {
+        const resp = await (0, prompts_1.default)({ type: "select", name, message, choices, initial });
+        return resp[name];
+    };
+    const loadDatabaseChoices = () => {
+        if (discoveredModules.databases && discoveredModules.databases.length > 0) {
+            return (0, module_discovery_1.getDatabaseChoices)(discoveredModules.databases, result.framework || "").map((c) => ({ title: c.name || String(c.value), value: c.value }));
+        }
+        try {
+            const modulesDir = path_1.default.join((0, package_root_1.getPackageRoot)(), "modules", "database");
+            if (fs_extra_1.default.existsSync(modulesDir)) {
+                const dbs = fs_extra_1.default.readdirSync(modulesDir).map((d) => ({
+                    title: d.charAt(0).toUpperCase() + d.slice(1),
+                    value: d,
+                }));
+                dbs.push({ title: "None", value: "none" });
+                return dbs;
+            }
+        }
+        catch {
+            // fall through to default
+        }
+        return [{ title: "None", value: "none" }];
+    };
+    if (!projectName) {
+        const resp = await (0, prompts_1.default)({
+            type: "text",
             name: "projectName",
             message: "Project name:",
-            default: projectName || "my-app",
-            when: !projectName,
+            initial: projectName || "my-app",
             validate: (input) => {
                 const validation = (0, validate_npm_package_name_1.default)(input);
                 if (!validation.validForNewPackages) {
@@ -154,95 +183,186 @@ async function getProjectConfig(projectName, options) {
                 }
                 return true;
             },
-        },
-        {
-            type: "list",
-            name: "framework",
-            message: "Select framework:",
-            choices: (() => {
-                if (discoveredModules.frameworks && discoveredModules.frameworks.length > 0) {
-                    return discoveredModules.frameworks.map((f) => ({ name: f.displayName, value: f.name }));
-                }
-                try {
-                    const templatesDir = path_1.default.join((0, package_root_1.getPackageRoot)(), "templates");
-                    if (fs_extra_1.default.existsSync(templatesDir)) {
-                        const dirs = fs_extra_1.default.readdirSync(templatesDir).filter((d) => d !== "node_modules");
-                        return dirs.map((d) => ({ name: d.charAt(0).toUpperCase() + d.slice(1), value: d }));
-                    }
-                }
-                catch {
-                    return [];
+        });
+        result.projectName = resp.projectName || projectName || "my-app";
+    }
+    else {
+        result.projectName = projectName;
+    }
+    // framework
+    const frameworkChoices = discoveredModules.frameworks && discoveredModules.frameworks.length > 0
+        ? discoveredModules.frameworks.map((f) => ({ title: f.displayName || f.name, value: f.name }))
+        : (() => {
+            try {
+                const templatesDir = path_1.default.join((0, package_root_1.getPackageRoot)(), "templates");
+                if (fs_extra_1.default.existsSync(templatesDir)) {
+                    const dirs = fs_extra_1.default.readdirSync(templatesDir).filter((d) => d !== "node_modules");
+                    return dirs.map((d) => ({ title: d.charAt(0).toUpperCase() + d.slice(1), value: d }));
                 }
+            }
+            catch {
                 return [];
-            })(),
-        },
-        {
-            type: "list",
-            name: "database",
-            message: "Select database/ORM:",
-            when: (answers) => answers.framework !== "react",
-            choices: (answers) => {
-                if (discoveredModules.databases && discoveredModules.databases.length > 0) {
-                    return (0, module_discovery_1.getDatabaseChoices)(discoveredModules.databases, answers.framework);
-                }
-                try {
-                    const modulesDir = path_1.default.join((0, package_root_1.getPackageRoot)(), "modules", "database");
-                    if (fs_extra_1.default.existsSync(modulesDir)) {
-                        const dbs = fs_extra_1.default
-                            .readdirSync(modulesDir)
-                            .map((d) => ({ name: d.charAt(0).toUpperCase() + d.slice(1), value: d }));
-                        dbs.push({ name: "None", value: "none" });
-                        return dbs;
-                    }
-                }
-                catch {
-                    return [{ name: "None", value: "none" }];
-                }
-                return [{ name: "None", value: "none" }];
-            },
-        },
-        {
-            type: "list",
+            }
+            return [];
+        })();
+    const fw = await (0, prompts_1.default)({
+        type: "select",
+        name: "framework",
+        message: "Select framework:",
+        choices: frameworkChoices,
+    });
+    result.framework = fw.framework || (discoveredModules.frameworks?.[0]?.name ?? "");
+    // database (skip for React and Next.js)
+    if (!["react", "nextjs"].includes(result.framework || "")) {
+        const dbChoices = loadDatabaseChoices();
+        const dbChoicesNormalized = dbChoices.map((c) => ({
+            title: c.name || c.title || String(c.value ?? ""),
+            value: c.value ?? String(c.title ?? ""),
+        }));
+        const selected = await promptSelect("database", "Select database/ORM:", dbChoicesNormalized);
+        result.database = selected || "none";
+    }
+    else {
+        result.database = "none";
+    }
+    // prisma provider
+    if (result.database === "prisma" && prismaProviders.length > 0) {
+        const pp = await (0, prompts_1.default)({
+            type: "select",
             name: "prismaProvider",
             message: "Select database provider for Prisma:",
-            when: (answers) => answers.database === "prisma" && prismaProviders.length > 0,
             choices: prismaProviders.map((p) => ({
-                name: p.charAt(0).toUpperCase() + p.slice(1),
+                title: p.charAt(0).toUpperCase() + p.slice(1),
                 value: p,
             })),
-        },
-        {
-            type: "list",
+        });
+        result.prismaProvider = pp.prismaProvider;
+    }
+    // UI system (React / Next.js)
+    if (result.framework === "react" || result.framework === "nextjs") {
+        const uiChoices = (discoveredModules.ui || [])
+            .filter((u) => !u.supportedFrameworks || u.supportedFrameworks.includes(result.framework || ""))
+            .map((u) => ({ title: u.displayName || u.name, value: u.name }));
+        if (uiChoices.length === 0) {
+            uiChoices.push({ title: "Shadcn (shadcn/ui)", value: "shadcn" });
+            uiChoices.push({ title: "None", value: "none" });
+        }
+        const uiInitial = uiChoices.findIndex((c) => c.value === "none");
+        const uiInitialIndex = uiInitial === -1 ? 0 : uiInitial;
+        const uiRespRaw = await (0, prompts_1.default)({
+            type: "select",
+            name: "ui",
+            message: "Select UI system:",
+            choices: uiChoices,
+            initial: uiInitialIndex,
+        });
+        const uiAnswer = uiRespRaw["ui"];
+        if (typeof uiAnswer === "string") {
+            result.ui = uiAnswer;
+        }
+        else {
+            result.ui = "none";
+        }
+    }
+    else {
+        result.ui = "none";
+    }
+    // Storage provider (Express)
+    if (result.framework === "express") {
+        const storageChoices = (discoveredModules.storage || []).map((s) => ({
+            title: s.displayName || s.name,
+            value: s.name,
+        }));
+        if (storageChoices.length === 0) {
+            storageChoices.push({ title: "Cloudinary", value: "cloudinary" });
+        }
+        storageChoices.push({ title: "None", value: "none" });
+        const spRaw = await (0, prompts_1.default)({
+            type: "select",
+            name: "storageProvider",
+            message: "Select storage provider:",
+            choices: storageChoices,
+            initial: Math.max(0, storageChoices.findIndex((c) => c.value === "cloudinary")),
+        });
+        const storageProviderAnswer = spRaw["storageProvider"];
+        if (typeof storageProviderAnswer === "string") {
+            result.storageProvider = storageProviderAnswer;
+        }
+        else {
+            result.storageProvider = "none";
+        }
+    }
+    else {
+        result.storageProvider = "none";
+    }
+    // Components — yes/no, default yes (React / Next.js only)
+    if (result.framework === "react" || result.framework === "nextjs") {
+        const compMeta = (discoveredModules.components || []).find((c) => !c.supportedFrameworks || c.supportedFrameworks.includes(result.framework || ""));
+        if (compMeta) {
+            const compResp = await (0, prompts_1.default)({
+                type: "confirm",
+                name: "add",
+                message: `Add ${compMeta.displayName || compMeta.name}?${compMeta.description ? ` › ${compMeta.description}` : ""}`,
+                initial: true,
+            });
+            result.components = compResp.add !== false;
+        }
+        else {
+            result.components = false;
+        }
+    }
+    else {
+        result.components = false;
+    }
+    // auth
+    if (result.database !== "none" || result.framework === "react" || result.framework === "nextjs") {
+        const authChoices = (0, module_discovery_1.getCompatibleAuthOptions)(discoveredModules.auth, result.framework || "", result.database || "none", discoveredModules.frameworks);
+        const authChoicesNormalized = (authChoices || []).map((c) => ({
+            title: c.name
+                ? c.description
+                    ? `${c.name} — ${c.description}`
+                    : c.name
+                : String(c.value ?? ""),
+            value: c.value ?? String(c.name ?? ""),
+        }));
+        const authResp = await (0, prompts_1.default)({
+            type: "select",
             name: "auth",
             message: "Select authentication:",
-            when: (answers) => answers.database !== "none" || answers.framework === "react",
-            choices: (answers) => (0, module_discovery_1.getCompatibleAuthOptions)(discoveredModules.auth, answers.framework, answers.database || "none", discoveredModules.frameworks),
-        },
-        {
-            type: "list",
-            name: "language",
-            message: "Language:",
-            choices: [
-                { name: "TypeScript", value: "typescript" },
-                { name: "JavaScript", value: "javascript" },
-            ],
-            default: "typescript",
-        },
-        {
-            type: "list",
-            name: "packageManager",
-            message: "Package manager:",
-            choices: [
-                { name: "pnpm (recommended)", value: "pnpm" },
-                { name: "npm", value: "npm" },
-                { name: "yarn", value: "yarn" },
-                { name: "bun", value: "bun" },
-            ],
-            default: "pnpm",
-        },
-    ]));
-    let databaseAnswer = answers.framework === "react" ? "none" : answers.database;
-    let prismaProviderAnswer = answers.prismaProvider;
+            choices: authChoicesNormalized,
+        });
+        result.auth = authResp.auth || "none";
+    }
+    else {
+        result.auth = "none";
+    }
+    const langResp = await (0, prompts_1.default)({
+        type: "select",
+        name: "language",
+        message: "Language:",
+        choices: [
+            { title: "TypeScript", value: "typescript" },
+            { title: "JavaScript", value: "javascript" },
+        ],
+        initial: 0,
+    });
+    result.language = langResp.language || "typescript";
+    const pmResp = await (0, prompts_1.default)({
+        type: "select",
+        name: "packageManager",
+        message: "Package manager:",
+        choices: [
+            { title: "pnpm (recommended)", value: "pnpm" },
+            { title: "npm", value: "npm" },
+            { title: "yarn", value: "yarn" },
+            { title: "bun", value: "bun" },
+        ],
+        initial: 0,
+    });
+    result.packageManager = pmResp.packageManager || "pnpm";
+    // Normalise prisma provider if database string contains prisma-xyz
+    let databaseAnswer = result.database;
+    let prismaProviderAnswer = result.prismaProvider;
     if (typeof databaseAnswer === "string" && databaseAnswer.startsWith("prisma-")) {
         const parts = databaseAnswer.split("-");
         if (parts.length >= 2) {
@@ -251,13 +371,16 @@ async function getProjectConfig(projectName, options) {
         }
     }
     return {
-        projectName: (projectName || answers.projectName),
-        framework: answers.framework,
+        projectName: (projectName || result.projectName),
+        framework: result.framework,
         database: databaseAnswer,
         prismaProvider: prismaProviderAnswer,
-        auth: answers.auth || "none",
-        language: answers.language,
-        packageManager: answers.packageManager,
+        auth: result.auth || "none",
+        language: result.language,
+        packageManager: result.packageManager,
+        ui: result.ui || "none",
+        storageProvider: result.storageProvider || "none",
+        components: result.components ?? false,
     };
 }
 async function generateProject(config, targetDir, options) {
@@ -288,7 +411,7 @@ async function generateProject(config, targetDir, options) {
         const postInstallSpinner = logger_1.logger.startSpinner("Running post-install commands...");
         try {
             for (const command of postInstallCommands) {
-                (0, child_process_1.execSync)(command, { cwd: targetDir, stdio: "pipe" });
+                (0, child_process_1.execSync)(command, { cwd: targetDir, stdio: "inherit" });
             }
             postInstallSpinner.succeed("Post-install commands completed");
         }
@@ -298,13 +421,11 @@ async function generateProject(config, targetDir, options) {
         }
     }
     if (options?.git !== false && !(options?.["no-git"] || options?.noGit)) {
-        const gitSpinner = logger_1.logger.startSpinner("Initializing git repository...");
         try {
             await (0, package_manager_1.initGit)(targetDir);
-            gitSpinner.succeed("Git repository initialized");
         }
         catch (error) {
-            gitSpinner.warn(`Failed to initialize git repository: ${error.message}`);
+            logger_1.logger.warn(`Failed to initialize git repository: ${error.message}`);
         }
     }
 }
@@ -322,6 +443,10 @@ async function composeTemplate(config, targetDir) {
         database: config.database === "none" ? undefined : config.database,
         auth: config.auth === "none" ? undefined : config.auth,
         prismaProvider: config.prismaProvider,
+        ui: config.ui,
+        storageProvider: config.storageProvider,
+        components: config.components === true ? true : undefined,
+        packageManager: config.packageManager,
     }, features, targetDir);
     const packageJsonPath = path_1.default.join(targetDir, "package.json");
     if (await fs_extra_1.default.pathExists(packageJsonPath)) {
@@ -388,6 +513,57 @@ async function processGeneratorEnvVars(config, targetDir) {
             }
         }
     }
+    // UI module env vars
+    if (config.ui && config.ui !== "none") {
+        const uiGeneratorPath = path_1.default.join(modulesDir, "ui", config.ui, "generator.json");
+        if (await fs_extra_1.default.pathExists(uiGeneratorPath)) {
+            const generator = await fs_extra_1.default.readJson(uiGeneratorPath);
+            if (generator.operations) {
+                for (const operation of generator.operations) {
+                    if (operation.type === "add-env" &&
+                        (!operation.condition || checkCondition(operation.condition, config))) {
+                        for (const [key, value] of Object.entries(operation.envVars)) {
+                            envVars.push({ key, value: value, required: true });
+                        }
+                    }
+                }
+            }
+        }
+    }
+    // Storage/provider module env vars
+    if (config.storageProvider && config.storageProvider !== "none") {
+        const spGeneratorPath = path_1.default.join(modulesDir, "storage", config.storageProvider, "generator.json");
+        if (await fs_extra_1.default.pathExists(spGeneratorPath)) {
+            const generator = await fs_extra_1.default.readJson(spGeneratorPath);
+            if (generator.operations) {
+                for (const operation of generator.operations) {
+                    if (operation.type === "add-env" &&
+                        (!operation.condition || checkCondition(operation.condition, config))) {
+                        for (const [key, value] of Object.entries(operation.envVars)) {
+                            envVars.push({ key, value: value, required: true });
+                        }
+                    }
+                }
+            }
+        }
+    }
+    // Components module env vars
+    if (config.components === true) {
+        const compGeneratorPath = path_1.default.join(modulesDir, "components", "generator.json");
+        if (await fs_extra_1.default.pathExists(compGeneratorPath)) {
+            const generator = await fs_extra_1.default.readJson(compGeneratorPath);
+            if (generator.operations) {
+                for (const operation of generator.operations) {
+                    if (operation.type === "add-env" &&
+                        (!operation.condition || checkCondition(operation.condition, config))) {
+                        for (const [key, value] of Object.entries(operation.envVars)) {
+                            envVars.push({ key, value: value, required: true });
+                        }
+                    }
+                }
+            }
+        }
+    }
     if (envVars.length > 0) {
         await (0, env_editor_1.addEnvVariables)(targetDir, envVars, { force: true });
     }

package/dist/cli/doctor.js

@@ -452,6 +452,7 @@ async function checkEslintConfigExists(projectRoot) {
         ".eslintrc.yml",
         ".eslintrc.yaml",
         "eslint.config.js",
+        "eslint.config.cjs",
         "eslint.config.mjs",
     ];
     for (const config of possibleConfigs) {

package/dist/cli/list.d.ts

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

package/dist/cli/list.js

@@ -11,7 +11,7 @@ const shared_1 = require("../lib/discovery/shared");
 const logger_1 = require("../lib/ui/logger");
 const module_loader_1 = require("../lib/utils/module-loader");
 const package_root_1 = require("../lib/utils/package-root");
-async function listCommand(options) {
+async function listCommand(options = {}) {
     const showFrameworks = !options.modules || options.frameworks;
     const showModules = !options.frameworks || options.modules;
     try {
@@ -19,14 +19,16 @@ async function listCommand(options) {
         logger_1.logger.newLine();
         let hasContent = false;
         if (showFrameworks) {
-            const frameworks = await getAvailableFrameworks();
+            let frameworks = [];
+            frameworks = await getAvailableFrameworks();
             if (frameworks.length > 0) {
                 hasContent = true;
                 printFrameworks(frameworks);
             }
         }
         if (showModules) {
-            const modules = await getAvailableModules();
+            let modules = [];
+            modules = await getAvailableModules();
             if (modules.length > 0) {
                 hasContent = true;
                 printModules(modules);
@@ -40,7 +42,7 @@ async function listCommand(options) {
         logger_1.logger.newLine();
     }
     catch (error) {
-        logger_1.logger.error(`Failed to list resources: ${error.message}`);
+        logger_1.logger.error(`Failed to list resources: ${error.message}`, error);
         process.exit(1);
     }
 }