stackkit 0.1.0

package/dist/lib/discovery/module-discovery.js

@@ -0,0 +1,188 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.discoverModules = discoverModules;
+exports.getValidDatabaseOptions = getValidDatabaseOptions;
+exports.getValidAuthOptions = getValidAuthOptions;
+exports.parseDatabaseOption = parseDatabaseOption;
+exports.getCompatibleAuthOptions = getCompatibleAuthOptions;
+exports.getDatabaseChoices = getDatabaseChoices;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+/**
+ * Discover all available modules from the modules directory
+ */
+async function discoverModules(modulesDir) {
+    const discovered = {
+        frameworks: [],
+        databases: [],
+        auth: [],
+    };
+    if (!(await fs_extra_1.default.pathExists(modulesDir))) {
+        return discovered;
+    }
+    // Discover frameworks from templates directory
+    const templatesDir = path_1.default.join(modulesDir, '..', 'templates');
+    if (await fs_extra_1.default.pathExists(templatesDir)) {
+        const frameworkDirs = await fs_extra_1.default.readdir(templatesDir);
+        for (const frameworkName of frameworkDirs) {
+            const templateJsonPath = path_1.default.join(templatesDir, frameworkName, 'template.json');
+            if (await fs_extra_1.default.pathExists(templateJsonPath)) {
+                try {
+                    const templateConfig = await fs_extra_1.default.readJson(templateJsonPath);
+                    discovered.frameworks.push({
+                        ...templateConfig,
+                        name: frameworkName,
+                        category: 'framework',
+                    });
+                }
+                catch {
+                    // Silently skip invalid templates
+                }
+            }
+        }
+    }
+    // Discover database modules
+    const databaseDir = path_1.default.join(modulesDir, 'database');
+    if (await fs_extra_1.default.pathExists(databaseDir)) {
+        const dbModules = await fs_extra_1.default.readdir(databaseDir);
+        // Sort to ensure consistent order: prisma first, then others
+        dbModules.sort((a, b) => {
+            if (a === 'prisma')
+                return -1;
+            if (b === 'prisma')
+                return 1;
+            return a.localeCompare(b);
+        });
+        for (const moduleName of dbModules) {
+            const modulePath = path_1.default.join(databaseDir, moduleName);
+            const moduleJsonPath = path_1.default.join(modulePath, 'module.json');
+            if (await fs_extra_1.default.pathExists(moduleJsonPath)) {
+                try {
+                    const metadata = await fs_extra_1.default.readJson(moduleJsonPath);
+                    discovered.databases.push(metadata);
+                }
+                catch {
+                    // Silently skip invalid modules
+                }
+            }
+        }
+    }
+    // Discover auth modules
+    const authDir = path_1.default.join(modulesDir, 'auth');
+    if (await fs_extra_1.default.pathExists(authDir)) {
+        const authModules = await fs_extra_1.default.readdir(authDir);
+        for (const moduleName of authModules) {
+            const modulePath = path_1.default.join(authDir, moduleName);
+            const moduleJsonPath = path_1.default.join(modulePath, 'module.json');
+            if (await fs_extra_1.default.pathExists(moduleJsonPath)) {
+                try {
+                    const metadata = await fs_extra_1.default.readJson(moduleJsonPath);
+                    discovered.auth.push(metadata);
+                }
+                catch {
+                    // Silently skip invalid modules
+                }
+            }
+        }
+    }
+    return discovered;
+}
+/**
+ * Get valid database options for CLI
+ */
+function getValidDatabaseOptions(databases) {
+    const options = ['none'];
+    for (const db of databases) {
+        if (db.name === 'prisma') {
+            // For Prisma, add provider-specific options
+            options.push('prisma-postgresql', 'prisma-mongodb', 'prisma-mysql', 'prisma-sqlite');
+        }
+        else if (db.name === 'mongoose') {
+            options.push('mongoose-mongodb', 'mongoose');
+        }
+        else {
+            // For other databases, add the name directly
+            options.push(db.name);
+        }
+    }
+    return options;
+}
+/**
+ * Get valid auth options for CLI
+ */
+function getValidAuthOptions(authModules) {
+    const options = ['none'];
+    for (const auth of authModules) {
+        options.push(auth.name);
+    }
+    return options;
+}
+/**
+ * Parse database option into database name and provider
+ */
+function parseDatabaseOption(dbOption) {
+    if (dbOption === 'none') {
+        return { database: 'none' };
+    }
+    if (dbOption.startsWith('prisma-')) {
+        const provider = dbOption.split('-')[1];
+        return { database: 'prisma', provider };
+    }
+    if (dbOption === 'mongoose-mongodb' || dbOption === 'mongoose') {
+        return { database: 'mongoose' };
+    }
+    return { database: dbOption };
+}
+/**
+ * Get compatible auth options for given framework and database
+ */
+function getCompatibleAuthOptions(authModules, framework, database) {
+    const compatible = [];
+    for (const auth of authModules) {
+        // Check if auth supports the framework
+        if (auth.supportedFrameworks && !auth.supportedFrameworks.includes(framework)) {
+            continue;
+        }
+        // Special compatibility rules
+        if (auth.name === 'authjs' && (database !== 'prisma' || framework !== 'nextjs')) {
+            continue;
+        }
+        if (auth.name === 'better-auth' && database === 'none' && framework !== 'react') {
+            continue;
+        }
+        compatible.push({
+            name: auth.displayName,
+            value: auth.name
+        });
+    }
+    // Add "None" at the end
+    compatible.push({ name: 'None', value: 'none' });
+    return compatible;
+}
+/**
+ * Get database choices for inquirer prompts
+ */
+function getDatabaseChoices(databases, framework) {
+    const choices = [];
+    for (const db of databases) {
+        // Check framework compatibility
+        if (db.supportedFrameworks && !db.supportedFrameworks.includes(framework)) {
+            continue;
+        }
+        if (db.name === 'prisma') {
+            choices.push({ name: 'Prisma (PostgreSQL)', value: 'prisma-postgresql' }, { name: 'Prisma (MongoDB)', value: 'prisma-mongodb' }, { name: 'Prisma (MySQL)', value: 'prisma-mysql' }, { name: 'Prisma (SQLite)', value: 'prisma-sqlite' });
+        }
+        else if (db.name === 'mongoose') {
+            choices.push({ name: 'Mongoose (MongoDB)', value: 'mongoose-mongodb' });
+        }
+        else {
+            choices.push({ name: db.displayName, value: db.name });
+        }
+    }
+    // Add "None" at the end
+    choices.push({ name: 'None', value: 'none' });
+    return choices;
+}

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

@@ -0,0 +1,9 @@
+export interface EnvVariable {
+    key: string;
+    value?: string;
+    required: boolean;
+}
+export declare function addEnvVariables(projectRoot: string, variables: EnvVariable[], options?: {
+    force?: boolean;
+}): Promise<void>;
+export declare function removeEnvVariables(projectRoot: string, keys: string[]): Promise<void>;

package/dist/lib/env/env-editor.js

@@ -0,0 +1,116 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addEnvVariables = addEnvVariables;
+exports.removeEnvVariables = removeEnvVariables;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const logger_1 = require("../ui/logger");
+const ENV_MARKER_START = "# StackKit:";
+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");
+    await appendToEnvFile(envExamplePath, variables, "example", options);
+    const envExists = await fs_extra_1.default.pathExists(envPath);
+    if (envExists || options.force) {
+        await appendToEnvFile(envPath, variables, "local", 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");
+    }
+    // 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) {
+        const match = line.match(/^([A-Z_][A-Z0-9_]*)=/);
+        if (match) {
+            existingKeys.add(match[1]);
+        }
+    }
+    const newVariables = variables.filter((v) => !existingKeys.has(v.key));
+    if (newVariables.length === 0) {
+        return;
+    }
+    // Ensure file ends with newline
+    if (content && !content.endsWith("\n")) {
+        content += "\n";
+    }
+    // Add marker and variables
+    content += "\n";
+    content += `${ENV_MARKER_START} Added by StackKit\n`;
+    for (const variable of newVariables) {
+        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) {
+    const envExamplePath = path_1.default.join(projectRoot, ".env.example");
+    const envPath = path_1.default.join(projectRoot, ".env");
+    await removeFromEnvFile(envExamplePath, keys);
+    if (await fs_extra_1.default.pathExists(envPath)) {
+        await removeFromEnvFile(envPath, keys);
+    }
+}
+async function removeFromEnvFile(filePath, keys) {
+    if (!(await fs_extra_1.default.pathExists(filePath))) {
+        return;
+    }
+    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);
+            }
+        }
+        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;
+    }
+}

package/dist/lib/framework/framework-utils.d.ts

@@ -0,0 +1,22 @@
+export interface FrameworkConfig {
+    name: string;
+    displayName: string;
+    compatibility: {
+        databases: string[];
+        auth: string[];
+    };
+}
+export interface ModuleConfig {
+    name: string;
+    displayName: string;
+    type: 'database' | 'auth';
+    compatibility?: {
+        frameworks?: string[];
+        databases?: string[];
+    };
+}
+export declare class FrameworkUtils {
+    private static frameworkConfigs;
+    static loadFrameworkConfig(frameworkName: string, templatesDir: string): Promise<FrameworkConfig>;
+    static isCompatible(framework: string, database?: string, auth?: string): boolean;
+}

package/dist/lib/framework/framework-utils.js

@@ -0,0 +1,74 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FrameworkUtils = void 0;
+const fs = __importStar(require("fs-extra"));
+const path = __importStar(require("path"));
+// eslint-disable-next-line @typescript-eslint/no-extraneous-class
+class FrameworkUtils {
+    static async loadFrameworkConfig(frameworkName, templatesDir) {
+        const configPath = path.join(templatesDir, frameworkName, 'template.json');
+        if (await fs.pathExists(configPath)) {
+            const config = await fs.readJson(configPath);
+            this.frameworkConfigs.set(frameworkName, config);
+            return config;
+        }
+        // Default config if no template.json exists
+        const defaultConfig = {
+            name: frameworkName,
+            displayName: frameworkName.charAt(0).toUpperCase() + frameworkName.slice(1),
+            compatibility: {
+                databases: ['prisma', 'mongoose'],
+                auth: ['better-auth', 'authjs'],
+            },
+        };
+        this.frameworkConfigs.set(frameworkName, defaultConfig);
+        return defaultConfig;
+    }
+    static isCompatible(framework, database, auth) {
+        const config = this.frameworkConfigs.get(framework);
+        if (!config)
+            return true; // Assume compatible if no config
+        if (database && !config.compatibility.databases.includes(database)) {
+            return false;
+        }
+        if (auth && !config.compatibility.auth.includes(auth)) {
+            return false;
+        }
+        return true;
+    }
+}
+exports.FrameworkUtils = FrameworkUtils;
+FrameworkUtils.frameworkConfigs = new Map();

package/dist/lib/fs/files.d.ts

@@ -0,0 +1,14 @@
+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;
+}): Promise<void>;
+export declare function readFile(filePath: string): Promise<string>;
+export declare function fileExists(filePath: string): Promise<boolean>;

package/dist/lib/fs/files.js

@@ -0,0 +1,101 @@
+"use strict";
+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;
+exports.fileExists = fileExists;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const logger_1 = require("../ui/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}`);
+    }
+    // Create target directory
+    await fs_extra_1.default.ensureDir(targetPath);
+    // Copy all files
+    await fs_extra_1.default.copy(templatePath, targetPath, {
+        filter: (src) => {
+            const basename = path_1.default.basename(src);
+            // Skip template.json metadata file and node_modules
+            return basename !== "template.json" && basename !== "node_modules";
+        },
+    });
+    // Update package.json with project name
+    const packageJsonPath = path_1.default.join(targetPath, "package.json");
+    if (await fs_extra_1.default.pathExists(packageJsonPath)) {
+        const packageJson = await fs_extra_1.default.readJSON(packageJsonPath);
+        packageJson.name = projectName;
+        await fs_extra_1.default.writeJSON(packageJsonPath, packageJson, { spaces: 2 });
+    }
+    logger_1.logger.success(`Template copied to ${targetPath}`);
+}
+async function createFile(targetPath, content, options = {}) {
+    const exists = await fs_extra_1.default.pathExists(targetPath);
+    if (exists && !options.force) {
+        logger_1.logger.warn(`File already exists: ${targetPath} (use --force to overwrite)`);
+        return;
+    }
+    await fs_extra_1.default.ensureDir(path_1.default.dirname(targetPath));
+    await fs_extra_1.default.writeFile(targetPath, content, "utf-8");
+}
+async function readFile(filePath) {
+    return fs_extra_1.default.readFile(filePath, "utf-8");
+}
+async function fileExists(filePath) {
+    return fs_extra_1.default.pathExists(filePath);
+}

package/dist/lib/generation/code-generator.d.ts

@@ -0,0 +1,83 @@
+import { FrameworkConfig } from '../framework/framework-utils';
+export interface GenerationContext {
+    framework: string;
+    database?: string;
+    auth?: string;
+    features?: string[];
+    [key: string]: unknown;
+}
+export interface TemplateCondition {
+    framework?: string | string[];
+    database?: string | string[];
+    auth?: string | string[];
+    features?: string[];
+}
+export interface Operation {
+    type: 'create-file' | 'patch-file' | 'add-dependency' | 'add-script' | 'add-env' | 'run-command';
+    description?: string;
+    condition?: TemplateCondition;
+    priority?: number;
+    source?: string;
+    destination?: string;
+    content?: string;
+    operations?: PatchOperation[];
+    dependencies?: Record<string, string>;
+    devDependencies?: Record<string, string>;
+    scripts?: Record<string, string>;
+    envVars?: Record<string, string>;
+    command?: string;
+}
+export interface PatchOperation {
+    type: 'add-import' | 'add-code' | 'replace-code' | 'add-to-top' | 'add-to-bottom';
+    condition?: TemplateCondition;
+    imports?: string[];
+    code?: string;
+    after?: string;
+    before?: string;
+    replace?: string;
+    content?: string;
+    source?: string;
+}
+export interface GeneratorConfig {
+    name: string;
+    type: 'framework' | 'database' | 'auth';
+    priority: number;
+    operations?: Operation[];
+    dependencies?: Record<string, string>;
+    devDependencies?: Record<string, string>;
+    scripts?: Record<string, string>;
+    envVars?: Record<string, string>;
+    postInstall?: string[];
+}
+export declare class AdvancedCodeGenerator {
+    private generators;
+    private frameworkConfig;
+    private postInstallCommands;
+    constructor(frameworkConfig: FrameworkConfig);
+    loadGenerators(modulesPath: string): Promise<void>;
+    private evaluateCondition;
+    private processTemplate;
+    private processVariableDefinitions;
+    private processTemplateRecursive;
+    generate(selectedModules: {
+        framework: string;
+        database?: string;
+        auth?: string;
+        prismaProvider?: string;
+    }, features: string[], outputPath: string): Promise<string[]>;
+    private executeOperation;
+    private copyTemplate;
+    private processOperationTemplates;
+    private executeCreateFile;
+    private executePatchFile;
+    private executeAddDependency;
+    private executeAddScript;
+    private executeAddEnv;
+    private executeRunCommand;
+    private generatePackageJson;
+    getAvailableGenerators(): {
+        frameworks: string[];
+        databases: string[];
+        auths: string[];
+    };
+}