stackkit 0.1.0

package/dist/cli/create.js

@@ -0,0 +1,336 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+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 validate_npm_package_name_1 = __importDefault(require("validate-npm-package-name"));
+const git_utils_1 = require("../lib/git-utils");
+const js_conversion_1 = require("../lib/conversion/js-conversion");
+const package_manager_1 = require("../lib/pm/package-manager");
+const logger_1 = require("../lib/ui/logger");
+const framework_utils_1 = require("../lib/framework/framework-utils");
+const module_discovery_1 = require("../lib/discovery/module-discovery");
+const code_generator_1 = require("../lib/generation/code-generator");
+async function createProject(projectName, options) {
+    logger_1.logger.newLine();
+    logger_1.logger.log(chalk_1.default.bold.cyan("📦 Create StackKit App"));
+    logger_1.logger.newLine();
+    const config = await getProjectConfig(projectName, options);
+    const targetDir = path_1.default.join(process.cwd(), config.projectName);
+    if (await fs_extra_1.default.pathExists(targetDir)) {
+        logger_1.logger.error(`Directory "${config.projectName}" already exists`);
+        logger_1.logger.log(chalk_1.default.gray("Please choose a different name or remove the existing directory.\n"));
+        process.exit(1);
+    }
+    await generateProject(config, targetDir, options);
+    showNextSteps(config);
+}
+async function getProjectConfig(projectName, options) {
+    // Resolve modules directory (dist first, then package root)
+    const modulesCandidates = [
+        path_1.default.join(__dirname, "..", "..", "..", "modules"),
+        path_1.default.join(__dirname, "..", "..", "..", "..", "modules"),
+    ];
+    let modulesDir;
+    for (const c of modulesCandidates) {
+        if (await fs_extra_1.default.pathExists(c)) {
+            modulesDir = c;
+            break;
+        }
+    }
+    const discoveredModules = await (0, module_discovery_1.discoverModules)(modulesDir || modulesCandidates[1]);
+    // Detect flags or `--yes` after `create`; project-name-only remains interactive
+    const argv = process.argv.slice(2);
+    const createIndex = argv.indexOf('create');
+    const argsAfterCreate = createIndex >= 0 ? argv.slice(createIndex + 1) : [];
+    const flagsProvided = argsAfterCreate.some(arg => arg.startsWith('-'));
+    const optionsProvided = flagsProvided || !!(options && (options.yes || options.y));
+    if (optionsProvided) {
+        if ((options && (options.yes || options.y))) {
+            return {
+                projectName: projectName || "my-app",
+                framework: "nextjs",
+                database: "prisma",
+                prismaProvider: "postgresql",
+                auth: "better-auth",
+                language: "typescript",
+                packageManager: "pnpm",
+            };
+        }
+        // Validate options using discovered modules (if any discovered)
+        const framework = (options && (options.framework || options.f)) || undefined;
+        if (discoveredModules.frameworks && discoveredModules.frameworks.length > 0) {
+            const validFrameworks = discoveredModules.frameworks.map(f => f.name);
+            if (framework && !validFrameworks.includes(framework)) {
+                throw new Error(`Invalid framework: ${framework}. Valid options: ${validFrameworks.join(', ')}`);
+            }
+        }
+        const db = (options && (options.database || options.d)) || undefined;
+        let allValidDatabases = [];
+        if (discoveredModules.databases && discoveredModules.databases.length > 0) {
+            const validDatabases = (0, module_discovery_1.getValidDatabaseOptions)(discoveredModules.databases);
+            // Also allow base database names like 'prisma', 'mongoose'
+            const validBaseDatabases = discoveredModules.databases.map(db => db.name);
+            allValidDatabases = [...validDatabases, ...validBaseDatabases];
+            if (db && !allValidDatabases.includes(db)) {
+                throw new Error(`Invalid database: ${db}. Valid options: ${allValidDatabases.filter((v, i, arr) => arr.indexOf(v) === i).join(', ')}`);
+            }
+        }
+        const authOpt = (options && (options.auth || options.a)) || undefined;
+        if (discoveredModules.auth && discoveredModules.auth.length > 0) {
+            const validAuth = (0, module_discovery_1.getValidAuthOptions)(discoveredModules.auth);
+            if (authOpt && !validAuth.includes(authOpt)) {
+                throw new Error(`Invalid auth: ${authOpt}. Valid options: ${validAuth.join(', ')}`);
+            }
+        }
+        const validLanguages = ['typescript', 'javascript'];
+        const language = (options && (options.language || options.l)) || undefined;
+        if (language && !validLanguages.includes(language)) {
+            throw new Error(`Invalid language: ${language}. Valid options: ${validLanguages.join(', ')}`);
+        }
+        const validPackageManagers = ['pnpm', 'npm', 'yarn', 'bun'];
+        const pm = (options && (options.packageManager || options.p)) || undefined;
+        if (pm && !validPackageManagers.includes(pm)) {
+            throw new Error(`Invalid package manager: ${pm}. Valid options: ${validPackageManagers.join(', ')}`);
+        }
+        let database = "none";
+        let prismaProvider;
+        if (db && db !== "none") {
+            const parsed = (0, module_discovery_1.parseDatabaseOption)(db);
+            database = parsed.database;
+            prismaProvider = parsed.provider;
+        }
+        let auth = "none";
+        if (authOpt && authOpt !== "none") {
+            auth = authOpt;
+        }
+        const finalFramework = (framework || "nextjs");
+        // Validate auth compatibility
+        if (auth === "authjs" && (database !== "prisma" || finalFramework !== "nextjs")) {
+            throw new Error("Auth.js is only supported with Next.js and Prisma database");
+        }
+        if (auth === "better-auth" && database === "none" && finalFramework !== "react") {
+            throw new Error("Better Auth requires a database for server frameworks");
+        }
+        return {
+            projectName: projectName || "my-app",
+            framework: finalFramework,
+            database,
+            prismaProvider,
+            auth,
+            language: (language || "typescript"),
+            packageManager: (pm || "pnpm"),
+        };
+    }
+    // Interactive prompts
+    const answers = (await inquirer_1.default.prompt([
+        {
+            type: "input",
+            name: "projectName",
+            message: "Project name:",
+            default: projectName || "my-app",
+            when: !projectName,
+            validate: (input) => {
+                const validation = (0, validate_npm_package_name_1.default)(input);
+                if (!validation.validForNewPackages) {
+                    return validation.errors?.[0] || "Invalid package name";
+                }
+                if (fs_extra_1.default.existsSync(path_1.default.join(process.cwd(), input))) {
+                    return "Directory already exists";
+                }
+                return true;
+            },
+        },
+        {
+            type: "list",
+            name: "framework",
+            message: "Select framework:",
+            choices: discoveredModules.frameworks.map(f => ({
+                name: f.displayName,
+                value: f.name
+            })),
+        },
+        {
+            type: "list",
+            name: "database",
+            message: "Select database/ORM:",
+            when: (answers) => answers.framework !== "react",
+            choices: [
+                { name: "Prisma", value: "prisma" },
+                { name: "Mongoose", value: "mongoose" },
+                { name: "None", value: "none" },
+            ],
+        },
+        {
+            type: "list",
+            name: "prismaProvider",
+            message: "Select database provider for Prisma:",
+            when: (answers) => answers.database === "prisma",
+            choices: [
+                { name: "PostgreSQL", value: "postgresql" },
+                { name: "MongoDB", value: "mongodb" },
+                { name: "MySQL", value: "mysql" },
+                { name: "SQLite", value: "sqlite" },
+            ],
+        },
+        {
+            type: "list",
+            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"),
+        },
+        {
+            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",
+        },
+    ]));
+    return {
+        projectName: (projectName || answers.projectName),
+        framework: answers.framework,
+        database: (answers.framework === "react"
+            ? "none"
+            : answers.database),
+        prismaProvider: answers.prismaProvider,
+        auth: (answers.auth || "none"),
+        language: answers.language,
+        packageManager: answers.packageManager,
+    };
+}
+async function generateProject(config, targetDir, options) {
+    const copySpinner = logger_1.logger.startSpinner("Creating project files...");
+    let postInstallCommands = [];
+    try {
+        postInstallCommands = await composeTemplate(config, targetDir);
+        copySpinner.succeed("Project files created");
+    }
+    catch (error) {
+        copySpinner.fail("Failed to create project files");
+        throw error;
+    }
+    // Install dependencies
+    if (options?.install !== false && !(options?.['skip-install'] || options?.skipInstall)) {
+        const installSpinner = logger_1.logger.startSpinner("Installing dependencies...");
+        try {
+            await (0, package_manager_1.installDependencies)(targetDir, config.packageManager);
+            installSpinner.succeed("Dependencies installed");
+        }
+        catch (error) {
+            installSpinner.fail("Failed to install dependencies");
+            throw error;
+        }
+    }
+    // Run post-install commands (skip if install was skipped)
+    if (postInstallCommands.length > 0 && options?.install !== false && !(options?.['skip-install'] || options?.skipInstall)) {
+        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" });
+            }
+            postInstallSpinner.succeed("Post-install commands completed");
+        }
+        catch (error) {
+            postInstallSpinner.fail("Failed to run post-install commands");
+            throw error;
+        }
+    }
+    // Initialize git
+    if (options?.git !== false && !(options?.['no-git'] || options?.noGit)) {
+        const gitSpinner = logger_1.logger.startSpinner("Initializing git repository...");
+        try {
+            await (0, git_utils_1.initGit)(targetDir);
+            gitSpinner.succeed("Git repository initialized");
+        }
+        catch {
+            gitSpinner.warn("Failed to initialize git repository");
+        }
+    }
+}
+async function composeTemplate(config, targetDir) {
+    // Resolve templates/modules paths
+    const templatesCandidates = [
+        path_1.default.join(__dirname, "..", "..", "..", "templates"),
+        path_1.default.join(__dirname, "..", "..", "..", "..", "templates"),
+    ];
+    const modulesCandidates2 = [
+        path_1.default.join(__dirname, "..", "..", "..", "modules"),
+        path_1.default.join(__dirname, "..", "..", "..", "..", "modules"),
+    ];
+    const templatesDir = (await (async () => { for (const c of templatesCandidates)
+        if (await fs_extra_1.default.pathExists(c))
+            return c; return templatesCandidates[1]; })());
+    const modulesDirForGenerator = (await (async () => { for (const c of modulesCandidates2)
+        if (await fs_extra_1.default.pathExists(c))
+            return c; return modulesCandidates2[1]; })());
+    await fs_extra_1.default.ensureDir(targetDir);
+    // Load framework configuration
+    const frameworkConfig = await framework_utils_1.FrameworkUtils.loadFrameworkConfig(config.framework, templatesDir);
+    // Initialize advanced code generator
+    const generator = new code_generator_1.AdvancedCodeGenerator(frameworkConfig);
+    await generator.loadGenerators(modulesDirForGenerator);
+    // Generate project using advanced code generator
+    const features = [];
+    const postInstallCommands = await generator.generate({
+        framework: config.framework,
+        database: config.database === 'none' ? undefined : config.database,
+        auth: config.auth === 'none' ? undefined : config.auth,
+        prismaProvider: config.prismaProvider,
+    }, features, targetDir);
+    // Update project name in package.json
+    const packageJsonPath = path_1.default.join(targetDir, "package.json");
+    if (await fs_extra_1.default.pathExists(packageJsonPath)) {
+        const packageJson = await fs_extra_1.default.readJson(packageJsonPath);
+        packageJson.name = config.projectName;
+        await fs_extra_1.default.writeJson(packageJsonPath, packageJson, { spaces: 2 });
+    }
+    // Ensure .env exists: if .env.example was copied from the template, create .env from it
+    try {
+        const envExamplePath = path_1.default.join(targetDir, ".env.example");
+        const envPath = path_1.default.join(targetDir, ".env");
+        if ((await fs_extra_1.default.pathExists(envExamplePath)) && !(await fs_extra_1.default.pathExists(envPath))) {
+            const envContent = await fs_extra_1.default.readFile(envExamplePath, "utf-8");
+            await fs_extra_1.default.writeFile(envPath, envContent);
+        }
+    }
+    catch {
+        // non-fatal
+    }
+    if (config.language === "javascript") {
+        await (0, js_conversion_1.convertToJavaScript)(targetDir, config.framework);
+    }
+    // For now, return empty array as post-install commands are handled by the generator
+    return postInstallCommands;
+}
+function showNextSteps(config) {
+    logger_1.logger.newLine();
+    logger_1.logger.success(`Created ${config.projectName}`);
+    logger_1.logger.newLine();
+    logger_1.logger.log("Next steps:");
+    logger_1.logger.log(`  cd ${config.projectName}`);
+    logger_1.logger.log(`  ${config.packageManager} run dev`);
+    logger_1.logger.newLine();
+}

package/dist/cli/doctor.d.ts

@@ -0,0 +1,7 @@
+interface DoctorOptions {
+    json?: boolean;
+    verbose?: boolean;
+    strict?: boolean;
+}
+export declare function doctorCommand(options: DoctorOptions): Promise<void>;
+export {};