stackkit 0.1.0

package/dist/cli/list.js

@@ -0,0 +1,123 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listCommand = listCommand;
+const chalk_1 = __importDefault(require("chalk"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const logger_1 = require("../lib/ui/logger");
+async function listCommand(options) {
+    const showFrameworks = !options.modules || options.frameworks;
+    const showModules = !options.frameworks || options.modules;
+    try {
+        logger_1.logger.header("StackKit Resources");
+        logger_1.logger.newLine();
+        let hasFrameworks = false;
+        let hasModules = false;
+        if (showFrameworks) {
+            const templatesDir = path_1.default.join(__dirname, "..", "..", "..", "..", "templates");
+            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();
+            }
+        }
+        // List modules
+        if (showModules) {
+            const modulesDir = path_1.default.join(__dirname, "..", "..", "..", "modules");
+            const modules = await getAvailableModules(modulesDir);
+            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]) {
+                        acc[mod.category] = [];
+                    }
+                    acc[mod.category].push(mod);
+                    return acc;
+                }, {});
+                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 getAvailableFrameworks(templatesDir) {
+    if (!(await fs_extra_1.default.pathExists(templatesDir))) {
+        return [];
+    }
+    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))) {
+        return [];
+    }
+    const modules = [];
+    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 metadataPath = path_1.default.join(categoryPath, moduleDir, "module.json");
+            if (await fs_extra_1.default.pathExists(metadataPath)) {
+                const metadata = await fs_extra_1.default.readJSON(metadataPath);
+                modules.push(metadata);
+            }
+        }
+    }
+    return modules;
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,91 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const create_1 = require("./cli/create");
+const add_1 = require("./cli/add");
+const doctor_1 = require("./cli/doctor");
+const list_1 = require("./cli/list");
+const logger_1 = require("./lib/ui/logger");
+const program = new commander_1.Command();
+program
+    .name("stackkit")
+    .description("CLI for creating and managing StackKit projects")
+    .version("0.1.0");
+// Create command
+program
+    .command("create [project-name]")
+    .description("Create a new StackKit project")
+    .option("-f, --framework <framework>", "Framework: nextjs, express, react")
+    .option("-d, --database <database>", "Database: prisma, mongoose, none")
+    .option("--prisma-provider <provider>", "Prisma provider: postgresql, mongodb, mysql, sqlite")
+    .option("-a, --auth <auth>", "Auth: better-auth, authjs, none")
+    .option("-l, --language <language>", "Language: typescript, javascript")
+    .option("-p, --package-manager <pm>", "Package manager: pnpm, npm, yarn, bun")
+    .option("--skip-install", "Skip dependency installation")
+    .option("--no-git", "Skip git initialization")
+    .option("-y, --yes", "Use default options")
+    .action(async (projectName, options) => {
+    try {
+        await (0, create_1.createProject)(projectName, options);
+    }
+    catch (error) {
+        logger_1.logger.error(`Error: ${error.message}`);
+        process.exit(1);
+    }
+});
+// Add command
+program
+    .command("add <module>")
+    .description("Add a module to your existing project")
+    .option("--provider <provider>", "Specific provider/variant to use")
+    .option("--force", "Overwrite existing files")
+    .option("--dry-run", "Show what would be changed without making changes")
+    .option("--no-install", "Skip installing dependencies")
+    .action(async (module, options) => {
+    try {
+        await (0, add_1.addCommand)(module, options);
+    }
+    catch (error) {
+        logger_1.logger.error(`Error: ${error.message}`);
+        process.exit(1);
+    }
+});
+// 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(async (options) => {
+    try {
+        await (0, doctor_1.doctorCommand)(options);
+    }
+    catch (error) {
+        logger_1.logger.error(`Error: ${error.message}`);
+        process.exit(1);
+    }
+});
+// List command
+program
+    .command("list")
+    .description("List available frameworks and modules")
+    .option("-f, --frameworks", "List only frameworks")
+    .option("-m, --modules", "List only modules")
+    .action(async (options) => {
+    try {
+        await (0, list_1.listCommand)(options);
+    }
+    catch (error) {
+        logger_1.logger.error(`Error: ${error.message}`);
+        process.exit(1);
+    }
+});
+// Error handling
+program.on("command:*", () => {
+    logger_1.logger.error(`Invalid command: ${program.args.join(" ")}`);
+    logger_1.logger.log("Run stackkit --help for a list of available commands.");
+    process.exit(1);
+});
+program.parse();

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

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

package/dist/lib/conversion/js-conversion.js

@@ -0,0 +1,244 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertToJavaScript = convertToJavaScript;
+/* eslint-disable @typescript-eslint/no-require-imports */
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const baseDirs = {
+    express: "./src",
+    "react": "./src",
+    nextjs: ".",
+};
+async function convertToJavaScript(targetDir, framework) {
+    const tsFiles = [
+        "tsconfig.json",
+        "tsconfig.app.json",
+        "tsconfig.node.json",
+        "next-env.d.ts",
+        "vite-env.d.ts",
+    ];
+    for (const file of tsFiles) {
+        const filePath = path_1.default.join(targetDir, file);
+        if (await fs_extra_1.default.pathExists(filePath)) {
+            await fs_extra_1.default.remove(filePath);
+        }
+    }
+    const removeDtsFiles = async (dir) => {
+        const entries = await fs_extra_1.default.readdir(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path_1.default.join(dir, entry.name);
+            if (entry.isDirectory() && entry.name !== "node_modules") {
+                await removeDtsFiles(fullPath);
+            }
+            else if (entry.isFile() && entry.name.endsWith(".d.ts")) {
+                await fs_extra_1.default.remove(fullPath);
+            }
+        }
+    };
+    await removeDtsFiles(targetDir);
+    const babel = require("@babel/core");
+    const transpileAllTsFiles = async (dir) => {
+        const entries = await fs_extra_1.default.readdir(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path_1.default.join(dir, entry.name);
+            if (entry.isDirectory() && entry.name !== "node_modules") {
+                await transpileAllTsFiles(fullPath);
+            }
+            else if (entry.isFile()) {
+                if (entry.name.endsWith(".ts") || entry.name.endsWith(".tsx")) {
+                    const code = await fs_extra_1.default.readFile(fullPath, "utf8");
+                    const isTsx = entry.name.endsWith(".tsx");
+                    const outFile = fullPath.replace(/\.tsx$/, ".jsx").replace(/\.ts$/, ".js");
+                    const presets = [
+                        [
+                            require.resolve("@babel/preset-typescript"),
+                            {
+                                onlyRemoveTypeImports: true,
+                                allowDeclareFields: true,
+                                allowNamespaces: true,
+                                optimizeForSpeed: true,
+                                allExtensions: true,
+                                isTSX: isTsx,
+                            },
+                        ],
+                        [
+                            require.resolve("@babel/preset-env"),
+                            {
+                                targets: { node: "18" },
+                                modules: false,
+                            },
+                        ],
+                    ];
+                    if (isTsx) {
+                        presets.push([
+                            require.resolve("@babel/preset-react"),
+                            {
+                                runtime: "classic",
+                            },
+                        ]);
+                    }
+                    // Use recast + Babel AST transform (same approach as transform.tools)
+                    try {
+                        const recast = require("recast");
+                        const { transformFromAstSync } = require("@babel/core");
+                        const transformTypescript = require("@babel/plugin-transform-typescript");
+                        // getBabelOptions may be exported as default or directly
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                        let getBabelOptions = require("recast/parsers/_babel_options");
+                        if (getBabelOptions && getBabelOptions.default)
+                            getBabelOptions = getBabelOptions.default;
+                        const babelParser = require("recast/parsers/babel").parser;
+                        const ast = recast.parse(code, {
+                            parser: {
+                                parse: (source, options) => {
+                                    const babelOptions = getBabelOptions(options || {});
+                                    // ensure typescript and jsx handling
+                                    if (isTsx) {
+                                        babelOptions.plugins.push("typescript", "jsx");
+                                    }
+                                    else {
+                                        babelOptions.plugins.push("typescript");
+                                    }
+                                    return babelParser.parse(source, babelOptions);
+                                },
+                            },
+                        });
+                        const opts = {
+                            cloneInputAst: false,
+                            code: false,
+                            ast: true,
+                            plugins: [transformTypescript],
+                            configFile: false,
+                        };
+                        const { ast: transformedAST } = transformFromAstSync(ast, code, opts);
+                        const resultCode = recast.print(transformedAST).code;
+                        await fs_extra_1.default.writeFile(outFile, resultCode, "utf8");
+                        await fs_extra_1.default.remove(fullPath);
+                        continue;
+                    }
+                    catch {
+                        // ignore recast errors, fall back to babel
+                    }
+                    const result = await babel.transformAsync(code, {
+                        filename: entry.name,
+                        presets,
+                        comments: true,
+                        retainLines: true,
+                        compact: false,
+                        babelrc: false,
+                        configFile: false,
+                    });
+                    await fs_extra_1.default.writeFile(outFile, result.code, "utf8");
+                    await fs_extra_1.default.remove(fullPath);
+                }
+            }
+        }
+    };
+    await transpileAllTsFiles(targetDir);
+    const baseDir = baseDirs[framework];
+    if (baseDir) {
+        const replaceAliases = async (dir) => {
+            const entries = await fs_extra_1.default.readdir(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                const full = path_1.default.join(dir, entry.name);
+                if (entry.isDirectory() && entry.name !== "node_modules") {
+                    await replaceAliases(full);
+                }
+                else if (entry.isFile() && (entry.name.endsWith(".js") || entry.name.endsWith(".jsx"))) {
+                    const content = await fs_extra_1.default.readFile(full, "utf-8");
+                    if (content.includes("@/")) {
+                        const fileDir = path_1.default.dirname(full);
+                        const newContent = content.replace(/from ['"]@\/([^'"]*)['"]/g, (match, p1) => {
+                            const resolved = path_1.default.resolve(baseDir, p1);
+                            let relPath = path_1.default.relative(fileDir, resolved);
+                            if (!relPath.startsWith("."))
+                                relPath = "./" + relPath;
+                            return `from '${relPath}'`;
+                        });
+                        await fs_extra_1.default.writeFile(full, newContent, "utf-8");
+                    }
+                }
+            }
+        };
+        await replaceAliases(targetDir);
+    }
+    const templatesRoot = path_1.default.join(__dirname, "..", "..", "..", "templates");
+    const templateName = framework;
+    let fileReplacements = [];
+    let jsScripts = null;
+    if (templateName) {
+        const templateJsonPath = path_1.default.join(templatesRoot, templateName, "template.json");
+        if (await fs_extra_1.default.pathExists(templateJsonPath)) {
+            try {
+                const templateJson = await fs_extra_1.default.readJson(templateJsonPath);
+                if (Array.isArray(templateJson.fileReplacements)) {
+                    fileReplacements = templateJson.fileReplacements;
+                }
+                if (templateJson.jsScripts) {
+                    jsScripts = templateJson.jsScripts;
+                }
+            }
+            catch {
+                // ignore errors reading template.json
+            }
+        }
+    }
+    for (const rep of fileReplacements) {
+        const filePath = path_1.default.join(targetDir, rep.file);
+        if (await fs_extra_1.default.pathExists(filePath)) {
+            let content = await fs_extra_1.default.readFile(filePath, "utf8");
+            if (rep.from && rep.to) {
+                content = content.replace(rep.from, rep.to);
+                await fs_extra_1.default.writeFile(filePath, content, "utf8");
+            }
+        }
+    }
+    if (jsScripts) {
+        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.scripts = { ...packageJson.scripts, ...jsScripts };
+            await fs_extra_1.default.writeJson(packageJsonPath, packageJson, { spaces: 2 });
+        }
+    }
+    const jsconfig = path_1.default.join(targetDir, "jsconfig.json");
+    if (!(await fs_extra_1.default.pathExists(jsconfig))) {
+        for (const tmpl of await fs_extra_1.default.readdir(templatesRoot, { withFileTypes: true })) {
+            if (tmpl.isDirectory()) {
+                const templateJsconfig = path_1.default.join(templatesRoot, tmpl.name, "jsconfig.json");
+                if (await fs_extra_1.default.pathExists(templateJsconfig)) {
+                    await fs_extra_1.default.copy(templateJsconfig, jsconfig);
+                    break;
+                }
+            }
+        }
+    }
+    const srcDir = path_1.default.join(targetDir, "src");
+    if (await fs_extra_1.default.pathExists(srcDir)) {
+        const srcFiles = await fs_extra_1.default.readdir(srcDir);
+        for (const file of srcFiles) {
+            if ((file.endsWith(".js") || file.endsWith(".jsx")) &&
+                file.replace(/\.(js|jsx)$/, ".ts") &&
+                srcFiles.includes(file.replace(/\.(js|jsx)$/, ".ts"))) {
+                await fs_extra_1.default.remove(path_1.default.join(srcDir, file.replace(/\.(js|jsx)$/, ".ts")));
+            }
+            if (file.endsWith(".jsx") && srcFiles.includes(file.replace(/\.jsx$/, ".tsx"))) {
+                await fs_extra_1.default.remove(path_1.default.join(srcDir, file.replace(/\.jsx$/, ".tsx")));
+            }
+        }
+    }
+    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);
+        if (packageJson.devDependencies) {
+            delete packageJson.devDependencies["typescript"];
+            delete packageJson.devDependencies["@types/node"];
+            delete packageJson.devDependencies["@types/react"];
+            delete packageJson.devDependencies["@types/react-dom"];
+        }
+        await fs_extra_1.default.writeJson(packageJsonPath, packageJson, { spaces: 2 });
+    }
+}

package/dist/lib/database/database-config.d.ts

@@ -0,0 +1,6 @@
+export declare const DATABASE_CONNECTION_STRINGS: {
+    readonly postgresql: "postgresql://user:password@localhost:5432/mydb?schema=public";
+    readonly mongodb: "mongodb://localhost:27017/mydb";
+    readonly mysql: "mysql://user:password@localhost:3306/mydb";
+    readonly sqlite: "file:./dev.db";
+};

package/dist/lib/database/database-config.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DATABASE_CONNECTION_STRINGS = void 0;
+exports.DATABASE_CONNECTION_STRINGS = {
+    postgresql: "postgresql://user:password@localhost:5432/mydb?schema=public",
+    mongodb: "mongodb://localhost:27017/mydb",
+    mysql: "mysql://user:password@localhost:3306/mydb",
+    sqlite: "file:./dev.db",
+};

package/dist/lib/discovery/module-discovery.d.ts

@@ -0,0 +1,62 @@
+export interface ModuleMetadata {
+    name: string;
+    displayName: string;
+    description: string;
+    category: string;
+    provider?: string;
+    supportedFrameworks?: string[];
+    databaseAdapters?: Record<string, unknown>;
+    frameworkConfigs?: Record<string, unknown>;
+    dependencies?: Record<string, unknown>;
+    devDependencies?: Record<string, unknown>;
+    envVars?: Record<string, unknown>;
+    patches?: unknown[];
+    postInstall?: string[];
+    compatibility?: {
+        databases?: string[];
+        auth?: string[];
+        languages?: string[];
+    };
+    framework?: string;
+    files?: string[];
+    scripts?: Record<string, string>;
+    jsScripts?: Record<string, string>;
+}
+export interface DiscoveredModules {
+    frameworks: ModuleMetadata[];
+    databases: ModuleMetadata[];
+    auth: ModuleMetadata[];
+}
+/**
+ * Discover all available modules from the modules directory
+ */
+export declare function discoverModules(modulesDir: string): Promise<DiscoveredModules>;
+/**
+ * Get valid database options for CLI
+ */
+export declare function getValidDatabaseOptions(databases: ModuleMetadata[]): string[];
+/**
+ * Get valid auth options for CLI
+ */
+export declare function getValidAuthOptions(authModules: ModuleMetadata[]): string[];
+/**
+ * Parse database option into database name and provider
+ */
+export declare function parseDatabaseOption(dbOption: string): {
+    database: string;
+    provider?: string;
+};
+/**
+ * Get compatible auth options for given framework and database
+ */
+export declare function getCompatibleAuthOptions(authModules: ModuleMetadata[], framework: string, database: string): Array<{
+    name: string;
+    value: string;
+}>;
+/**
+ * Get database choices for inquirer prompts
+ */
+export declare function getDatabaseChoices(databases: ModuleMetadata[], framework: string): Array<{
+    name: string;
+    value: string;
+}>;