stackkit 0.1.7 → 0.1.8

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

@@ -8,8 +8,6 @@ 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");
@@ -59,14 +57,11 @@ async function appendToEnvFile(filePath, variables, fileType, options = {}) {
     if (content && !content.endsWith("\n")) {
         content += "\n";
     }
-    // Add marker and variables
-    content += "\n";
-    content += `${ENV_MARKER_START} Added by StackKit\n`;
+    // Append variables
     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");
 }
@@ -86,23 +81,12 @@ async function removeFromEnvFile(filePath, keys) {
         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);
-            }
+            newLines.push(line);
         }
         while (newLines.length > 0 && newLines[newLines.length - 1].trim() === "") {
             newLines.pop();

package/dist/lib/generation/code-generator.js

@@ -214,14 +214,14 @@ class AdvancedCodeGenerator {
                 const [, caseValue, caseContent] = caseMatch;
                 const cleanCaseValue = caseValue.trim().replace(/['"]/g, "");
                 if (cleanCaseValue === "default") {
-                    defaultCase = caseContent;
+                    defaultCase = caseContent.trim();
                 }
                 else if (actualVal === cleanCaseValue) {
-                    result = caseContent;
+                    result = caseContent.trim();
                     break;
                 }
             }
-            return result || defaultCase || "";
+            return (result || defaultCase || "").trim();
         });
         // Handle variable replacement with advanced expressions
         content = content.replace(/\{\{([^}]+)\}\}/g, (match, varExpr) => {
@@ -378,6 +378,18 @@ class AdvancedCodeGenerator {
                         !relativePath.startsWith("node_modules/"));
                 },
             });
+            // If template provides a .env.example, create a .env from it when
+            // the target project does not already have a .env file.
+            try {
+                const envExampleSrc = path.join(templatePath, ".env.example");
+                const envDest = path.join(outputPath, ".env");
+                if ((await fs.pathExists(envExampleSrc)) && !(await fs.pathExists(envDest))) {
+                    await fs.copy(envExampleSrc, envDest);
+                }
+            }
+            catch {
+                // ignore failures here — not critical
+            }
         }
     }
     processOperationTemplates(operation, context) {
@@ -469,34 +481,107 @@ class AdvancedCodeGenerator {
                 switch (patchOp.type) {
                     case "add-import":
                         if (patchOp.imports) {
+                            // Process imports and trim any accidental surrounding blank lines
                             const imports = patchOp.imports
                                 .map((imp) => this.processTemplate(imp, context))
-                                .join("\n");
-                            // Add imports at the top, after existing imports
+                                .join("\n")
+                                .replace(/^\n+/, "")
+                                .replace(/\n+$/, "");
+                            // Add imports at the top, after existing imports without introducing
+                            // extra blank lines.
                             const lines = content.split("\n");
-                            let insertIndex = 0;
+                            // Find the last import line index
+                            let lastImportIndex = -1;
                             for (let i = 0; i < lines.length; i++) {
-                                if (lines[i].trim().startsWith("import") || lines[i].trim() === "") {
-                                    insertIndex = i + 1;
+                                if (lines[i].trim().startsWith("import"))
+                                    lastImportIndex = i;
+                            }
+                            // Insert right after the last import. If there's a blank line
+                            // immediately after the imports, overwrite that blank line to
+                            // avoid introducing an extra empty line above the inserted imports.
+                            const insertIndex = lastImportIndex === -1 ? 0 : lastImportIndex + 1;
+                            // Only add imports that don't already exist in the file
+                            const importLines = imports
+                                .split("\n")
+                                .map((l) => l.trim())
+                                .filter(Boolean);
+                            const newImportLines = importLines.filter((imp) => !lines.some((ln) => ln.trim() === imp));
+                            if (newImportLines.length > 0) {
+                                // Insert imports
+                                if (insertIndex < lines.length && lines[insertIndex].trim() === "") {
+                                    lines.splice(insertIndex, 1, ...newImportLines);
                                 }
                                 else {
-                                    break;
+                                    lines.splice(insertIndex, 0, ...newImportLines);
+                                }
+                                // After insertion, ensure exactly one blank line after the import block
+                                // Find last import line index again
+                                let lastIdx = -1;
+                                for (let i = 0; i < lines.length; i++) {
+                                    if (lines[i].trim().startsWith("import"))
+                                        lastIdx = i;
+                                }
+                                const nextIdx = lastIdx + 1;
+                                if (lastIdx !== -1) {
+                                    // Remove multiple blank lines after imports
+                                    let j = nextIdx;
+                                    while (j < lines.length && lines[j].trim() === "") {
+                                        j++;
+                                    }
+                                    // Ensure exactly one blank line after imports unless imports end at EOF
+                                    if (nextIdx < lines.length) {
+                                        lines.splice(nextIdx, j - nextIdx, "");
+                                    }
                                 }
                             }
-                            lines.splice(insertIndex, 0, imports);
                             content = lines.join("\n");
                         }
                         break;
                     case "add-code":
-                        if (patchOp.code && patchOp.after) {
+                        if (patchOp.code) {
                             const processedCode = this.processTemplate(patchOp.code, context);
-                            const afterPattern = this.processTemplate(patchOp.after, context);
-                            const index = content.indexOf(afterPattern);
-                            if (index !== -1) {
-                                content =
-                                    content.slice(0, index + afterPattern.length) +
-                                        processedCode +
-                                        content.slice(index + afterPattern.length);
+                            // Skip insertion if the exact code already exists in the file
+                            const codeTrimmed = processedCode.trim();
+                            if (codeTrimmed && content.includes(codeTrimmed)) {
+                                break;
+                            }
+                            // Insert after pattern if provided
+                            if (patchOp.after) {
+                                const afterPattern = this.processTemplate(patchOp.after, context);
+                                const index = content.indexOf(afterPattern);
+                                if (index !== -1) {
+                                    const left = content.slice(0, index + afterPattern.length);
+                                    const right = content.slice(index + afterPattern.length);
+                                    // Normalize code: trim surrounding newlines and ensure single trailing newline
+                                    let codeNormalized = processedCode.replace(/^\n+|\n+$/g, "") + "\n";
+                                    // If right already starts with a newline, avoid double-blank by
+                                    // removing trailing newline from codeNormalized so only one newline remains
+                                    const rightStartsWithNewline = right.startsWith("\n");
+                                    if (rightStartsWithNewline && codeNormalized.endsWith("\n")) {
+                                        codeNormalized = codeNormalized.replace(/\n+$/, "");
+                                    }
+                                    const leftNeedsNewline = !left.endsWith("\n");
+                                    content = left + (leftNeedsNewline ? "\n" : "") + codeNormalized + right;
+                                }
+                            }
+                            // Insert before pattern if provided
+                            if (patchOp.before) {
+                                const beforePattern = this.processTemplate(patchOp.before, context);
+                                const index = content.indexOf(beforePattern);
+                                if (index !== -1) {
+                                    const left = content.slice(0, index);
+                                    const right = content.slice(index);
+                                    // Normalize code: trim surrounding newlines and ensure single trailing newline
+                                    let codeNormalized = processedCode.replace(/^\n+|\n+$/g, "") + "\n";
+                                    // If right already starts with a newline, avoid double-blank by
+                                    // removing trailing newline from codeNormalized so only one newline remains
+                                    const rightStartsWithNewline = right.startsWith("\n");
+                                    if (rightStartsWithNewline && codeNormalized.endsWith("\n")) {
+                                        codeNormalized = codeNormalized.replace(/\n+$/, "");
+                                    }
+                                    const leftNeedsNewline = !left.endsWith("\n");
+                                    content = left + (leftNeedsNewline ? "\n" : "") + codeNormalized + right;
+                                }
                             }
                         }
                         break;
@@ -546,6 +631,8 @@ class AdvancedCodeGenerator {
                 }
             }
         }
+        // Normalize excessive blank lines introduced during patching
+        content = content.replace(/\n{3,}/g, "\n\n");
         // Write back the modified content
         await fs.writeFile(filePath, content, "utf-8");
     }
@@ -620,8 +707,8 @@ class AdvancedCodeGenerator {
             if ((type === "framework" && name === selectedModules.framework) ||
                 (type === "database" && name === selectedModules.database) ||
                 (type === "auth" && name === selectedModules.auth)) {
-                Object.assign(allDeps, generator.dependencies);
-                Object.assign(allDevDeps, generator.devDependencies);
+                // Dependencies and devDependencies are now provided via `add-dependency`
+                // operations. Keep merging scripts from generator configs for now.
                 Object.assign(allScripts, generator.scripts);
             }
         }

package/dist/lib/generation/generator-utils.js

@@ -90,11 +90,24 @@ async function mergeGeneratorIntoModuleMetadata(metadata, modulePath) {
                     }
                 }
             }
-            if (generator.dependencies) {
-                metadata.dependencies = { ...metadata.dependencies, ...generator.dependencies };
-            }
-            if (generator.devDependencies) {
-                metadata.devDependencies = { ...metadata.devDependencies, ...generator.devDependencies };
+            // Collect dependencies/devDependencies from add-dependency operations
+            if (generator.operations && Array.isArray(generator.operations)) {
+                for (const operation of generator.operations) {
+                    if (operation.type === "add-dependency") {
+                        if (operation.dependencies) {
+                            metadata.dependencies = {
+                                ...metadata.dependencies,
+                                ...operation.dependencies,
+                            };
+                        }
+                        if (operation.devDependencies) {
+                            metadata.devDependencies = {
+                                ...metadata.devDependencies,
+                                ...operation.devDependencies,
+                            };
+                        }
+                    }
+                }
             }
             if (generator.postInstall && Array.isArray(generator.postInstall)) {
                 metadata.postInstall = metadata.postInstall || [];

package/modules/auth/authjs/generator.json

@@ -34,8 +34,7 @@
       "condition": { "database": "prisma" },
       "dependencies": {
         "@auth/prisma-adapter": "^0.5.0"
-      },
-      "devDependencies": {}
+      }
     },
     {
       "type": "add-env",
@@ -44,11 +43,12 @@
         "AUTH_GOOGLE_ID": "",
         "AUTH_GOOGLE_SECRET": ""
       }
+    },
+    {
+      "type": "add-dependency",
+      "dependencies": {
+        "next-auth": "^5.0.0-beta.30"
+      }
     }
-  ],
-  "dependencies": {
-    "next-auth": "^5.0.0-beta.30"
-  },
-  "devDependencies": {},
-  "scripts": {}
+  ]
 }

package/modules/auth/better-auth/files/lib/auth.ts

@@ -1,4 +1,4 @@
-import { betterAuth } from "better-auth";
+import { betterAuth, env } from "better-auth";
 import { sendEmail } from "./email/email-service";
 import { getVerificationEmailTemplate, getPasswordResetEmailTemplate } from "./email/email-templates";
 {{#switch database}}
@@ -13,6 +13,12 @@ import { mongodbAdapter } from "better-auth/adapters/mongodb";
 {{/switch}}
 
 export async function initAuth() {
+{{#if database == 'mongoose'}}
+const mongooseInstance = await mongoose();
+const client = mongooseInstance.connection.getClient();
+const db = client.db();
+{{/if}}
+
 return betterAuth({
 {{#switch database}}
 {{#case prisma}}
@@ -21,12 +27,10 @@ return betterAuth({
   }),
 {{/case}}
 {{#case mongoose}}
-  const mongooseInstance = await mongoose();
-  const client = mongooseInstance.connection.getClient();
-  const db = client.db();
   database: mongodbAdapter(db, { client }),
 {{/case}}
 {{/switch}}
+  secret: env.BETTER_AUTH_SECRET,
   user: {
     additionalFields: {
       role: {

package/modules/auth/better-auth/files/lib/email-service.ts

@@ -1,7 +1,7 @@
 import nodemailer from "nodemailer";
 
 // Create email transporter
-const transporter = nodemailer.createTransporter({
+const transporter = nodemailer.createTransport({
   host: process.env.EMAIL_HOST,
   port: parseInt(process.env.EMAIL_PORT || "587"),
   secure: process.env.EMAIL_PORT === "465",
@@ -27,7 +27,6 @@ export const sendEmail = async ({ to, subject, text, html }: {
       html,
     });
   } catch (error) {
-    // eslint-disable-next-line no-console
     console.error("Email sending failed:", error);
     throw error;
   }

package/modules/auth/better-auth/generator.json

@@ -51,7 +51,7 @@
       "operations": [
         {
           "type": "add-import",
-          "imports": ["import { initAuth } from \"@/lib/auth\";"]
+          "imports": ["import { initAuth } from \"../lib/auth\";"]
         },
         {
           "type": "add-code",
@@ -67,7 +67,7 @@
       "operations": [
         {
           "type": "add-import",
-          "imports": ["import { auth } from \"@/lib/auth\";",
+          "imports": ["import { auth } from \"../lib/auth\";",
           "import { toNodeHandler } from \"better-auth/node\";"]
         },
         {
@@ -97,12 +97,13 @@
         "EMAIL_USER": "",
         "EMAIL_PASS": "",
         "EMAIL_FROM": "noreply@yourapp.com"
+        }
+      },
+    {
+      "type": "add-dependency",
+      "dependencies": {
+        "better-auth": "^1.4.12"
       }
     }
-  ],
-  "dependencies": {
-    "better-auth": "^1.4.12"
-  },
-  "devDependencies": {},
-  "scripts": {}
+  ]
 }

package/modules/database/mongoose/generator.json

@@ -6,7 +6,7 @@
     {
       "type": "create-file",
       "source": "lib/mongoose.ts",
-      "destination": "src/lib/mongoose.ts"
+      "destination": "lib/mongoose.ts"
     },
     {
       "type": "create-file",
@@ -20,7 +20,7 @@
       "operations": [
         {
           "type": "add-import",
-          "imports": ["import { mongoose } from \"@/lib/mongoose\";"]
+          "imports": ["import { mongoose } from \"../lib/mongoose\";"]
         },
         {
           "type": "add-code",
@@ -34,10 +34,12 @@
       "envVars": {
         "MONGODB_URI": "mongodb://localhost:27017/database_name"
       }
+    },
+    {
+      "type": "add-dependency",
+      "dependencies": {
+        "mongoose": "^8.8.0"
+      }
     }
-  ],
-  "dependencies": {
-    "mongoose": "^8.8.0"
-  },
-  "devDependencies": {}
+  ]
 }

package/modules/database/prisma/generator.json

@@ -91,17 +91,22 @@
       "envVars": {
         "DATABASE_URL": "mongodb://localhost:27017/database_name"
       }
+    },
+    {
+      "type": "add-dependency",
+      "dependencies": {
+        "dotenv": "^17.2.3"
+      }
+    },
+    {
+      "type": "add-script",
+      "scripts": {
+        "db:generate": "npx prisma generate",
+        "db:push": "npx prisma db push",
+        "db:seed": "tsx prisma/seed.ts",
+        "db:migrate": "npx prisma migrate dev",
+        "db:studio": "npx prisma studio"
+      }
     }
-  ],
-  "dependencies": {
-    "dotenv": "^17.2.3"
-  },
-  "devDependencies": {},
-  "scripts": {
-    "db:generate": "npx prisma generate",
-    "db:push": "npx prisma db push",
-    "db:seed": "tsx prisma/seed.ts",
-    "db:migrate": "npx prisma migrate dev",
-    "db:studio": "npx prisma studio"
-  }
+  ]
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "stackkit",
-  "version": "0.1.7",
+  "version": "0.1.8",
   "description": "Production-ready CLI to create and extend JavaScript or TypeScript apps with modular stacks.",
   "main": "dist/index.js",
   "bin": {