create-stackforge 0.1.2 → 0.1.4

package/dist/cli.js

@@ -275,7 +275,6 @@ async function promptForConfig(input) {
 
 // src/generators/core/project-creator.ts
 import { join as join3 } from "path";
-import { fileURLToPath } from "url";
 
 // src/utils/file-system.ts
 import { mkdir, readFile, rm, writeFile } from "fs/promises";
@@ -643,19 +642,33 @@ async function readProjectConfig(root) {
 }
 
 // src/generators/core/project-creator.ts
+var GITIGNORE_CONTENT = `node_modules/
+.next/
+dist/
+.env
+.env.local
+.env.*.local
+.DS_Store
+`;
+var EDITORCONFIG_CONTENT = `root = true
+
+[*]
+charset = utf-8
+end_of_line = lf
+insert_final_newline = true
+indent_style = space
+indent_size = 2
+`;
 async function createProjectSkeleton(root, config, ctx) {
   const projectRoot = join3(root, config.projectName);
-  const templatesRoot = fileURLToPath(new URL("../../../templates", import.meta.url));
   await ensureDir(projectRoot, ctx);
   const readme = buildProjectReadme(config);
   await writeTextFile(join3(projectRoot, "README.md"), readme + "\n", ctx);
   const envExample = `# Environment Variables
 `;
   await writeTextFile(join3(projectRoot, ".env.example"), envExample, ctx);
-  const gitignore = await readTextFile(join3(templatesRoot, "shared", "_gitignore"));
-  await writeTextFile(join3(projectRoot, ".gitignore"), gitignore, ctx);
-  const editorconfig = await readTextFile(join3(templatesRoot, "shared", ".editorconfig"));
-  await writeTextFile(join3(projectRoot, ".editorconfig"), editorconfig, ctx);
+  await writeTextFile(join3(projectRoot, ".gitignore"), GITIGNORE_CONTENT, ctx);
+  await writeTextFile(join3(projectRoot, ".editorconfig"), EDITORCONFIG_CONTENT, ctx);
   const pkg = {
     name: config.projectName,
     version: "0.0.0",
@@ -698,8 +711,7 @@ async function createProjectSkeleton(root, config, ctx) {
 }
 
 // src/generators/database/database-files.ts
-import { join as join4 } from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
+import { join as join5 } from "path";
 
 // src/utils/env-file.ts
 import { readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
@@ -740,12 +752,30 @@ async function removeEnvKey(path, key, ctx) {
   await writeFile3(path, filtered.join("\n"), "utf8");
 }
 
+// src/utils/templates-dir.ts
+import { dirname as dirname3, join as join4 } from "path";
+import { existsSync as existsSync2 } from "fs";
+import { fileURLToPath } from "url";
+function findPackageRoot() {
+  let dir = dirname3(fileURLToPath(import.meta.url));
+  for (let i = 0; i < 10; i++) {
+    if (existsSync2(join4(dir, "package.json"))) {
+      return dir;
+    }
+    const parent = dirname3(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  throw new Error("Could not find package root (package.json)");
+}
+var TEMPLATES_DIR = join4(findPackageRoot(), "templates");
+
 // src/generators/database/database-files.ts
 async function generateDatabaseFiles(root, config, ctx) {
-  const projectRoot = join4(root, config.projectName);
-  const templatesRoot = fileURLToPath2(new URL("../../../templates", import.meta.url));
+  const projectRoot = join5(root, config.projectName);
+  const templatesRoot = TEMPLATES_DIR;
   if (config.database.provider !== "none") {
-    const envPath = join4(projectRoot, ".env.example");
+    const envPath = join5(projectRoot, ".env.example");
     if (config.database.provider === "mongodb") {
       await appendEnvLine(envPath, 'MONGODB_URI=""', ctx);
     } else {
@@ -754,91 +784,90 @@ async function generateDatabaseFiles(root, config, ctx) {
     if (config.database.provider === "neon") {
       await appendEnvLine(envPath, 'NEON_API_KEY=""', ctx);
       await appendEnvLine(envPath, 'NEON_PROJECT_ID=""', ctx);
-      const providerDir = join4(projectRoot, "database");
+      const providerDir = join5(projectRoot, "database");
       await ensureDir(providerDir, ctx);
-      const providerReadme = await readTextFile(join4(templatesRoot, "database", "providers", "neon.README.md"));
-      await writeTextFile(join4(providerDir, "README.md"), providerReadme, ctx);
+      const providerReadme = await readTextFile(join5(templatesRoot, "database", "providers", "neon.README.md"));
+      await writeTextFile(join5(providerDir, "README.md"), providerReadme, ctx);
     }
     if (config.database.provider === "supabase") {
       await appendEnvLine(envPath, 'SUPABASE_URL=""', ctx);
       await appendEnvLine(envPath, 'SUPABASE_ANON_KEY=""', ctx);
-      const providerDir = join4(projectRoot, "database");
+      const providerDir = join5(projectRoot, "database");
       await ensureDir(providerDir, ctx);
-      const providerReadme = await readTextFile(join4(templatesRoot, "database", "providers", "supabase.README.md"));
-      await writeTextFile(join4(providerDir, "README.md"), providerReadme, ctx);
+      const providerReadme = await readTextFile(join5(templatesRoot, "database", "providers", "supabase.README.md"));
+      await writeTextFile(join5(providerDir, "README.md"), providerReadme, ctx);
     }
   }
   if (config.database.orm === "drizzle") {
-    const drizzleDir = join4(projectRoot, "drizzle");
+    const drizzleDir = join5(projectRoot, "drizzle");
     await ensureDir(drizzleDir, ctx);
-    const configContent = await readTextFile(join4(templatesRoot, "database", "drizzle", "drizzle.config.ts"));
-    const schemaContent = await readTextFile(join4(templatesRoot, "database", "drizzle", "schema.ts"));
+    const configContent = await readTextFile(join5(templatesRoot, "database", "drizzle", "drizzle.config.ts"));
+    const schemaContent = await readTextFile(join5(templatesRoot, "database", "drizzle", "schema.ts"));
     const ext = config.frontend.language === "ts" ? "ts" : "js";
-    const clientContent = await readTextFile(join4(templatesRoot, "database", "drizzle", `client.${ext}`));
-    const exampleContent = await readTextFile(join4(templatesRoot, "database", "drizzle", `example.${ext}`));
-    await writeTextFile(join4(projectRoot, "drizzle.config.ts"), configContent, ctx);
-    await writeTextFile(join4(drizzleDir, "schema.ts"), schemaContent, ctx);
-    await writeTextFile(join4(drizzleDir, `client.${ext}`), clientContent, ctx);
-    await writeTextFile(join4(drizzleDir, `example.${ext}`), exampleContent, ctx);
+    const clientContent = await readTextFile(join5(templatesRoot, "database", "drizzle", `client.${ext}`));
+    const exampleContent = await readTextFile(join5(templatesRoot, "database", "drizzle", `example.${ext}`));
+    await writeTextFile(join5(projectRoot, "drizzle.config.ts"), configContent, ctx);
+    await writeTextFile(join5(drizzleDir, "schema.ts"), schemaContent, ctx);
+    await writeTextFile(join5(drizzleDir, `client.${ext}`), clientContent, ctx);
+    await writeTextFile(join5(drizzleDir, `example.${ext}`), exampleContent, ctx);
   }
   if (config.database.orm === "prisma") {
-    const prismaDir = join4(projectRoot, "prisma");
+    const prismaDir = join5(projectRoot, "prisma");
     await ensureDir(prismaDir, ctx);
-    const schema = await readTextFile(join4(templatesRoot, "database", "prisma", "schema.prisma"));
-    await writeTextFile(join4(prismaDir, "schema.prisma"), schema, ctx);
-    const dbDir = join4(projectRoot, "src", "db");
+    const schema = await readTextFile(join5(templatesRoot, "database", "prisma", "schema.prisma"));
+    await writeTextFile(join5(prismaDir, "schema.prisma"), schema, ctx);
+    const dbDir = join5(projectRoot, "src", "db");
     await ensureDir(dbDir, ctx);
     const ext = config.frontend.language === "ts" ? "ts" : "js";
-    const client = await readTextFile(join4(templatesRoot, "database", "prisma", `client.${ext}`));
-    const example = await readTextFile(join4(templatesRoot, "database", "prisma", `example.${ext}`));
-    await writeTextFile(join4(dbDir, `prisma.${ext}`), client, ctx);
-    await writeTextFile(join4(dbDir, `prisma-example.${ext}`), example, ctx);
-    const usage = await readTextFile(join4(templatesRoot, "database", "usage", `prisma-users.${ext}`));
-    await writeTextFile(join4(dbDir, `users.${ext}`), usage, ctx);
+    const client = await readTextFile(join5(templatesRoot, "database", "prisma", `client.${ext}`));
+    const example = await readTextFile(join5(templatesRoot, "database", "prisma", `example.${ext}`));
+    await writeTextFile(join5(dbDir, `prisma.${ext}`), client, ctx);
+    await writeTextFile(join5(dbDir, `prisma-example.${ext}`), example, ctx);
+    const usage = await readTextFile(join5(templatesRoot, "database", "usage", `prisma-users.${ext}`));
+    await writeTextFile(join5(dbDir, `users.${ext}`), usage, ctx);
   }
   if (config.database.orm === "mongoose") {
-    const dbDir = join4(projectRoot, "src", "db");
+    const dbDir = join5(projectRoot, "src", "db");
     await ensureDir(dbDir, ctx);
     const ext = config.frontend.language === "ts" ? "ts" : "js";
-    const connection = await readTextFile(join4(templatesRoot, "database", "mongoose", `connection.${ext}`));
-    const model = await readTextFile(join4(templatesRoot, "database", "mongoose", `model.${ext}`));
-    await writeTextFile(join4(dbDir, `mongoose.${ext}`), connection, ctx);
-    await writeTextFile(join4(dbDir, `mongoose-model.${ext}`), model, ctx);
-    const usage = await readTextFile(join4(templatesRoot, "database", "usage", `mongoose-users.${ext}`));
-    await writeTextFile(join4(dbDir, `users.${ext}`), usage, ctx);
+    const connection = await readTextFile(join5(templatesRoot, "database", "mongoose", `connection.${ext}`));
+    const model = await readTextFile(join5(templatesRoot, "database", "mongoose", `model.${ext}`));
+    await writeTextFile(join5(dbDir, `mongoose.${ext}`), connection, ctx);
+    await writeTextFile(join5(dbDir, `mongoose-model.${ext}`), model, ctx);
+    const usage = await readTextFile(join5(templatesRoot, "database", "usage", `mongoose-users.${ext}`));
+    await writeTextFile(join5(dbDir, `users.${ext}`), usage, ctx);
   }
   if (config.database.orm === "typeorm") {
-    const dbDir = join4(projectRoot, "src", "db");
+    const dbDir = join5(projectRoot, "src", "db");
     await ensureDir(dbDir, ctx);
     const ext = config.frontend.language === "ts" ? "ts" : "js";
-    const template = await readTextFile(join4(templatesRoot, "database", "typeorm", `data-source.${ext}`));
+    const template = await readTextFile(join5(templatesRoot, "database", "typeorm", `data-source.${ext}`));
     const typeormType = config.database.provider === "mysql" ? "mysql" : config.database.provider === "sqlite" ? "sqlite" : "postgres";
     const migrationsPath = config.frontend.language === "ts" ? "migrations/*.ts" : "migrations/*.js";
     const content = template.replace("{{typeormType}}", typeormType).replace("{{migrationsPath}}", migrationsPath);
-    await writeTextFile(join4(dbDir, `data-source.${ext}`), content, ctx);
-    const entitiesDir = join4(dbDir, "entities");
+    await writeTextFile(join5(dbDir, `data-source.${ext}`), content, ctx);
+    const entitiesDir = join5(dbDir, "entities");
     await ensureDir(entitiesDir, ctx);
-    const entity = await readTextFile(join4(templatesRoot, "database", "typeorm", `entity.${ext}`));
-    await writeTextFile(join4(entitiesDir, `User.${ext}`), entity, ctx);
-    const migrationsDir = join4(dbDir, "migrations");
+    const entity = await readTextFile(join5(templatesRoot, "database", "typeorm", `entity.${ext}`));
+    await writeTextFile(join5(entitiesDir, `User.${ext}`), entity, ctx);
+    const migrationsDir = join5(dbDir, "migrations");
     await ensureDir(migrationsDir, ctx);
-    const migrationReadme = await readTextFile(join4(templatesRoot, "database", "typeorm", "migrations", "README.md"));
-    await writeTextFile(join4(migrationsDir, "README.md"), migrationReadme, ctx);
-    const usage = await readTextFile(join4(templatesRoot, "database", "usage", `typeorm-users.${ext}`));
-    await writeTextFile(join4(dbDir, `users.${ext}`), usage, ctx);
+    const migrationReadme = await readTextFile(join5(templatesRoot, "database", "typeorm", "migrations", "README.md"));
+    await writeTextFile(join5(migrationsDir, "README.md"), migrationReadme, ctx);
+    const usage = await readTextFile(join5(templatesRoot, "database", "usage", `typeorm-users.${ext}`));
+    await writeTextFile(join5(dbDir, `users.${ext}`), usage, ctx);
   }
   if (config.database.orm === "drizzle") {
-    const dbDir = join4(projectRoot, "src", "db");
+    const dbDir = join5(projectRoot, "src", "db");
     await ensureDir(dbDir, ctx);
     const ext = config.frontend.language === "ts" ? "ts" : "js";
-    const usage = await readTextFile(join4(templatesRoot, "database", "usage", `drizzle-users.${ext}`));
-    await writeTextFile(join4(dbDir, `users.${ext}`), usage, ctx);
+    const usage = await readTextFile(join5(templatesRoot, "database", "usage", `drizzle-users.${ext}`));
+    await writeTextFile(join5(dbDir, `users.${ext}`), usage, ctx);
   }
 }
 
 // src/generators/frontend/frontend-files.ts
-import { join as join5 } from "path";
-import { fileURLToPath as fileURLToPath3 } from "url";
+import { join as join6 } from "path";
 
 // src/generators/templates/template-engine.ts
 function applyTemplate(content, vars) {
@@ -851,10 +880,10 @@ function applyTemplate(content, vars) {
 
 // src/generators/frontend/frontend-files.ts
 async function generateFrontendFiles(root, config, ctx) {
-  const projectRoot = join5(root, config.projectName);
-  const templatesRoot = fileURLToPath3(new URL("../../../templates", import.meta.url));
+  const projectRoot = join6(root, config.projectName);
+  const templatesRoot = TEMPLATES_DIR;
   if (config.frontend.type === "nextjs") {
-    const appDir = join5(projectRoot, "app");
+    const appDir = join6(projectRoot, "app");
     await ensureDir(appDir, ctx);
     const uiCssImports = buildUiCssImports(config, "nextjs");
     const importCss = uiCssImports.length ? uiCssImports.join("") + "\n" : "";
@@ -863,25 +892,25 @@ async function generateFrontendFiles(root, config, ctx) {
     const hasProviders = hasTrpc || hasUiProvider;
     const providersImport = hasProviders ? "import { Providers } from './providers';\n" : "";
     const wrapChildren = hasProviders ? "<Providers>{children}</Providers>" : "{children}";
-    const layoutTemplatePath = join5(
+    const layoutTemplatePath = join6(
       templatesRoot,
       "nextjs",
       "app",
       config.frontend.language === "ts" ? "layout.tsx" : "layout.jsx"
     );
-    const pageTemplatePath = join5(
+    const pageTemplatePath = join6(
       templatesRoot,
       "nextjs",
       "app",
       config.frontend.language === "ts" ? "page.tsx" : "page.jsx"
     );
-    const actionsTemplatePath = join5(
+    const actionsTemplatePath = join6(
       templatesRoot,
       "nextjs",
       "app",
       config.frontend.language === "ts" ? "actions.ts" : "actions.js"
     );
-    const nextConfigTemplatePath = join5(
+    const nextConfigTemplatePath = join6(
       templatesRoot,
       "nextjs",
       config.frontend.language === "ts" ? "next.config.ts" : "next.config.js"
@@ -889,7 +918,7 @@ async function generateFrontendFiles(root, config, ctx) {
     const layoutTemplate = await readTextFile(layoutTemplatePath);
     const pageTemplate = await readTextFile(pageTemplatePath);
     const examplesTemplate = await readTextFile(
-      join5(
+      join6(
         templatesRoot,
         "nextjs",
         "app",
@@ -906,15 +935,15 @@ async function generateFrontendFiles(root, config, ctx) {
     const links = buildPageLinks(config);
     const page = applyTemplate(pageTemplate, { projectName: config.projectName, links });
     await writeTextFile(
-      join5(projectRoot, config.frontend.language === "ts" ? "next.config.ts" : "next.config.js"),
+      join6(projectRoot, config.frontend.language === "ts" ? "next.config.ts" : "next.config.js"),
       nextConfigTemplate,
       ctx
     );
-    await writeTextFile(join5(appDir, config.frontend.language === "ts" ? "layout.tsx" : "layout.jsx"), layout, ctx);
-    await writeTextFile(join5(appDir, config.frontend.language === "ts" ? "page.tsx" : "page.jsx"), page, ctx);
-    await writeTextFile(join5(appDir, config.frontend.language === "ts" ? "actions.ts" : "actions.js"), actionsTemplate, ctx);
+    await writeTextFile(join6(appDir, config.frontend.language === "ts" ? "layout.tsx" : "layout.jsx"), layout, ctx);
+    await writeTextFile(join6(appDir, config.frontend.language === "ts" ? "page.tsx" : "page.jsx"), page, ctx);
+    await writeTextFile(join6(appDir, config.frontend.language === "ts" ? "actions.ts" : "actions.js"), actionsTemplate, ctx);
     if (config.api.type !== "none") {
-      const examplesDir = join5(appDir, "examples");
+      const examplesDir = join6(appDir, "examples");
       await ensureDir(examplesDir, ctx);
       const { imports, components } = buildApiExamples(config, "nextjs");
       const featureNotes = buildFeatureNotes(config);
@@ -927,7 +956,7 @@ async function generateFrontendFiles(root, config, ctx) {
         uiDemoComponent
       });
       await writeTextFile(
-        join5(examplesDir, config.frontend.language === "ts" ? "page.tsx" : "page.jsx"),
+        join6(examplesDir, config.frontend.language === "ts" ? "page.tsx" : "page.jsx"),
         examplesPage,
         ctx
       );
@@ -935,23 +964,23 @@ async function generateFrontendFiles(root, config, ctx) {
     if (hasProviders) {
       const providers = buildProvidersComponent(config, "nextjs");
       await writeTextFile(
-        join5(appDir, config.frontend.language === "ts" ? "providers.tsx" : "providers.jsx"),
+        join6(appDir, config.frontend.language === "ts" ? "providers.tsx" : "providers.jsx"),
         providers,
         ctx
       );
     }
   }
   if (config.frontend.type === "vite") {
-    const srcDir = join5(projectRoot, "src");
+    const srcDir = join6(projectRoot, "src");
     await ensureDir(srcDir, ctx);
     const uiCssImports = buildUiCssImports(config, "vite");
     const cssImport = uiCssImports.length ? uiCssImports.join("") : "";
     const ext = config.frontend.language === "ts" ? "tsx" : "jsx";
-    const mainTemplatePath = join5(templatesRoot, "vite", config.frontend.language === "ts" ? "main.tsx" : "main.jsx");
-    const appTemplatePath = join5(templatesRoot, "vite", config.frontend.language === "ts" ? "App.tsx" : "App.jsx");
-    const indexTemplatePath = join5(templatesRoot, "vite", "index.html");
-    const viteConfigTemplatePath = join5(templatesRoot, "vite", "vite.config.ts");
-    const viteEnvTemplatePath = join5(templatesRoot, "vite", "vite-env.d.ts");
+    const mainTemplatePath = join6(templatesRoot, "vite", config.frontend.language === "ts" ? "main.tsx" : "main.jsx");
+    const appTemplatePath = join6(templatesRoot, "vite", config.frontend.language === "ts" ? "App.tsx" : "App.jsx");
+    const indexTemplatePath = join6(templatesRoot, "vite", "index.html");
+    const viteConfigTemplatePath = join6(templatesRoot, "vite", "vite.config.ts");
+    const viteEnvTemplatePath = join6(templatesRoot, "vite", "vite-env.d.ts");
     const mainTemplate = await readTextFile(mainTemplatePath);
     const appTemplate = await readTextFile(appTemplatePath);
     const indexTemplate = await readTextFile(indexTemplatePath);
@@ -984,17 +1013,17 @@ async function generateFrontendFiles(root, config, ctx) {
       uiDemoComponent
     });
     const indexHtml = applyTemplate(indexTemplate, { projectName: config.projectName, ext });
-    await writeTextFile(join5(projectRoot, "index.html"), indexHtml, ctx);
-    await writeTextFile(join5(projectRoot, "vite.config.ts"), viteConfigTemplate, ctx);
-    await writeTextFile(join5(srcDir, config.frontend.language === "ts" ? "main.tsx" : "main.jsx"), main, ctx);
-    await writeTextFile(join5(srcDir, config.frontend.language === "ts" ? "App.tsx" : "App.jsx"), app, ctx);
+    await writeTextFile(join6(projectRoot, "index.html"), indexHtml, ctx);
+    await writeTextFile(join6(projectRoot, "vite.config.ts"), viteConfigTemplate, ctx);
+    await writeTextFile(join6(srcDir, config.frontend.language === "ts" ? "main.tsx" : "main.jsx"), main, ctx);
+    await writeTextFile(join6(srcDir, config.frontend.language === "ts" ? "App.tsx" : "App.jsx"), app, ctx);
     if (config.frontend.language === "ts") {
-      await writeTextFile(join5(srcDir, "vite-env.d.ts"), viteEnvTemplate, ctx);
+      await writeTextFile(join6(srcDir, "vite-env.d.ts"), viteEnvTemplate, ctx);
     }
-    await appendEnvLine(join5(projectRoot, ".env.example"), 'VITE_API_URL="http://localhost:3001"', ctx);
+    await appendEnvLine(join6(projectRoot, ".env.example"), 'VITE_API_URL="http://localhost:3001"', ctx);
     if (hasProviders) {
       const providers = buildProvidersComponent(config, "vite");
-      await writeTextFile(join5(srcDir, config.frontend.language === "ts" ? "providers.tsx" : "providers.jsx"), providers, ctx);
+      await writeTextFile(join6(srcDir, config.frontend.language === "ts" ? "providers.tsx" : "providers.jsx"), providers, ctx);
     }
   }
 }
@@ -1188,70 +1217,69 @@ function buildPageLinks(config) {
 }
 
 // src/generators/ui/ui-files.ts
-import { join as join6 } from "path";
-import { fileURLToPath as fileURLToPath4 } from "url";
+import { join as join7 } from "path";
 async function generateUiFiles(root, config, ctx) {
-  const projectRoot = join6(root, config.projectName);
-  const templatesRoot = fileURLToPath4(new URL("../../../templates", import.meta.url));
+  const projectRoot = join7(root, config.projectName);
+  const templatesRoot = TEMPLATES_DIR;
   if (config.ui.library === "tailwind") {
-    const tailwindTemplate = await readTextFile(join6(templatesRoot, "ui", "tailwind.config.js"));
-    const postcssTemplate = await readTextFile(join6(templatesRoot, "ui", "postcss.config.js"));
-    const stylesTemplate = await readTextFile(join6(templatesRoot, "ui", "styles.css"));
-    await writeTextFile(join6(projectRoot, "tailwind.config.js"), tailwindTemplate, ctx);
-    await writeTextFile(join6(projectRoot, "postcss.config.js"), postcssTemplate, ctx);
-    const stylesDir = join6(projectRoot, "src");
+    const tailwindTemplate = await readTextFile(join7(templatesRoot, "ui", "tailwind.config.js"));
+    const postcssTemplate = await readTextFile(join7(templatesRoot, "ui", "postcss.config.js"));
+    const stylesTemplate = await readTextFile(join7(templatesRoot, "ui", "styles.css"));
+    await writeTextFile(join7(projectRoot, "tailwind.config.js"), tailwindTemplate, ctx);
+    await writeTextFile(join7(projectRoot, "postcss.config.js"), postcssTemplate, ctx);
+    const stylesDir = join7(projectRoot, "src");
     await ensureDir(stylesDir, ctx);
-    await writeTextFile(join6(stylesDir, "styles.css"), stylesTemplate, ctx);
+    await writeTextFile(join7(stylesDir, "styles.css"), stylesTemplate, ctx);
     const demo = await readTextFile(
-      join6(templatesRoot, "ui", config.frontend.language === "ts" ? "demo-tailwind.tsx" : "demo-tailwind.jsx")
+      join7(templatesRoot, "ui", config.frontend.language === "ts" ? "demo-tailwind.tsx" : "demo-tailwind.jsx")
     );
-    await ensureDir(join6(projectRoot, "src", "components"), ctx);
+    await ensureDir(join7(projectRoot, "src", "components"), ctx);
     await writeTextFile(
-      join6(projectRoot, "src", "components", config.frontend.language === "ts" ? "ui-demo.tsx" : "ui-demo.jsx"),
+      join7(projectRoot, "src", "components", config.frontend.language === "ts" ? "ui-demo.tsx" : "ui-demo.jsx"),
       demo,
       ctx
     );
   }
   if (config.ui.library === "shadcn") {
-    await ensureDir(join6(projectRoot, "components"), ctx);
-    const shadcnReadme = await readTextFile(join6(templatesRoot, "ui", "shadcn.README.md"));
-    await writeTextFile(join6(projectRoot, "components", "README.md"), shadcnReadme, ctx);
-    const componentsJson = await readTextFile(join6(templatesRoot, "ui", "components.json"));
-    await writeTextFile(join6(projectRoot, "components.json"), componentsJson, ctx);
-    const srcDir = join6(projectRoot, "src");
-    await ensureDir(join6(srcDir, "lib"), ctx);
-    await ensureDir(join6(srcDir, "components", "ui"), ctx);
+    await ensureDir(join7(projectRoot, "components"), ctx);
+    const shadcnReadme = await readTextFile(join7(templatesRoot, "ui", "shadcn.README.md"));
+    await writeTextFile(join7(projectRoot, "components", "README.md"), shadcnReadme, ctx);
+    const componentsJson = await readTextFile(join7(templatesRoot, "ui", "components.json"));
+    await writeTextFile(join7(projectRoot, "components.json"), componentsJson, ctx);
+    const srcDir = join7(projectRoot, "src");
+    await ensureDir(join7(srcDir, "lib"), ctx);
+    await ensureDir(join7(srcDir, "components", "ui"), ctx);
     const ext = config.frontend.language === "ts" ? "ts" : "js";
-    const utilsTemplate = await readTextFile(join6(templatesRoot, "ui", `utils.${ext}`));
-    await writeTextFile(join6(srcDir, "lib", `utils.${ext}`), utilsTemplate, ctx);
+    const utilsTemplate = await readTextFile(join7(templatesRoot, "ui", `utils.${ext}`));
+    await writeTextFile(join7(srcDir, "lib", `utils.${ext}`), utilsTemplate, ctx);
     const buttonTemplate = await readTextFile(
-      join6(templatesRoot, "ui", config.frontend.language === "ts" ? "button.tsx" : "button.jsx")
+      join7(templatesRoot, "ui", config.frontend.language === "ts" ? "button.tsx" : "button.jsx")
     );
-    await writeTextFile(join6(srcDir, "components", "ui", config.frontend.language === "ts" ? "button.tsx" : "button.jsx"), buttonTemplate, ctx);
+    await writeTextFile(join7(srcDir, "components", "ui", config.frontend.language === "ts" ? "button.tsx" : "button.jsx"), buttonTemplate, ctx);
     const demo = await readTextFile(
-      join6(templatesRoot, "ui", config.frontend.language === "ts" ? "demo-shadcn.tsx" : "demo-shadcn.jsx")
+      join7(templatesRoot, "ui", config.frontend.language === "ts" ? "demo-shadcn.tsx" : "demo-shadcn.jsx")
     );
     await writeTextFile(
-      join6(srcDir, "components", config.frontend.language === "ts" ? "ui-demo.tsx" : "ui-demo.jsx"),
+      join7(srcDir, "components", config.frontend.language === "ts" ? "ui-demo.tsx" : "ui-demo.jsx"),
       demo,
       ctx
     );
   }
   if (["mui", "chakra", "mantine", "antd", "nextui"].includes(config.ui.library)) {
-    await ensureDir(join6(projectRoot, "components"), ctx);
-    const readme = await readTextFile(join6(templatesRoot, "ui", `${config.ui.library}.README.md`));
-    await writeTextFile(join6(projectRoot, "components", "README.md"), readme, ctx);
-    const srcDir = join6(projectRoot, "src");
+    await ensureDir(join7(projectRoot, "components"), ctx);
+    const readme = await readTextFile(join7(templatesRoot, "ui", `${config.ui.library}.README.md`));
+    await writeTextFile(join7(projectRoot, "components", "README.md"), readme, ctx);
+    const srcDir = join7(projectRoot, "src");
     await ensureDir(srcDir, ctx);
     const ext = config.frontend.language === "ts" ? "ts" : "js";
-    const themeTemplate = await readTextFile(join6(templatesRoot, "ui", `${config.ui.library}.theme.${ext}`));
-    await writeTextFile(join6(srcDir, `theme.${ext}`), themeTemplate, ctx);
+    const themeTemplate = await readTextFile(join7(templatesRoot, "ui", `${config.ui.library}.theme.${ext}`));
+    await writeTextFile(join7(srcDir, `theme.${ext}`), themeTemplate, ctx);
     const demo = await readTextFile(
-      join6(templatesRoot, "ui", `demo-${config.ui.library}.${config.frontend.language === "ts" ? "tsx" : "jsx"}`)
+      join7(templatesRoot, "ui", `demo-${config.ui.library}.${config.frontend.language === "ts" ? "tsx" : "jsx"}`)
     );
-    await ensureDir(join6(srcDir, "components"), ctx);
+    await ensureDir(join7(srcDir, "components"), ctx);
     await writeTextFile(
-      join6(srcDir, "components", config.frontend.language === "ts" ? "ui-demo.tsx" : "ui-demo.jsx"),
+      join7(srcDir, "components", config.frontend.language === "ts" ? "ui-demo.tsx" : "ui-demo.jsx"),
       demo,
       ctx
     );
@@ -1259,54 +1287,53 @@ async function generateUiFiles(root, config, ctx) {
 }
 
 // src/generators/auth/auth-files.ts
-import { join as join7 } from "path";
-import { fileURLToPath as fileURLToPath5 } from "url";
+import { join as join8 } from "path";
 async function generateAuthFiles(root, config, ctx) {
-  const projectRoot = join7(root, config.projectName);
-  const templatesRoot = fileURLToPath5(new URL("../../../templates", import.meta.url));
+  const projectRoot = join8(root, config.projectName);
+  const templatesRoot = TEMPLATES_DIR;
   if (config.auth.provider === "nextauth") {
-    await appendEnvLine(join7(projectRoot, ".env.example"), 'NEXTAUTH_SECRET=""', ctx);
-    await appendEnvLine(join7(projectRoot, ".env.example"), 'NEXTAUTH_URL=""', ctx);
+    await appendEnvLine(join8(projectRoot, ".env.example"), 'NEXTAUTH_SECRET=""', ctx);
+    await appendEnvLine(join8(projectRoot, ".env.example"), 'NEXTAUTH_URL=""', ctx);
     const ext = config.frontend.language === "ts" ? "ts" : "js";
     if (config.frontend.type === "nextjs") {
-      const routeDir = join7(projectRoot, "app", "api", "auth", "[...nextauth]");
+      const routeDir = join8(projectRoot, "app", "api", "auth", "[...nextauth]");
       await ensureDir(routeDir, ctx);
-      const route = await readTextFile(join7(templatesRoot, "auth", `nextauth-route.${ext}`));
-      await writeTextFile(join7(routeDir, config.frontend.language === "ts" ? "route.ts" : "route.js"), route, ctx);
+      const route = await readTextFile(join8(templatesRoot, "auth", `nextauth-route.${ext}`));
+      await writeTextFile(join8(routeDir, config.frontend.language === "ts" ? "route.ts" : "route.js"), route, ctx);
     }
-    const authDir = join7(projectRoot, "auth");
+    const authDir = join8(projectRoot, "auth");
     await ensureDir(authDir, ctx);
-    const readme = await readTextFile(join7(templatesRoot, "auth", "nextauth.README.md"));
-    await writeTextFile(join7(authDir, "README.md"), readme, ctx);
-    const options = await readTextFile(join7(templatesRoot, "auth", `nextauth-options.${ext}`));
-    await writeTextFile(join7(authDir, `auth-options.${ext}`), options, ctx);
+    const readme = await readTextFile(join8(templatesRoot, "auth", "nextauth.README.md"));
+    await writeTextFile(join8(authDir, "README.md"), readme, ctx);
+    const options = await readTextFile(join8(templatesRoot, "auth", `nextauth-options.${ext}`));
+    await writeTextFile(join8(authDir, `auth-options.${ext}`), options, ctx);
     if (config.frontend.type === "nextjs") {
-      const protectedDir = join7(projectRoot, "app", "auth", "protected");
+      const protectedDir = join8(projectRoot, "app", "auth", "protected");
       await ensureDir(protectedDir, ctx);
       const protectedPage = await readTextFile(
-        join7(templatesRoot, "auth", `nextauth-protected-page.${ext}x`)
+        join8(templatesRoot, "auth", `nextauth-protected-page.${ext}x`)
       );
-      await writeTextFile(join7(protectedDir, `page.${ext}x`), protectedPage, ctx);
-      const signInDir = join7(projectRoot, "app", "auth", "signin");
+      await writeTextFile(join8(protectedDir, `page.${ext}x`), protectedPage, ctx);
+      const signInDir = join8(projectRoot, "app", "auth", "signin");
       await ensureDir(signInDir, ctx);
-      const signInPage = await readTextFile(join7(templatesRoot, "auth", `nextauth-signin.${ext}x`));
-      await writeTextFile(join7(signInDir, `page.${ext}x`), signInPage, ctx);
+      const signInPage = await readTextFile(join8(templatesRoot, "auth", `nextauth-signin.${ext}x`));
+      await writeTextFile(join8(signInDir, `page.${ext}x`), signInPage, ctx);
     } else {
-      const protectedPage = await readTextFile(join7(templatesRoot, "auth", `nextauth-protected.${ext}x`));
-      await writeTextFile(join7(authDir, `protected.${ext}x`), protectedPage, ctx);
+      const protectedPage = await readTextFile(join8(templatesRoot, "auth", `nextauth-protected.${ext}x`));
+      await writeTextFile(join8(authDir, `protected.${ext}x`), protectedPage, ctx);
     }
   }
   if (config.auth.provider === "clerk") {
-    await appendEnvLine(join7(projectRoot, ".env.example"), 'CLERK_SECRET_KEY=""', ctx);
-    await appendEnvLine(join7(projectRoot, ".env.example"), 'NEXT_PUBLIC_CLERK_PUBLISHABLE_KEY=""', ctx);
-    const libDir = join7(projectRoot, "src", "lib");
+    await appendEnvLine(join8(projectRoot, ".env.example"), 'CLERK_SECRET_KEY=""', ctx);
+    await appendEnvLine(join8(projectRoot, ".env.example"), 'NEXT_PUBLIC_CLERK_PUBLISHABLE_KEY=""', ctx);
+    const libDir = join8(projectRoot, "src", "lib");
     await ensureDir(libDir, ctx);
     const clerkClient = `import { clerkClient } from '@clerk/nextjs/server';
 
 export { clerkClient };
 `;
     const ext = config.frontend.language === "ts" ? "ts" : "js";
-    await writeTextFile(join7(libDir, `clerk.${ext}`), clerkClient, ctx);
+    await writeTextFile(join8(libDir, `clerk.${ext}`), clerkClient, ctx);
     if (config.frontend.type === "nextjs") {
       const middleware = `import { authMiddleware } from '@clerk/nextjs';
 
@@ -1316,63 +1343,63 @@ export const config = {
   matcher: ['/((?!.*\\..*|_next).*)', '/', '/(api|trpc)(.*)']
 };
 `;
-      await writeTextFile(join7(projectRoot, `middleware.${ext}`), middleware, ctx);
+      await writeTextFile(join8(projectRoot, `middleware.${ext}`), middleware, ctx);
     }
-    const authDir = join7(projectRoot, "auth");
+    const authDir = join8(projectRoot, "auth");
     await ensureDir(authDir, ctx);
-    const readme = await readTextFile(join7(templatesRoot, "auth", "clerk.README.md"));
-    await writeTextFile(join7(authDir, "README.md"), readme, ctx);
+    const readme = await readTextFile(join8(templatesRoot, "auth", "clerk.README.md"));
+    await writeTextFile(join8(authDir, "README.md"), readme, ctx);
     if (config.frontend.type === "nextjs") {
-      const protectedDir = join7(projectRoot, "app", "auth", "protected");
+      const protectedDir = join8(projectRoot, "app", "auth", "protected");
       await ensureDir(protectedDir, ctx);
       const protectedPage = await readTextFile(
-        join7(templatesRoot, "auth", `clerk-protected-page.${ext}x`)
+        join8(templatesRoot, "auth", `clerk-protected-page.${ext}x`)
       );
-      await writeTextFile(join7(protectedDir, `page.${ext}x`), protectedPage, ctx);
-      const signInDir = join7(projectRoot, "app", "auth", "signin");
+      await writeTextFile(join8(protectedDir, `page.${ext}x`), protectedPage, ctx);
+      const signInDir = join8(projectRoot, "app", "auth", "signin");
       await ensureDir(signInDir, ctx);
-      const signInPage = await readTextFile(join7(templatesRoot, "auth", `clerk-signin.${ext}x`));
-      await writeTextFile(join7(signInDir, `page.${ext}x`), signInPage, ctx);
+      const signInPage = await readTextFile(join8(templatesRoot, "auth", `clerk-signin.${ext}x`));
+      await writeTextFile(join8(signInDir, `page.${ext}x`), signInPage, ctx);
     } else {
-      const protectedPage = await readTextFile(join7(templatesRoot, "auth", `clerk-protected.${ext}x`));
-      await writeTextFile(join7(authDir, `protected.${ext}x`), protectedPage, ctx);
+      const protectedPage = await readTextFile(join8(templatesRoot, "auth", `clerk-protected.${ext}x`));
+      await writeTextFile(join8(authDir, `protected.${ext}x`), protectedPage, ctx);
     }
   }
   if (config.auth.provider === "better-auth") {
-    await appendEnvLine(join7(projectRoot, ".env.example"), 'BETTER_AUTH_SECRET=""', ctx);
-    await appendEnvLine(join7(projectRoot, ".env.example"), 'BETTER_AUTH_URL=""', ctx);
+    await appendEnvLine(join8(projectRoot, ".env.example"), 'BETTER_AUTH_SECRET=""', ctx);
+    await appendEnvLine(join8(projectRoot, ".env.example"), 'BETTER_AUTH_URL=""', ctx);
     const ext = config.frontend.language === "ts" ? "ts" : "js";
-    const authDir = join7(projectRoot, "auth");
+    const authDir = join8(projectRoot, "auth");
     await ensureDir(authDir, ctx);
-    const readme = await readTextFile(join7(templatesRoot, "auth", "better-auth.README.md"));
-    await writeTextFile(join7(authDir, "README.md"), readme, ctx);
-    const serverConfig = await readTextFile(join7(templatesRoot, "auth", `better-auth-server.${ext}`));
-    await writeTextFile(join7(authDir, `auth.${ext}`), serverConfig, ctx);
-    const libDir = join7(projectRoot, "src", "lib");
+    const readme = await readTextFile(join8(templatesRoot, "auth", "better-auth.README.md"));
+    await writeTextFile(join8(authDir, "README.md"), readme, ctx);
+    const serverConfig = await readTextFile(join8(templatesRoot, "auth", `better-auth-server.${ext}`));
+    await writeTextFile(join8(authDir, `auth.${ext}`), serverConfig, ctx);
+    const libDir = join8(projectRoot, "src", "lib");
     await ensureDir(libDir, ctx);
-    const clientConfig = await readTextFile(join7(templatesRoot, "auth", `better-auth-client.${ext}`));
-    await writeTextFile(join7(libDir, `auth-client.${ext}`), clientConfig, ctx);
+    const clientConfig = await readTextFile(join8(templatesRoot, "auth", `better-auth-client.${ext}`));
+    await writeTextFile(join8(libDir, `auth-client.${ext}`), clientConfig, ctx);
     if (config.frontend.type === "nextjs") {
-      const routeDir = join7(projectRoot, "app", "api", "auth", "[...all]");
+      const routeDir = join8(projectRoot, "app", "api", "auth", "[...all]");
       await ensureDir(routeDir, ctx);
-      const route = await readTextFile(join7(templatesRoot, "auth", `better-auth-route.${ext}`));
-      await writeTextFile(join7(routeDir, `route.${ext}`), route, ctx);
-      const protectedDir = join7(projectRoot, "app", "auth", "protected");
+      const route = await readTextFile(join8(templatesRoot, "auth", `better-auth-route.${ext}`));
+      await writeTextFile(join8(routeDir, `route.${ext}`), route, ctx);
+      const protectedDir = join8(projectRoot, "app", "auth", "protected");
       await ensureDir(protectedDir, ctx);
       const protectedPage = await readTextFile(
-        join7(templatesRoot, "auth", `better-auth-protected-page.${ext}x`)
+        join8(templatesRoot, "auth", `better-auth-protected-page.${ext}x`)
       );
-      await writeTextFile(join7(protectedDir, `page.${ext}x`), protectedPage, ctx);
-      const signInDir = join7(projectRoot, "app", "auth", "signin");
+      await writeTextFile(join8(protectedDir, `page.${ext}x`), protectedPage, ctx);
+      const signInDir = join8(projectRoot, "app", "auth", "signin");
       await ensureDir(signInDir, ctx);
-      const signInPage = await readTextFile(join7(templatesRoot, "auth", `better-auth-signin.${ext}x`));
-      await writeTextFile(join7(signInDir, `page.${ext}x`), signInPage, ctx);
+      const signInPage = await readTextFile(join8(templatesRoot, "auth", `better-auth-signin.${ext}x`));
+      await writeTextFile(join8(signInDir, `page.${ext}x`), signInPage, ctx);
     }
   }
   if (config.auth.provider === "supabase") {
-    await appendEnvLine(join7(projectRoot, ".env.example"), 'NEXT_PUBLIC_SUPABASE_URL=""', ctx);
-    await appendEnvLine(join7(projectRoot, ".env.example"), 'NEXT_PUBLIC_SUPABASE_ANON_KEY=""', ctx);
-    const libDir = join7(projectRoot, "src", "lib");
+    await appendEnvLine(join8(projectRoot, ".env.example"), 'NEXT_PUBLIC_SUPABASE_URL=""', ctx);
+    await appendEnvLine(join8(projectRoot, ".env.example"), 'NEXT_PUBLIC_SUPABASE_ANON_KEY=""', ctx);
+    const libDir = join8(projectRoot, "src", "lib");
     await ensureDir(libDir, ctx);
     const supabaseClient = `import { createClient } from '@supabase/supabase-js';
 
@@ -1382,7 +1409,7 @@ const key = process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY || '';
 export const supabase = createClient(url, key);
 `;
     const ext = config.frontend.language === "ts" ? "ts" : "js";
-    await writeTextFile(join7(libDir, `supabase.${ext}`), supabaseClient, ctx);
+    await writeTextFile(join8(libDir, `supabase.${ext}`), supabaseClient, ctx);
     if (config.frontend.type === "nextjs") {
       const supabaseServer = `import { createServerClient } from '@supabase/ssr';
 import { cookies } from 'next/headers';
@@ -1402,47 +1429,46 @@ export function createSupabaseServerClient() {
   );
 }
 `;
-      await writeTextFile(join7(libDir, `supabase-server.${ext}`), supabaseServer, ctx);
+      await writeTextFile(join8(libDir, `supabase-server.${ext}`), supabaseServer, ctx);
     }
-    const authDir = join7(projectRoot, "auth");
+    const authDir = join8(projectRoot, "auth");
     await ensureDir(authDir, ctx);
-    const readme = await readTextFile(join7(templatesRoot, "auth", "supabase.README.md"));
-    await writeTextFile(join7(authDir, "README.md"), readme, ctx);
+    const readme = await readTextFile(join8(templatesRoot, "auth", "supabase.README.md"));
+    await writeTextFile(join8(authDir, "README.md"), readme, ctx);
     if (config.frontend.type === "nextjs") {
-      const protectedDir = join7(projectRoot, "app", "auth", "protected");
+      const protectedDir = join8(projectRoot, "app", "auth", "protected");
       await ensureDir(protectedDir, ctx);
       const protectedPage = await readTextFile(
-        join7(templatesRoot, "auth", `supabase-protected-page.${ext}x`)
+        join8(templatesRoot, "auth", `supabase-protected-page.${ext}x`)
       );
-      await writeTextFile(join7(protectedDir, `page.${ext}x`), protectedPage, ctx);
-      const signInDir = join7(projectRoot, "app", "auth", "signin");
+      await writeTextFile(join8(protectedDir, `page.${ext}x`), protectedPage, ctx);
+      const signInDir = join8(projectRoot, "app", "auth", "signin");
       await ensureDir(signInDir, ctx);
-      const signInPage = await readTextFile(join7(templatesRoot, "auth", `supabase-signin.${ext}x`));
-      await writeTextFile(join7(signInDir, `page.${ext}x`), signInPage, ctx);
+      const signInPage = await readTextFile(join8(templatesRoot, "auth", `supabase-signin.${ext}x`));
+      await writeTextFile(join8(signInDir, `page.${ext}x`), signInPage, ctx);
     } else {
-      const protectedPage = await readTextFile(join7(templatesRoot, "auth", `supabase-protected.${ext}x`));
-      await writeTextFile(join7(authDir, `protected.${ext}x`), protectedPage, ctx);
+      const protectedPage = await readTextFile(join8(templatesRoot, "auth", `supabase-protected.${ext}x`));
+      await writeTextFile(join8(authDir, `protected.${ext}x`), protectedPage, ctx);
       const signin = await readTextFile(
-        join7(templatesRoot, "auth", `supabase-vite-signin.${ext}x`)
+        join8(templatesRoot, "auth", `supabase-vite-signin.${ext}x`)
       );
-      const authUiDir = join7(projectRoot, "src", "auth");
+      const authUiDir = join8(projectRoot, "src", "auth");
       await ensureDir(authUiDir, ctx);
-      await writeTextFile(join7(authUiDir, `signin.${ext}x`), signin, ctx);
+      await writeTextFile(join8(authUiDir, `signin.${ext}x`), signin, ctx);
     }
   }
 }
 
 // src/generators/api/api-files.ts
-import { join as join8 } from "path";
-import { fileURLToPath as fileURLToPath6 } from "url";
+import { join as join9 } from "path";
 async function generateApiFiles(root, config, ctx) {
-  const projectRoot = join8(root, config.projectName);
-  const templatesRoot = fileURLToPath6(new URL("../../../templates", import.meta.url));
+  const projectRoot = join9(root, config.projectName);
+  const templatesRoot = TEMPLATES_DIR;
   if (config.api.type === "rest") {
-    const apiDir = join8(projectRoot, "api");
+    const apiDir = join9(projectRoot, "api");
     await ensureDir(apiDir, ctx);
     await writeTextFile(
-      join8(apiDir, "README.md"),
+      join9(apiDir, "README.md"),
       `# REST API
 
 ## Overview
@@ -1458,56 +1484,56 @@ async function generateApiFiles(root, config, ctx) {
       ctx
     );
     if (config.frontend.type === "nextjs") {
-      const routeDir = join8(projectRoot, "app", "api", "hello");
+      const routeDir = join9(projectRoot, "app", "api", "hello");
       await ensureDir(routeDir, ctx);
       const ext = config.frontend.language === "ts" ? "ts" : "js";
-      const handler = await readTextFile(join8(templatesRoot, "api", "rest", `route.${ext}`));
-      await writeTextFile(join8(routeDir, `route.${ext}`), handler, ctx);
+      const handler = await readTextFile(join9(templatesRoot, "api", "rest", `route.${ext}`));
+      await writeTextFile(join9(routeDir, `route.${ext}`), handler, ctx);
       if (config.database.orm) {
-        const usersDir = join8(projectRoot, "app", "api", "users");
+        const usersDir = join9(projectRoot, "app", "api", "users");
         await ensureDir(usersDir, ctx);
         const usersRoute = await readTextFile(
-          join8(templatesRoot, "api", "rest", config.frontend.language === "ts" ? "users-route.ts" : "users-route.js")
+          join9(templatesRoot, "api", "rest", config.frontend.language === "ts" ? "users-route.ts" : "users-route.js")
         );
         await writeTextFile(
-          join8(usersDir, config.frontend.language === "ts" ? "route.ts" : "route.js"),
+          join9(usersDir, config.frontend.language === "ts" ? "route.ts" : "route.js"),
           usersRoute,
           ctx
         );
       }
     }
     if (config.frontend.type === "vite") {
-      const serverDir = join8(projectRoot, "src", "server");
+      const serverDir = join9(projectRoot, "src", "server");
       await ensureDir(serverDir, ctx);
       const serverTemplate = await readTextFile(
-        join8(templatesRoot, "api", "rest", config.frontend.language === "ts" ? "vite-server.ts" : "vite-server.js")
+        join9(templatesRoot, "api", "rest", config.frontend.language === "ts" ? "vite-server.ts" : "vite-server.js")
       );
       await writeTextFile(
-        join8(serverDir, config.frontend.language === "ts" ? "index.ts" : "index.js"),
+        join9(serverDir, config.frontend.language === "ts" ? "index.ts" : "index.js"),
         serverTemplate,
         ctx
       );
     }
-    const clientDir = join8(projectRoot, "src", "api");
+    const clientDir = join9(projectRoot, "src", "api");
     await ensureDir(clientDir, ctx);
     const client = await readTextFile(
-      join8(templatesRoot, "api", "rest", config.frontend.language === "ts" ? "client.ts" : "client.js")
+      join9(templatesRoot, "api", "rest", config.frontend.language === "ts" ? "client.ts" : "client.js")
     );
-    await writeTextFile(join8(clientDir, config.frontend.language === "ts" ? "client.ts" : "client.js"), client, ctx);
+    await writeTextFile(join9(clientDir, config.frontend.language === "ts" ? "client.ts" : "client.js"), client, ctx);
     const usage = await readTextFile(
-      join8(templatesRoot, "api", "rest", config.frontend.language === "ts" ? "client-usage.tsx" : "client-usage.jsx")
+      join9(templatesRoot, "api", "rest", config.frontend.language === "ts" ? "client-usage.tsx" : "client-usage.jsx")
     );
     await writeTextFile(
-      join8(clientDir, config.frontend.language === "ts" ? "client-usage.tsx" : "client-usage.jsx"),
+      join9(clientDir, config.frontend.language === "ts" ? "client-usage.tsx" : "client-usage.jsx"),
       usage,
       ctx
     );
   }
   if (config.api.type === "trpc") {
-    const apiDir = join8(projectRoot, "api");
+    const apiDir = join9(projectRoot, "api");
     await ensureDir(apiDir, ctx);
     await writeTextFile(
-      join8(apiDir, "README.md"),
+      join9(apiDir, "README.md"),
       `# tRPC Setup
 
 ## Overview
@@ -1523,69 +1549,69 @@ async function generateApiFiles(root, config, ctx) {
       ctx
     );
     if (config.frontend.type === "nextjs") {
-      const trpcDir = join8(projectRoot, "src", "server", "api");
+      const trpcDir = join9(projectRoot, "src", "server", "api");
       await ensureDir(trpcDir, ctx);
-      const router = await readTextFile(join8(templatesRoot, "api", "trpc", "trpc.ts"));
-      const appRouter = await readTextFile(join8(templatesRoot, "api", "trpc", "root.ts"));
-      await writeTextFile(join8(trpcDir, "trpc.ts"), router, ctx);
-      await writeTextFile(join8(trpcDir, "root.ts"), appRouter, ctx);
-      const routeDir = join8(projectRoot, "app", "api", "trpc", "[trpc]");
+      const router = await readTextFile(join9(templatesRoot, "api", "trpc", "trpc.ts"));
+      const appRouter = await readTextFile(join9(templatesRoot, "api", "trpc", "root.ts"));
+      await writeTextFile(join9(trpcDir, "trpc.ts"), router, ctx);
+      await writeTextFile(join9(trpcDir, "root.ts"), appRouter, ctx);
+      const routeDir = join9(projectRoot, "app", "api", "trpc", "[trpc]");
       await ensureDir(routeDir, ctx);
-      const handler = await readTextFile(join8(templatesRoot, "api", "trpc", "route.ts"));
-      await writeTextFile(join8(routeDir, config.frontend.language === "ts" ? "route.ts" : "route.js"), handler, ctx);
-      const clientDir = join8(projectRoot, "src", "trpc");
+      const handler = await readTextFile(join9(templatesRoot, "api", "trpc", "route.ts"));
+      await writeTextFile(join9(routeDir, config.frontend.language === "ts" ? "route.ts" : "route.js"), handler, ctx);
+      const clientDir = join9(projectRoot, "src", "trpc");
       await ensureDir(clientDir, ctx);
       const client = await readTextFile(
-        join8(templatesRoot, "api", "trpc", config.frontend.language === "ts" ? "client.ts" : "client.js")
+        join9(templatesRoot, "api", "trpc", config.frontend.language === "ts" ? "client.ts" : "client.js")
       );
-      await writeTextFile(join8(clientDir, config.frontend.language === "ts" ? "client.ts" : "client.js"), client, ctx);
+      await writeTextFile(join9(clientDir, config.frontend.language === "ts" ? "client.ts" : "client.js"), client, ctx);
       const usage = await readTextFile(
-        join8(templatesRoot, "api", "trpc", config.frontend.language === "ts" ? "client-usage.tsx" : "client-usage.jsx")
+        join9(templatesRoot, "api", "trpc", config.frontend.language === "ts" ? "client-usage.tsx" : "client-usage.jsx")
       );
       await writeTextFile(
-        join8(clientDir, config.frontend.language === "ts" ? "client-usage.tsx" : "client-usage.jsx"),
+        join9(clientDir, config.frontend.language === "ts" ? "client-usage.tsx" : "client-usage.jsx"),
         usage,
         ctx
       );
     }
     if (config.frontend.type === "vite") {
-      const trpcDir = join8(projectRoot, "src", "server", "api");
+      const trpcDir = join9(projectRoot, "src", "server", "api");
       await ensureDir(trpcDir, ctx);
-      const router = await readTextFile(join8(templatesRoot, "api", "trpc", "trpc.ts"));
-      const appRouter = await readTextFile(join8(templatesRoot, "api", "trpc", "root.ts"));
-      await writeTextFile(join8(trpcDir, "trpc.ts"), router, ctx);
-      await writeTextFile(join8(trpcDir, "root.ts"), appRouter, ctx);
-      const clientDir = join8(projectRoot, "src", "trpc");
+      const router = await readTextFile(join9(templatesRoot, "api", "trpc", "trpc.ts"));
+      const appRouter = await readTextFile(join9(templatesRoot, "api", "trpc", "root.ts"));
+      await writeTextFile(join9(trpcDir, "trpc.ts"), router, ctx);
+      await writeTextFile(join9(trpcDir, "root.ts"), appRouter, ctx);
+      const clientDir = join9(projectRoot, "src", "trpc");
       await ensureDir(clientDir, ctx);
       const client = await readTextFile(
-        join8(templatesRoot, "api", "trpc", config.frontend.language === "ts" ? "client-vite.ts" : "client-vite.js")
+        join9(templatesRoot, "api", "trpc", config.frontend.language === "ts" ? "client-vite.ts" : "client-vite.js")
       );
-      await writeTextFile(join8(clientDir, config.frontend.language === "ts" ? "client.ts" : "client.js"), client, ctx);
+      await writeTextFile(join9(clientDir, config.frontend.language === "ts" ? "client.ts" : "client.js"), client, ctx);
       const usage = await readTextFile(
-        join8(templatesRoot, "api", "trpc", config.frontend.language === "ts" ? "client-usage.tsx" : "client-usage.jsx")
+        join9(templatesRoot, "api", "trpc", config.frontend.language === "ts" ? "client-usage.tsx" : "client-usage.jsx")
       );
       await writeTextFile(
-        join8(clientDir, config.frontend.language === "ts" ? "client-usage.tsx" : "client-usage.jsx"),
+        join9(clientDir, config.frontend.language === "ts" ? "client-usage.tsx" : "client-usage.jsx"),
         usage,
         ctx
       );
-      const serverDir = join8(projectRoot, "src", "server");
+      const serverDir = join9(projectRoot, "src", "server");
       await ensureDir(serverDir, ctx);
       const serverTemplate = await readTextFile(
-        join8(templatesRoot, "api", "trpc", config.frontend.language === "ts" ? "vite-server.ts" : "vite-server.js")
+        join9(templatesRoot, "api", "trpc", config.frontend.language === "ts" ? "vite-server.ts" : "vite-server.js")
       );
       await writeTextFile(
-        join8(serverDir, config.frontend.language === "ts" ? "index.ts" : "index.js"),
+        join9(serverDir, config.frontend.language === "ts" ? "index.ts" : "index.js"),
         serverTemplate,
         ctx
       );
     }
   }
   if (config.api.type === "graphql") {
-    const apiDir = join8(projectRoot, "api");
+    const apiDir = join9(projectRoot, "api");
     await ensureDir(apiDir, ctx);
     await writeTextFile(
-      join8(apiDir, "README.md"),
+      join9(apiDir, "README.md"),
       `# GraphQL Setup
 
 ## Overview
@@ -1601,54 +1627,54 @@ async function generateApiFiles(root, config, ctx) {
       ctx
     );
     if (config.frontend.type === "nextjs") {
-      const gqlDir = join8(projectRoot, "src", "graphql");
+      const gqlDir = join9(projectRoot, "src", "graphql");
       await ensureDir(gqlDir, ctx);
-      const schema = await readTextFile(join8(templatesRoot, "api", "graphql", "schema.graphql"));
-      await writeTextFile(join8(gqlDir, "schema.graphql"), schema, ctx);
-      const routeDir = join8(projectRoot, "app", "api", "graphql");
+      const schema = await readTextFile(join9(templatesRoot, "api", "graphql", "schema.graphql"));
+      await writeTextFile(join9(gqlDir, "schema.graphql"), schema, ctx);
+      const routeDir = join9(projectRoot, "app", "api", "graphql");
       await ensureDir(routeDir, ctx);
       const gqlExt = config.frontend.language === "ts" ? "ts" : "js";
-      const handler = await readTextFile(join8(templatesRoot, "api", "graphql", `route.${gqlExt}`));
-      await writeTextFile(join8(routeDir, `route.${gqlExt}`), handler, ctx);
-      const clientDir = join8(projectRoot, "src", "graphql");
+      const handler = await readTextFile(join9(templatesRoot, "api", "graphql", `route.${gqlExt}`));
+      await writeTextFile(join9(routeDir, `route.${gqlExt}`), handler, ctx);
+      const clientDir = join9(projectRoot, "src", "graphql");
       const client = await readTextFile(
-        join8(templatesRoot, "api", "graphql", config.frontend.language === "ts" ? "client.ts" : "client.js")
+        join9(templatesRoot, "api", "graphql", config.frontend.language === "ts" ? "client.ts" : "client.js")
       );
-      await writeTextFile(join8(clientDir, config.frontend.language === "ts" ? "client.ts" : "client.js"), client, ctx);
+      await writeTextFile(join9(clientDir, config.frontend.language === "ts" ? "client.ts" : "client.js"), client, ctx);
       const usage = await readTextFile(
-        join8(templatesRoot, "api", "graphql", config.frontend.language === "ts" ? "client-usage.tsx" : "client-usage.jsx")
+        join9(templatesRoot, "api", "graphql", config.frontend.language === "ts" ? "client-usage.tsx" : "client-usage.jsx")
       );
       await writeTextFile(
-        join8(clientDir, config.frontend.language === "ts" ? "client-usage.tsx" : "client-usage.jsx"),
+        join9(clientDir, config.frontend.language === "ts" ? "client-usage.tsx" : "client-usage.jsx"),
         usage,
         ctx
       );
     }
     if (config.frontend.type === "vite") {
-      const gqlDir = join8(projectRoot, "src", "graphql");
+      const gqlDir = join9(projectRoot, "src", "graphql");
       await ensureDir(gqlDir, ctx);
-      const schema = await readTextFile(join8(templatesRoot, "api", "graphql", "schema.graphql"));
-      await writeTextFile(join8(gqlDir, "schema.graphql"), schema, ctx);
-      const serverDir = join8(projectRoot, "src", "server");
+      const schema = await readTextFile(join9(templatesRoot, "api", "graphql", "schema.graphql"));
+      await writeTextFile(join9(gqlDir, "schema.graphql"), schema, ctx);
+      const serverDir = join9(projectRoot, "src", "server");
       await ensureDir(serverDir, ctx);
       const serverTemplate = await readTextFile(
-        join8(templatesRoot, "api", "graphql", config.frontend.language === "ts" ? "vite-server.ts" : "vite-server.js")
+        join9(templatesRoot, "api", "graphql", config.frontend.language === "ts" ? "vite-server.ts" : "vite-server.js")
       );
       await writeTextFile(
-        join8(serverDir, config.frontend.language === "ts" ? "index.ts" : "index.js"),
+        join9(serverDir, config.frontend.language === "ts" ? "index.ts" : "index.js"),
         serverTemplate,
         ctx
       );
-      const clientDir = join8(projectRoot, "src", "graphql");
+      const clientDir = join9(projectRoot, "src", "graphql");
       const client = await readTextFile(
-        join8(templatesRoot, "api", "graphql", config.frontend.language === "ts" ? "client.ts" : "client.js")
+        join9(templatesRoot, "api", "graphql", config.frontend.language === "ts" ? "client.ts" : "client.js")
       );
-      await writeTextFile(join8(clientDir, config.frontend.language === "ts" ? "client.ts" : "client.js"), client, ctx);
+      await writeTextFile(join9(clientDir, config.frontend.language === "ts" ? "client.ts" : "client.js"), client, ctx);
       const usage = await readTextFile(
-        join8(templatesRoot, "api", "graphql", config.frontend.language === "ts" ? "client-usage.tsx" : "client-usage.jsx")
+        join9(templatesRoot, "api", "graphql", config.frontend.language === "ts" ? "client-usage.tsx" : "client-usage.jsx")
       );
       await writeTextFile(
-        join8(clientDir, config.frontend.language === "ts" ? "client-usage.tsx" : "client-usage.jsx"),
+        join9(clientDir, config.frontend.language === "ts" ? "client-usage.tsx" : "client-usage.jsx"),
         usage,
         ctx
       );
@@ -1657,8 +1683,8 @@ async function generateApiFiles(root, config, ctx) {
 }
 
 // src/ai-agents/config-generator.ts
-import { join as join9 } from "path";
-import { existsSync as existsSync2 } from "fs";
+import { join as join10 } from "path";
+import { existsSync as existsSync3 } from "fs";
 function buildAgentContext(config) {
   return {
     stack: {
@@ -1840,22 +1866,22 @@ function buildHints(config) {
 async function generateAiAgentConfigs(root, config, ctx) {
   if (!config.aiAgents || config.aiAgents.length === 0) return;
   const projectRoot = resolveProjectRoot(root, config);
-  const agentsRoot = join9(projectRoot, ".ai-agents");
+  const agentsRoot = join10(projectRoot, ".ai-agents");
   await ensureDir(agentsRoot, ctx);
-  const serversRoot = join9(agentsRoot, "servers");
+  const serversRoot = join10(agentsRoot, "servers");
   await ensureDir(serversRoot, ctx);
-  const protocolsRoot = join9(agentsRoot, "protocols");
+  const protocolsRoot = join10(agentsRoot, "protocols");
   await ensureDir(protocolsRoot, ctx);
   const tools = buildTools(config);
   const hints = buildHints(config);
   for (const agent of config.aiAgents) {
-    const agentDir = join9(agentsRoot, agent);
+    const agentDir = join10(agentsRoot, agent);
     await ensureDir(agentDir, ctx);
     const ext = config.frontend.language === "ts" ? "ts" : "js";
     const contextJson = JSON.stringify(buildAgentContext(config), null, 2);
-    await writeTextFile(join9(agentDir, "context.json"), contextJson + "\n", ctx);
+    await writeTextFile(join10(agentDir, "context.json"), contextJson + "\n", ctx);
     const toolsJson = JSON.stringify({ tools }, null, 2);
-    await writeTextFile(join9(agentDir, "tools.json"), toolsJson + "\n", ctx);
+    await writeTextFile(join10(agentDir, "tools.json"), toolsJson + "\n", ctx);
     if (agent === "claude") {
       const content = JSON.stringify(
         {
@@ -1869,19 +1895,19 @@ async function generateAiAgentConfigs(root, config, ctx) {
         null,
         2
       );
-      await writeTextFile(join9(agentDir, "claude_desktop_config.json"), content + "\n", ctx);
-      const claudeRoot = join9(projectRoot, ".claude");
+      await writeTextFile(join10(agentDir, "claude_desktop_config.json"), content + "\n", ctx);
+      const claudeRoot = join10(projectRoot, ".claude");
       await ensureDir(claudeRoot, ctx);
-      await writeTextFile(join9(claudeRoot, "claude_desktop_config.json"), content + "\n", ctx);
+      await writeTextFile(join10(claudeRoot, "claude_desktop_config.json"), content + "\n", ctx);
       await writeTextFile(
-        join9(claudeRoot, "README.md"),
+        join10(claudeRoot, "README.md"),
         "StackForge generated this folder for Claude. Use claude_desktop_config.json to configure the MCP server. The server lives in .ai-agents/servers/claude/mcp-server.(ts|js).\n",
         ctx
       );
-      const serverDir = join9(serversRoot, "claude");
+      const serverDir = join10(serversRoot, "claude");
       await ensureDir(serverDir, ctx);
       const serverContent = buildMcpServerContent(ext, tools, hints);
-      await writeTextFile(join9(serverDir, `mcp-server.${ext}`), serverContent, ctx);
+      await writeTextFile(join10(serverDir, `mcp-server.${ext}`), serverContent, ctx);
       const mcpSpec = JSON.stringify(
         {
           name: "stackforge",
@@ -1890,17 +1916,17 @@ async function generateAiAgentConfigs(root, config, ctx) {
         null,
         2
       );
-      await writeTextFile(join9(serverDir, "mcp.json"), mcpSpec + "\n", ctx);
+      await writeTextFile(join10(serverDir, "mcp.json"), mcpSpec + "\n", ctx);
       await writeTextFile(
-        join9(serverDir, "README.md"),
+        join10(serverDir, "README.md"),
         "Run the MCP server: `node mcp-server.js` (or .ts with tsx). Endpoints: /tools and /invoke.\n",
         ctx
       );
     }
     if (agent === "copilot") {
       const content = JSON.stringify({ functions: buildFunctionDefinitions(tools) }, null, 2);
-      await writeTextFile(join9(agentDir, "functions.json"), content + "\n", ctx);
-      const serverDir = join9(serversRoot, "copilot");
+      await writeTextFile(join10(agentDir, "functions.json"), content + "\n", ctx);
+      const serverDir = join10(serversRoot, "copilot");
       await ensureDir(serverDir, ctx);
       const serverContent = `export const functions = ${JSON.stringify(buildFunctionDefinitions(tools), null, 2)};
 
@@ -1908,21 +1934,21 @@ export function handleFunctionCall(name, args) {
   return { name, args, ok: true, message: 'Implement tool logic here.' };
 }
 `;
-      await writeTextFile(join9(serverDir, `functions.${ext}`), serverContent, ctx);
-      await writeTextFile(join9(serverDir, "functions.json"), content + "\n", ctx);
+      await writeTextFile(join10(serverDir, `functions.${ext}`), serverContent, ctx);
+      await writeTextFile(join10(serverDir, "functions.json"), content + "\n", ctx);
     }
     if (agent === "codex") {
       const content = JSON.stringify({ functions: buildFunctionDefinitions(tools) }, null, 2);
-      await writeTextFile(join9(agentDir, "functions.json"), content + "\n", ctx);
-      const codexRoot = join9(projectRoot, ".codex");
+      await writeTextFile(join10(agentDir, "functions.json"), content + "\n", ctx);
+      const codexRoot = join10(projectRoot, ".codex");
       await ensureDir(codexRoot, ctx);
-      await writeTextFile(join9(codexRoot, "functions.json"), content + "\n", ctx);
+      await writeTextFile(join10(codexRoot, "functions.json"), content + "\n", ctx);
       await writeTextFile(
-        join9(codexRoot, "README.md"),
+        join10(codexRoot, "README.md"),
         "StackForge generated this folder for Codex. Use functions.json for OpenAI function calling integrations.\n",
         ctx
       );
-      const serverDir = join9(serversRoot, "codex");
+      const serverDir = join10(serversRoot, "codex");
       await ensureDir(serverDir, ctx);
       const serverContent = `export const functions = ${JSON.stringify(buildFunctionDefinitions(tools), null, 2)};
 
@@ -1930,13 +1956,13 @@ export function handleFunctionCall(name, args) {
   return { name, args, ok: true, message: 'Implement tool logic here.' };
 }
 `;
-      await writeTextFile(join9(serverDir, `functions.${ext}`), serverContent, ctx);
-      await writeTextFile(join9(serverDir, "functions.json"), content + "\n", ctx);
+      await writeTextFile(join10(serverDir, `functions.${ext}`), serverContent, ctx);
+      await writeTextFile(join10(serverDir, "functions.json"), content + "\n", ctx);
     }
     if (agent === "gemini") {
       const content = JSON.stringify({ functions: buildFunctionDefinitions(tools) }, null, 2);
-      await writeTextFile(join9(agentDir, "function_declarations.json"), content + "\n", ctx);
-      const serverDir = join9(serversRoot, "gemini");
+      await writeTextFile(join10(agentDir, "function_declarations.json"), content + "\n", ctx);
+      const serverDir = join10(serversRoot, "gemini");
       await ensureDir(serverDir, ctx);
       const serverContent = `export const functions = ${JSON.stringify(buildFunctionDefinitions(tools), null, 2)};
 
@@ -1944,46 +1970,46 @@ export function handleFunctionCall(name, args) {
   return { name, args, ok: true, message: 'Implement tool logic here.' };
 }
 `;
-      await writeTextFile(join9(serverDir, `functions.${ext}`), serverContent, ctx);
-      await writeTextFile(join9(serverDir, "function_declarations.json"), content + "\n", ctx);
+      await writeTextFile(join10(serverDir, `functions.${ext}`), serverContent, ctx);
+      await writeTextFile(join10(serverDir, "function_declarations.json"), content + "\n", ctx);
     }
     if (agent === "cursor") {
       const content = `# Cursor rules
 # See context.json for project stack details
 `;
-      await writeTextFile(join9(agentDir, ".cursorrules"), content, ctx);
-      await writeTextFile(join9(projectRoot, ".cursorrules"), content, ctx);
-      const cursorRoot = join9(projectRoot, ".cursor");
+      await writeTextFile(join10(agentDir, ".cursorrules"), content, ctx);
+      await writeTextFile(join10(projectRoot, ".cursorrules"), content, ctx);
+      const cursorRoot = join10(projectRoot, ".cursor");
       await ensureDir(cursorRoot, ctx);
       const extensions = JSON.stringify({ recommendations: ["cursor.cursor"] }, null, 2);
-      await writeTextFile(join9(cursorRoot, "extensions.json"), extensions + "\n", ctx);
-      const serverDir = join9(serversRoot, "cursor");
+      await writeTextFile(join10(cursorRoot, "extensions.json"), extensions + "\n", ctx);
+      const serverDir = join10(serversRoot, "cursor");
       await ensureDir(serverDir, ctx);
       const serverContent = `# Cursor uses .cursorrules for guidance.
 `;
-      await writeTextFile(join9(serverDir, "README.md"), serverContent, ctx);
+      await writeTextFile(join10(serverDir, "README.md"), serverContent, ctx);
     }
     if (agent === "codeium") {
       const content = JSON.stringify({ protocol: "lsp", tools, hints }, null, 2);
-      await writeTextFile(join9(agentDir, "server-config.json"), content + "\n", ctx);
+      await writeTextFile(join10(agentDir, "server-config.json"), content + "\n", ctx);
     }
     if (agent === "windsurf") {
-      const windsurfRoot = join9(projectRoot, ".windsurf");
+      const windsurfRoot = join10(projectRoot, ".windsurf");
       await ensureDir(windsurfRoot, ctx);
       const content = JSON.stringify({ protocol: "cascade", tools, hints }, null, 2);
-      await writeTextFile(join9(windsurfRoot, "cascade.json"), content + "\n", ctx);
+      await writeTextFile(join10(windsurfRoot, "cascade.json"), content + "\n", ctx);
     }
     if (agent === "tabnine") {
-      const tabnineRoot = join9(projectRoot, ".tabnine");
+      const tabnineRoot = join10(projectRoot, ".tabnine");
       await ensureDir(tabnineRoot, ctx);
       const content = JSON.stringify({ tools, hints }, null, 2);
-      await writeTextFile(join9(tabnineRoot, "config.json"), content + "\n", ctx);
+      await writeTextFile(join10(tabnineRoot, "config.json"), content + "\n", ctx);
     }
   }
   const protocolTools = tools;
   const openAiFunctions = buildFunctionDefinitions(protocolTools);
   const openAiSchema = JSON.stringify({ functions: openAiFunctions }, null, 2);
-  await writeTextFile(join9(protocolsRoot, "openai-functions.json"), openAiSchema + "\n", ctx);
+  await writeTextFile(join10(protocolsRoot, "openai-functions.json"), openAiSchema + "\n", ctx);
   const lspSchema = JSON.stringify(
     {
       version: "0.1",
@@ -1994,16 +2020,16 @@ export function handleFunctionCall(name, args) {
     null,
     2
   );
-  await writeTextFile(join9(protocolsRoot, "lsp.json"), lspSchema + "\n", ctx);
-  const docsDir = join9(projectRoot, "docs");
+  await writeTextFile(join10(protocolsRoot, "lsp.json"), lspSchema + "\n", ctx);
+  const docsDir = join10(projectRoot, "docs");
   await ensureDir(docsDir, ctx);
   const aiDoc = buildAiAgentsDoc(config);
-  await writeTextFile(join9(docsDir, "AI_AGENTS.md"), aiDoc + "\n", ctx);
+  await writeTextFile(join10(docsDir, "AI_AGENTS.md"), aiDoc + "\n", ctx);
 }
 function resolveProjectRoot(root, config) {
-  const candidate = join9(root, "stackforge.json");
-  if (existsSync2(candidate)) return root;
-  return join9(root, config.projectName);
+  const candidate = join10(root, "stackforge.json");
+  if (existsSync3(candidate)) return root;
+  return join10(root, config.projectName);
 }
 function buildAiAgentsDoc(config) {
   const agentsList = config.aiAgents.map((agent) => `- ${agent}`).join("\n");
@@ -2113,73 +2139,72 @@ server.listen(port, () => {
 }
 
 // src/generators/features/feature-files.ts
-import { join as join10 } from "path";
-import { fileURLToPath as fileURLToPath7 } from "url";
+import { join as join11 } from "path";
 async function generateFeatureFiles(root, config, ctx) {
-  const projectRoot = join10(root, config.projectName);
-  const templatesRoot = fileURLToPath7(new URL("../../../templates", import.meta.url));
-  const libDir = join10(projectRoot, "src", "lib");
+  const projectRoot = join11(root, config.projectName);
+  const templatesRoot = TEMPLATES_DIR;
+  const libDir = join11(projectRoot, "src", "lib");
   const isTs = config.frontend.language === "ts";
   if (config.features.includes("email")) {
-    const dir = join10(projectRoot, "features", "email");
+    const dir = join11(projectRoot, "features", "email");
     await ensureDir(dir, ctx);
     await ensureDir(libDir, ctx);
-    const readme = await readTextFile(join10(templatesRoot, "features", "email", "README.md"));
+    const readme = await readTextFile(join11(templatesRoot, "features", "email", "README.md"));
     const resendClient = await readTextFile(
-      join10(templatesRoot, "features", "email", isTs ? "resend.ts" : "resend.js")
+      join11(templatesRoot, "features", "email", isTs ? "resend.ts" : "resend.js")
     );
-    await writeTextFile(join10(dir, "README.md"), readme, ctx);
-    await writeTextFile(join10(libDir, isTs ? "resend.ts" : "resend.js"), resendClient, ctx);
-    await appendEnvLine(join10(projectRoot, ".env.example"), 'RESEND_API_KEY=""', ctx);
+    await writeTextFile(join11(dir, "README.md"), readme, ctx);
+    await writeTextFile(join11(libDir, isTs ? "resend.ts" : "resend.js"), resendClient, ctx);
+    await appendEnvLine(join11(projectRoot, ".env.example"), 'RESEND_API_KEY=""', ctx);
   }
   if (config.features.includes("storage")) {
-    const dir = join10(projectRoot, "features", "storage");
+    const dir = join11(projectRoot, "features", "storage");
     await ensureDir(dir, ctx);
     await ensureDir(libDir, ctx);
-    const readme = await readTextFile(join10(templatesRoot, "features", "storage", "README.md"));
-    await writeTextFile(join10(dir, "README.md"), readme, ctx);
+    const readme = await readTextFile(join11(templatesRoot, "features", "storage", "README.md"));
+    await writeTextFile(join11(dir, "README.md"), readme, ctx);
     const storageClient = await readTextFile(
-      join10(templatesRoot, "features", "storage", isTs ? "storage.ts" : "storage.js")
+      join11(templatesRoot, "features", "storage", isTs ? "storage.ts" : "storage.js")
     );
-    await writeTextFile(join10(libDir, isTs ? "storage.ts" : "storage.js"), storageClient, ctx);
-    await appendEnvLine(join10(projectRoot, ".env.example"), 'CLOUDINARY_URL=""', ctx);
+    await writeTextFile(join11(libDir, isTs ? "storage.ts" : "storage.js"), storageClient, ctx);
+    await appendEnvLine(join11(projectRoot, ".env.example"), 'CLOUDINARY_URL=""', ctx);
   }
   if (config.features.includes("payments")) {
-    const dir = join10(projectRoot, "features", "payments");
+    const dir = join11(projectRoot, "features", "payments");
     await ensureDir(dir, ctx);
     await ensureDir(libDir, ctx);
-    const readme = await readTextFile(join10(templatesRoot, "features", "payments", "README.md"));
+    const readme = await readTextFile(join11(templatesRoot, "features", "payments", "README.md"));
     const stripeClient = await readTextFile(
-      join10(templatesRoot, "features", "payments", isTs ? "stripe.ts" : "stripe.js")
+      join11(templatesRoot, "features", "payments", isTs ? "stripe.ts" : "stripe.js")
     );
-    await writeTextFile(join10(dir, "README.md"), readme, ctx);
-    await writeTextFile(join10(libDir, isTs ? "stripe.ts" : "stripe.js"), stripeClient, ctx);
-    await appendEnvLine(join10(projectRoot, ".env.example"), 'STRIPE_SECRET_KEY=""', ctx);
+    await writeTextFile(join11(dir, "README.md"), readme, ctx);
+    await writeTextFile(join11(libDir, isTs ? "stripe.ts" : "stripe.js"), stripeClient, ctx);
+    await appendEnvLine(join11(projectRoot, ".env.example"), 'STRIPE_SECRET_KEY=""', ctx);
   }
   if (config.features.includes("analytics")) {
-    const dir = join10(projectRoot, "features", "analytics");
+    const dir = join11(projectRoot, "features", "analytics");
     await ensureDir(dir, ctx);
     await ensureDir(libDir, ctx);
-    const readme = await readTextFile(join10(templatesRoot, "features", "analytics", "README.md"));
+    const readme = await readTextFile(join11(templatesRoot, "features", "analytics", "README.md"));
     const client = await readTextFile(
-      join10(templatesRoot, "features", "analytics", isTs ? "posthog.ts" : "posthog.js")
+      join11(templatesRoot, "features", "analytics", isTs ? "posthog.ts" : "posthog.js")
     );
-    await writeTextFile(join10(dir, "README.md"), readme, ctx);
-    await writeTextFile(join10(libDir, isTs ? "posthog.ts" : "posthog.js"), client, ctx);
-    await appendEnvLine(join10(projectRoot, ".env.example"), 'NEXT_PUBLIC_POSTHOG_KEY=""', ctx);
-    await appendEnvLine(join10(projectRoot, ".env.example"), 'NEXT_PUBLIC_POSTHOG_HOST=""', ctx);
+    await writeTextFile(join11(dir, "README.md"), readme, ctx);
+    await writeTextFile(join11(libDir, isTs ? "posthog.ts" : "posthog.js"), client, ctx);
+    await appendEnvLine(join11(projectRoot, ".env.example"), 'NEXT_PUBLIC_POSTHOG_KEY=""', ctx);
+    await appendEnvLine(join11(projectRoot, ".env.example"), 'NEXT_PUBLIC_POSTHOG_HOST=""', ctx);
   }
   if (config.features.includes("error-tracking")) {
-    const dir = join10(projectRoot, "features", "error-tracking");
+    const dir = join11(projectRoot, "features", "error-tracking");
     await ensureDir(dir, ctx);
     await ensureDir(libDir, ctx);
-    const readme = await readTextFile(join10(templatesRoot, "features", "error-tracking", "README.md"));
+    const readme = await readTextFile(join11(templatesRoot, "features", "error-tracking", "README.md"));
     const client = await readTextFile(
-      join10(templatesRoot, "features", "error-tracking", isTs ? "sentry.ts" : "sentry.js")
+      join11(templatesRoot, "features", "error-tracking", isTs ? "sentry.ts" : "sentry.js")
     );
-    await writeTextFile(join10(dir, "README.md"), readme, ctx);
-    await writeTextFile(join10(libDir, isTs ? "sentry.ts" : "sentry.js"), client, ctx);
-    await appendEnvLine(join10(projectRoot, ".env.example"), 'SENTRY_DSN=""', ctx);
+    await writeTextFile(join11(dir, "README.md"), readme, ctx);
+    await writeTextFile(join11(libDir, isTs ? "sentry.ts" : "sentry.js"), client, ctx);
+    await appendEnvLine(join11(projectRoot, ".env.example"), 'SENTRY_DSN=""', ctx);
   }
 }
 
@@ -2316,7 +2341,7 @@ function runInstall(pm, cwd) {
 }
 
 // src/cli/commands/create.ts
-import { join as join11, resolve } from "path";
+import { join as join12, resolve } from "path";
 function parseCsv(input) {
   if (!input) return void 0;
   return input.split(",").map((a) => a.trim()).filter(Boolean);
@@ -2341,7 +2366,7 @@ var createCommand = new Command("create").argument("[project-name]", "name of th
   const outDir = options.outDir ? resolve(options.outDir) : process.cwd();
   await runGenerators(outDir, config, ctx);
   if (options.install !== false && !options.dryRun) {
-    const projectRoot = join11(outDir, config.projectName);
+    const projectRoot = join12(outDir, config.projectName);
     logger.info("Installing dependencies...");
     await runInstall(config.packageManager, projectRoot);
   }
@@ -2519,7 +2544,7 @@ async function syncPackageJson(path, oldConfig, newConfig) {
 }
 
 // src/cli/commands/add.ts
-import { dirname as dirname3, join as join12 } from "path";
+import { dirname as dirname4, join as join13 } from "path";
 function parseFeature(feature) {
   const parts = feature.split(":");
   if (parts.length !== 2 || !parts[0] || !parts[1]) {
@@ -2539,14 +2564,14 @@ var addCommand = new Command3("add").argument("<feature>", "feature to add (cate
     validateDependencies(next);
     await writeProjectConfig(cwd, next);
     await syncPackageJson(`${cwd}/package.json`, current, next);
-    const root = dirname3(cwd);
+    const root = dirname4(cwd);
     if (category === "ui") await generateUiFiles(root, next);
     if (category === "database" || category === "orm") await generateDatabaseFiles(root, next);
     if (category === "auth") await generateAuthFiles(root, next);
     if (category === "api") await generateApiFiles(root, next);
     if (category === "feature") await generateFeatureFiles(root, next);
     const readme = buildProjectReadme(next);
-    await writeTextFile(join12(cwd, "README.md"), readme + "\n");
+    await writeTextFile(join13(cwd, "README.md"), readme + "\n");
     logger.info(`Added ${feature}`);
   } catch (err) {
     logger.error(err instanceof Error ? err.message : String(err));
@@ -2558,188 +2583,188 @@ var addCommand = new Command3("add").argument("<feature>", "feature to add (cate
 import { Command as Command4 } from "commander";
 
 // src/utils/feature-cleanup.ts
-import { join as join13 } from "path";
+import { join as join14 } from "path";
 async function cleanupFeature(cwd, config, category, value) {
   const root = cwd;
   if (category === "ui") {
     if (config.ui.library === "tailwind") {
-      await removePath(join13(root, "tailwind.config.js"));
-      await removePath(join13(root, "postcss.config.js"));
-      await removePath(join13(root, "src", "styles.css"));
-      await removePath(join13(root, "src", "components", "ui-demo.tsx"));
-      await removePath(join13(root, "src", "components", "ui-demo.jsx"));
+      await removePath(join14(root, "tailwind.config.js"));
+      await removePath(join14(root, "postcss.config.js"));
+      await removePath(join14(root, "src", "styles.css"));
+      await removePath(join14(root, "src", "components", "ui-demo.tsx"));
+      await removePath(join14(root, "src", "components", "ui-demo.jsx"));
     }
     if (config.ui.library === "shadcn") {
-      await removePath(join13(root, "components"));
-      await removePath(join13(root, "components.json"));
-      await removePath(join13(root, "src", "lib", "utils.ts"));
-      await removePath(join13(root, "src", "lib", "utils.js"));
-      await removePath(join13(root, "src", "components", "ui"));
-      await removePath(join13(root, "src", "components", "ui-demo.tsx"));
-      await removePath(join13(root, "src", "components", "ui-demo.jsx"));
+      await removePath(join14(root, "components"));
+      await removePath(join14(root, "components.json"));
+      await removePath(join14(root, "src", "lib", "utils.ts"));
+      await removePath(join14(root, "src", "lib", "utils.js"));
+      await removePath(join14(root, "src", "components", "ui"));
+      await removePath(join14(root, "src", "components", "ui-demo.tsx"));
+      await removePath(join14(root, "src", "components", "ui-demo.jsx"));
     }
     if (config.ui.library === "mui" || config.ui.library === "chakra" || config.ui.library === "mantine" || config.ui.library === "antd" || config.ui.library === "nextui") {
-      await removePath(join13(root, "components"));
-      await removePath(join13(root, "src", "theme.ts"));
-      await removePath(join13(root, "src", "theme.js"));
-      await removePath(join13(root, "src", "components", "ui-demo.tsx"));
-      await removePath(join13(root, "src", "components", "ui-demo.jsx"));
+      await removePath(join14(root, "components"));
+      await removePath(join14(root, "src", "theme.ts"));
+      await removePath(join14(root, "src", "theme.js"));
+      await removePath(join14(root, "src", "components", "ui-demo.tsx"));
+      await removePath(join14(root, "src", "components", "ui-demo.jsx"));
     }
   }
   if (category === "auth") {
     if (config.auth.provider === "nextauth") {
-      await removePath(join13(root, "app", "api", "auth"));
-      await removePath(join13(root, "app", "auth", "protected"));
-      await removePath(join13(root, "app", "auth", "signin"));
-      await removeEnvKey(join13(root, ".env.example"), "NEXTAUTH_SECRET");
-      await removeEnvKey(join13(root, ".env.example"), "NEXTAUTH_URL");
+      await removePath(join14(root, "app", "api", "auth"));
+      await removePath(join14(root, "app", "auth", "protected"));
+      await removePath(join14(root, "app", "auth", "signin"));
+      await removeEnvKey(join14(root, ".env.example"), "NEXTAUTH_SECRET");
+      await removeEnvKey(join14(root, ".env.example"), "NEXTAUTH_URL");
     }
     if (config.auth.provider === "clerk") {
-      await removePath(join13(root, "middleware.ts"));
-      await removePath(join13(root, "middleware.js"));
-      await removePath(join13(root, "src", "lib", "clerk.ts"));
-      await removePath(join13(root, "src", "lib", "clerk.js"));
-      await removePath(join13(root, "app", "auth", "protected"));
-      await removePath(join13(root, "app", "auth", "signin"));
-      await removeEnvKey(join13(root, ".env.example"), "CLERK_SECRET_KEY");
-      await removeEnvKey(join13(root, ".env.example"), "NEXT_PUBLIC_CLERK_PUBLISHABLE_KEY");
+      await removePath(join14(root, "middleware.ts"));
+      await removePath(join14(root, "middleware.js"));
+      await removePath(join14(root, "src", "lib", "clerk.ts"));
+      await removePath(join14(root, "src", "lib", "clerk.js"));
+      await removePath(join14(root, "app", "auth", "protected"));
+      await removePath(join14(root, "app", "auth", "signin"));
+      await removeEnvKey(join14(root, ".env.example"), "CLERK_SECRET_KEY");
+      await removeEnvKey(join14(root, ".env.example"), "NEXT_PUBLIC_CLERK_PUBLISHABLE_KEY");
     }
     if (config.auth.provider === "supabase") {
-      await removePath(join13(root, "src", "lib", "supabase.ts"));
-      await removePath(join13(root, "src", "lib", "supabase.js"));
-      await removePath(join13(root, "src", "lib", "supabase-server.ts"));
-      await removePath(join13(root, "src", "lib", "supabase-server.js"));
-      await removePath(join13(root, "app", "auth", "protected"));
-      await removePath(join13(root, "app", "auth", "signin"));
-      await removePath(join13(root, "src", "auth", "signin.tsx"));
-      await removePath(join13(root, "src", "auth", "signin.jsx"));
-      await removeEnvKey(join13(root, ".env.example"), "NEXT_PUBLIC_SUPABASE_URL");
-      await removeEnvKey(join13(root, ".env.example"), "NEXT_PUBLIC_SUPABASE_ANON_KEY");
-    }
-    await removePath(join13(root, "auth"));
+      await removePath(join14(root, "src", "lib", "supabase.ts"));
+      await removePath(join14(root, "src", "lib", "supabase.js"));
+      await removePath(join14(root, "src", "lib", "supabase-server.ts"));
+      await removePath(join14(root, "src", "lib", "supabase-server.js"));
+      await removePath(join14(root, "app", "auth", "protected"));
+      await removePath(join14(root, "app", "auth", "signin"));
+      await removePath(join14(root, "src", "auth", "signin.tsx"));
+      await removePath(join14(root, "src", "auth", "signin.jsx"));
+      await removeEnvKey(join14(root, ".env.example"), "NEXT_PUBLIC_SUPABASE_URL");
+      await removeEnvKey(join14(root, ".env.example"), "NEXT_PUBLIC_SUPABASE_ANON_KEY");
+    }
+    await removePath(join14(root, "auth"));
   }
   if (category === "api") {
     if (config.api.type === "rest") {
-      await removePath(join13(root, "app", "api", "hello"));
-      await removePath(join13(root, "app", "api", "users"));
-      await removePath(join13(root, "app", "examples"));
-      await removePath(join13(root, "src", "server"));
-      await removePath(join13(root, "src", "api"));
-      await removePath(join13(root, "src", "api", "client-usage.tsx"));
-      await removePath(join13(root, "src", "api", "client-usage.jsx"));
+      await removePath(join14(root, "app", "api", "hello"));
+      await removePath(join14(root, "app", "api", "users"));
+      await removePath(join14(root, "app", "examples"));
+      await removePath(join14(root, "src", "server"));
+      await removePath(join14(root, "src", "api"));
+      await removePath(join14(root, "src", "api", "client-usage.tsx"));
+      await removePath(join14(root, "src", "api", "client-usage.jsx"));
     }
     if (config.api.type === "trpc") {
-      await removePath(join13(root, "app", "api", "trpc"));
-      await removePath(join13(root, "app", "examples"));
-      await removePath(join13(root, "src", "server", "api"));
-      await removePath(join13(root, "src", "trpc"));
-      await removePath(join13(root, "src", "trpc", "client-usage.tsx"));
-      await removePath(join13(root, "src", "trpc", "client-usage.jsx"));
-      await removePath(join13(root, "src", "server"));
+      await removePath(join14(root, "app", "api", "trpc"));
+      await removePath(join14(root, "app", "examples"));
+      await removePath(join14(root, "src", "server", "api"));
+      await removePath(join14(root, "src", "trpc"));
+      await removePath(join14(root, "src", "trpc", "client-usage.tsx"));
+      await removePath(join14(root, "src", "trpc", "client-usage.jsx"));
+      await removePath(join14(root, "src", "server"));
     }
     if (config.api.type === "graphql") {
-      await removePath(join13(root, "app", "api", "graphql"));
-      await removePath(join13(root, "app", "examples"));
-      await removePath(join13(root, "src", "graphql"));
-      await removePath(join13(root, "src", "server"));
-      await removePath(join13(root, "src", "graphql", "client-usage.tsx"));
-      await removePath(join13(root, "src", "graphql", "client-usage.jsx"));
+      await removePath(join14(root, "app", "api", "graphql"));
+      await removePath(join14(root, "app", "examples"));
+      await removePath(join14(root, "src", "graphql"));
+      await removePath(join14(root, "src", "server"));
+      await removePath(join14(root, "src", "graphql", "client-usage.tsx"));
+      await removePath(join14(root, "src", "graphql", "client-usage.jsx"));
     }
-    await removePath(join13(root, "api"));
+    await removePath(join14(root, "api"));
   }
   if (category === "database") {
     if (config.database.orm === "drizzle") {
-      await removePath(join13(root, "drizzle.config.ts"));
-      await removePath(join13(root, "drizzle"));
+      await removePath(join14(root, "drizzle.config.ts"));
+      await removePath(join14(root, "drizzle"));
     }
     if (config.database.orm === "prisma") {
-      await removePath(join13(root, "prisma"));
-      await removePath(join13(root, "src", "db", "prisma.ts"));
-      await removePath(join13(root, "src", "db", "prisma.js"));
-      await removePath(join13(root, "src", "db", "prisma-example.ts"));
-      await removePath(join13(root, "src", "db", "prisma-example.js"));
+      await removePath(join14(root, "prisma"));
+      await removePath(join14(root, "src", "db", "prisma.ts"));
+      await removePath(join14(root, "src", "db", "prisma.js"));
+      await removePath(join14(root, "src", "db", "prisma-example.ts"));
+      await removePath(join14(root, "src", "db", "prisma-example.js"));
     }
     if (config.database.orm === "mongoose") {
-      await removePath(join13(root, "src", "db", "mongoose.ts"));
-      await removePath(join13(root, "src", "db", "mongoose.js"));
-      await removePath(join13(root, "src", "db", "mongoose-model.ts"));
-      await removePath(join13(root, "src", "db", "mongoose-model.js"));
+      await removePath(join14(root, "src", "db", "mongoose.ts"));
+      await removePath(join14(root, "src", "db", "mongoose.js"));
+      await removePath(join14(root, "src", "db", "mongoose-model.ts"));
+      await removePath(join14(root, "src", "db", "mongoose-model.js"));
     }
     if (config.database.orm === "typeorm") {
-      await removePath(join13(root, "src", "db", "data-source.ts"));
-      await removePath(join13(root, "src", "db", "data-source.js"));
-      await removePath(join13(root, "src", "db", "entities"));
-      await removePath(join13(root, "src", "db", "migrations"));
+      await removePath(join14(root, "src", "db", "data-source.ts"));
+      await removePath(join14(root, "src", "db", "data-source.js"));
+      await removePath(join14(root, "src", "db", "entities"));
+      await removePath(join14(root, "src", "db", "migrations"));
     }
-    await removeEnvKey(join13(root, ".env.example"), "DATABASE_URL");
-    await removeEnvKey(join13(root, ".env.example"), "NEON_API_KEY");
-    await removeEnvKey(join13(root, ".env.example"), "NEON_PROJECT_ID");
-    await removeEnvKey(join13(root, ".env.example"), "SUPABASE_URL");
-    await removeEnvKey(join13(root, ".env.example"), "SUPABASE_ANON_KEY");
+    await removeEnvKey(join14(root, ".env.example"), "DATABASE_URL");
+    await removeEnvKey(join14(root, ".env.example"), "NEON_API_KEY");
+    await removeEnvKey(join14(root, ".env.example"), "NEON_PROJECT_ID");
+    await removeEnvKey(join14(root, ".env.example"), "SUPABASE_URL");
+    await removeEnvKey(join14(root, ".env.example"), "SUPABASE_ANON_KEY");
   }
   if (category === "orm") {
     if (config.database.orm === "drizzle") {
-      await removePath(join13(root, "drizzle.config.ts"));
-      await removePath(join13(root, "drizzle"));
+      await removePath(join14(root, "drizzle.config.ts"));
+      await removePath(join14(root, "drizzle"));
     }
     if (config.database.orm === "prisma") {
-      await removePath(join13(root, "prisma"));
-      await removePath(join13(root, "src", "db", "prisma.ts"));
-      await removePath(join13(root, "src", "db", "prisma.js"));
-      await removePath(join13(root, "src", "db", "prisma-example.ts"));
-      await removePath(join13(root, "src", "db", "prisma-example.js"));
+      await removePath(join14(root, "prisma"));
+      await removePath(join14(root, "src", "db", "prisma.ts"));
+      await removePath(join14(root, "src", "db", "prisma.js"));
+      await removePath(join14(root, "src", "db", "prisma-example.ts"));
+      await removePath(join14(root, "src", "db", "prisma-example.js"));
     }
     if (config.database.orm === "mongoose") {
-      await removePath(join13(root, "src", "db", "mongoose.ts"));
-      await removePath(join13(root, "src", "db", "mongoose.js"));
-      await removePath(join13(root, "src", "db", "mongoose-model.ts"));
-      await removePath(join13(root, "src", "db", "mongoose-model.js"));
+      await removePath(join14(root, "src", "db", "mongoose.ts"));
+      await removePath(join14(root, "src", "db", "mongoose.js"));
+      await removePath(join14(root, "src", "db", "mongoose-model.ts"));
+      await removePath(join14(root, "src", "db", "mongoose-model.js"));
     }
     if (config.database.orm === "typeorm") {
-      await removePath(join13(root, "src", "db", "data-source.ts"));
-      await removePath(join13(root, "src", "db", "data-source.js"));
-      await removePath(join13(root, "src", "db", "entities"));
-      await removePath(join13(root, "src", "db", "migrations"));
+      await removePath(join14(root, "src", "db", "data-source.ts"));
+      await removePath(join14(root, "src", "db", "data-source.js"));
+      await removePath(join14(root, "src", "db", "entities"));
+      await removePath(join14(root, "src", "db", "migrations"));
     }
   }
   if (category === "feature") {
     const targets = value ? [value] : config.features;
     if (targets.includes("email")) {
-      await removePath(join13(root, "features", "email"));
-      await removeEnvKey(join13(root, ".env.example"), "RESEND_API_KEY");
-      await removePath(join13(root, "src", "lib", "resend.ts"));
-      await removePath(join13(root, "src", "lib", "resend.js"));
+      await removePath(join14(root, "features", "email"));
+      await removeEnvKey(join14(root, ".env.example"), "RESEND_API_KEY");
+      await removePath(join14(root, "src", "lib", "resend.ts"));
+      await removePath(join14(root, "src", "lib", "resend.js"));
     }
     if (targets.includes("storage")) {
-      await removePath(join13(root, "features", "storage"));
-      await removeEnvKey(join13(root, ".env.example"), "CLOUDINARY_URL");
-      await removePath(join13(root, "src", "lib", "storage.ts"));
-      await removePath(join13(root, "src", "lib", "storage.js"));
+      await removePath(join14(root, "features", "storage"));
+      await removeEnvKey(join14(root, ".env.example"), "CLOUDINARY_URL");
+      await removePath(join14(root, "src", "lib", "storage.ts"));
+      await removePath(join14(root, "src", "lib", "storage.js"));
     }
     if (targets.includes("payments")) {
-      await removePath(join13(root, "features", "payments"));
-      await removeEnvKey(join13(root, ".env.example"), "STRIPE_SECRET_KEY");
-      await removePath(join13(root, "src", "lib", "stripe.ts"));
-      await removePath(join13(root, "src", "lib", "stripe.js"));
+      await removePath(join14(root, "features", "payments"));
+      await removeEnvKey(join14(root, ".env.example"), "STRIPE_SECRET_KEY");
+      await removePath(join14(root, "src", "lib", "stripe.ts"));
+      await removePath(join14(root, "src", "lib", "stripe.js"));
     }
     if (targets.includes("analytics")) {
-      await removePath(join13(root, "features", "analytics"));
-      await removeEnvKey(join13(root, ".env.example"), "NEXT_PUBLIC_POSTHOG_KEY");
-      await removeEnvKey(join13(root, ".env.example"), "NEXT_PUBLIC_POSTHOG_HOST");
-      await removePath(join13(root, "src", "lib", "posthog.ts"));
-      await removePath(join13(root, "src", "lib", "posthog.js"));
+      await removePath(join14(root, "features", "analytics"));
+      await removeEnvKey(join14(root, ".env.example"), "NEXT_PUBLIC_POSTHOG_KEY");
+      await removeEnvKey(join14(root, ".env.example"), "NEXT_PUBLIC_POSTHOG_HOST");
+      await removePath(join14(root, "src", "lib", "posthog.ts"));
+      await removePath(join14(root, "src", "lib", "posthog.js"));
     }
     if (targets.includes("error-tracking")) {
-      await removePath(join13(root, "features", "error-tracking"));
-      await removeEnvKey(join13(root, ".env.example"), "SENTRY_DSN");
-      await removePath(join13(root, "src", "lib", "sentry.ts"));
-      await removePath(join13(root, "src", "lib", "sentry.js"));
+      await removePath(join14(root, "features", "error-tracking"));
+      await removeEnvKey(join14(root, ".env.example"), "SENTRY_DSN");
+      await removePath(join14(root, "src", "lib", "sentry.ts"));
+      await removePath(join14(root, "src", "lib", "sentry.js"));
     }
   }
 }
 
 // src/cli/commands/remove.ts
-import { join as join14 } from "path";
+import { join as join15 } from "path";
 function parseFeature2(feature) {
   const parts = feature.split(":");
   if (parts.length !== 2 || !parts[0] || !parts[1]) {
@@ -2798,7 +2823,7 @@ var removeCommand = new Command4("remove").argument("<feature>", "feature to rem
     await writeProjectConfig(cwd, next);
     await syncPackageJson(`${cwd}/package.json`, current, next);
     const readme = buildProjectReadme(next);
-    await writeTextFile(join14(cwd, "README.md"), readme + "\n");
+    await writeTextFile(join15(cwd, "README.md"), readme + "\n");
     logger.info(`Removed ${feature}`);
   } catch (err) {
     logger.error(err instanceof Error ? err.message : String(err));
@@ -2808,13 +2833,13 @@ var removeCommand = new Command4("remove").argument("<feature>", "feature to rem
 
 // src/cli/commands/update.ts
 import { Command as Command5 } from "commander";
-import { join as join15 } from "path";
+import { join as join16 } from "path";
 import { readFile as readFile5 } from "fs/promises";
 var updateCommand = new Command5("update").option("--check", "check for updates").option("--major", "allow major updates").option("--live", "compare against latest registry versions").action(async (options) => {
   try {
     const cwd = process.cwd();
     const config = await readProjectConfig(cwd);
-    const pkgPath = join15(cwd, "package.json");
+    const pkgPath = join16(cwd, "package.json");
     if (options.check) {
       const pkg = JSON.parse(await readFile5(pkgPath, "utf8"));
       const expectedScripts = resolveScripts(config);
@@ -2884,7 +2909,7 @@ var updateCommand = new Command5("update").option("--check", "check for updates"
       await writePackageJson(pkgPath, pkg);
     }
     const readme = buildProjectReadme(config);
-    await writeTextFile(join15(cwd, "README.md"), readme + "\n");
+    await writeTextFile(join16(cwd, "README.md"), readme + "\n");
     logger.info("Project updated.");
   } catch (err) {
     logger.error(err instanceof Error ? err.message : String(err));
@@ -2899,13 +2924,13 @@ function parseMajor(version2) {
 
 // src/cli/commands/doctor.ts
 import { Command as Command6 } from "commander";
-import { existsSync as existsSync4 } from "fs";
-import { join as join17 } from "path";
+import { existsSync as existsSync5 } from "fs";
+import { join as join18 } from "path";
 
 // src/utils/doctor.ts
-import { existsSync as existsSync3 } from "fs";
+import { existsSync as existsSync4 } from "fs";
 import { readFile as readFile6 } from "fs/promises";
-import { join as join16, dirname as dirname4, basename } from "path";
+import { join as join17, dirname as dirname5, basename } from "path";
 function requiredEnvKeys(config) {
   const keys = [];
   if (config.database.provider !== "none") keys.push("DATABASE_URL");
@@ -2934,21 +2959,21 @@ function agentFiles(agent) {
   return files;
 }
 async function checkProject(cwd) {
-  const configPath = join16(cwd, "stackforge.json");
-  const pkgPath = join16(cwd, "package.json");
-  const envPath = join16(cwd, ".env.example");
+  const configPath = join17(cwd, "stackforge.json");
+  const pkgPath = join17(cwd, "package.json");
+  const envPath = join17(cwd, ".env.example");
   const issues = [];
-  if (!existsSync3(configPath)) {
+  if (!existsSync4(configPath)) {
     return {
       issues: ["Missing stackforge.json. Run from a StackForge project root."],
       config: void 0,
       pkgPath,
       envPath,
       hasConfig: false,
-      hasPackageJson: existsSync3(pkgPath)
+      hasPackageJson: existsSync4(pkgPath)
     };
   }
-  if (!existsSync3(pkgPath)) {
+  if (!existsSync4(pkgPath)) {
     return {
       issues: ["Missing package.json"],
       config: await readProjectConfig(cwd),
@@ -2978,7 +3003,7 @@ async function checkProject(cwd) {
     }
   }
   let envContent = "";
-  if (existsSync3(envPath)) {
+  if (existsSync4(envPath)) {
     envContent = await readFile6(envPath, "utf8");
   }
   const envKeys = new Set(
@@ -2991,25 +3016,25 @@ async function checkProject(cwd) {
     }
   }
   for (const agent of config.aiAgents) {
-    const agentRoot = join16(cwd, ".ai-agents", agent);
+    const agentRoot = join17(cwd, ".ai-agents", agent);
     for (const file of agentFiles(agent)) {
-      if (!existsSync3(join16(agentRoot, file))) {
+      if (!existsSync4(join17(agentRoot, file))) {
         issues.push(`Missing AI agent file: .ai-agents/${agent}/${file}`);
       }
     }
-    if (agent === "claude" && !existsSync3(join16(cwd, ".claude", "claude_desktop_config.json"))) {
+    if (agent === "claude" && !existsSync4(join17(cwd, ".claude", "claude_desktop_config.json"))) {
       issues.push("Missing Claude config: .claude/claude_desktop_config.json");
     }
-    if (agent === "codex" && !existsSync3(join16(cwd, ".codex", "functions.json"))) {
+    if (agent === "codex" && !existsSync4(join17(cwd, ".codex", "functions.json"))) {
       issues.push("Missing Codex config: .codex/functions.json");
     }
-    if (agent === "cursor" && !existsSync3(join16(cwd, ".cursor", "extensions.json"))) {
+    if (agent === "cursor" && !existsSync4(join17(cwd, ".cursor", "extensions.json"))) {
       issues.push("Missing Cursor config: .cursor/extensions.json");
     }
-    if (agent === "windsurf" && !existsSync3(join16(cwd, ".windsurf", "cascade.json"))) {
+    if (agent === "windsurf" && !existsSync4(join17(cwd, ".windsurf", "cascade.json"))) {
       issues.push("Missing Windsurf config: .windsurf/cascade.json");
     }
-    if (agent === "tabnine" && !existsSync3(join16(cwd, ".tabnine", "config.json"))) {
+    if (agent === "tabnine" && !existsSync4(join17(cwd, ".tabnine", "config.json"))) {
       issues.push("Missing Tabnine config: .tabnine/config.json");
     }
   }
@@ -3026,7 +3051,7 @@ async function fixProject(result, cwd) {
   const { config, pkgPath, envPath } = result;
   if (!config) return;
   await syncPackageJson(pkgPath, config, config);
-  const envContent = existsSync3(envPath) ? await readFile6(envPath, "utf8") : "";
+  const envContent = existsSync4(envPath) ? await readFile6(envPath, "utf8") : "";
   const envKeys = new Set(
     envContent.split(/\r?\n/).map((line) => line.trim()).filter((line) => line && !line.startsWith("#")).map((line) => line.split("=")[0])
   );
@@ -3035,19 +3060,19 @@ async function fixProject(result, cwd) {
     await appendEnvLine(envPath, `${key}=""`);
   }
   if (config.aiAgents.length > 0) {
-    const base = basename(cwd) === config.projectName ? dirname4(cwd) : cwd;
+    const base = basename(cwd) === config.projectName ? dirname5(cwd) : cwd;
     await generateAiAgentConfigs(base, config);
   }
   const readme = buildProjectReadme(config);
-  await writeTextFile(join16(cwd, "README.md"), readme + "\n");
+  await writeTextFile(join17(cwd, "README.md"), readme + "\n");
 }
 
 // src/cli/commands/doctor.ts
 import { readFile as readFile7 } from "fs/promises";
 var doctorCommand = new Command6("doctor").option("--fix", "apply non-destructive fixes").action(async (options) => {
   const cwd = process.cwd();
-  const configPath = join17(cwd, "stackforge.json");
-  if (!existsSync4(configPath)) {
+  const configPath = join18(cwd, "stackforge.json");
+  if (!existsSync5(configPath)) {
     logger.error("Missing stackforge.json. Run from a StackForge project root.");
     return;
   }
@@ -3065,8 +3090,8 @@ var doctorCommand = new Command6("doctor").option("--fix", "apply non-destructiv
     logger.error("Failed to read stackforge.json");
     return;
   }
-  const pkgPath = join17(cwd, "package.json");
-  if (!existsSync4(pkgPath)) {
+  const pkgPath = join18(cwd, "package.json");
+  if (!existsSync5(pkgPath)) {
     logger.error("Missing package.json");
     return;
   }
@@ -3145,11 +3170,11 @@ var listAgentsCommand = new Command10("list-agents").action(async () => {
 // src/cli/commands/migrate.ts
 import { Command as Command11 } from "commander";
 import { readFile as readFile8, writeFile as writeFile5 } from "fs/promises";
-import { join as join18 } from "path";
+import { join as join19 } from "path";
 var migrateCommand = new Command11("migrate").option("--dry-run", "show planned migration without writing").action(async (options) => {
   try {
     const cwd = process.cwd();
-    const path = join18(cwd, "stackforge.json");
+    const path = join19(cwd, "stackforge.json");
     const raw = await readFile8(path, "utf8");
     const parsed = JSON.parse(raw);
     const current = parsed._schemaVersion ?? 0;
@@ -3239,7 +3264,7 @@ var fixCommand = new Command15("fix").description("apply safe fixes to project c
 
 // src/cli/commands/upgrade.ts
 import { Command as Command16 } from "commander";
-import { join as join19, dirname as dirname5 } from "path";
+import { join as join20, dirname as dirname6 } from "path";
 var upgradeCommand = new Command16("upgrade").option("--preset <name>", "preset to upgrade to").action(async (options) => {
   const cwd = process.cwd();
   const current = await readProjectConfig(cwd);
@@ -3281,8 +3306,8 @@ var upgradeCommand = new Command16("upgrade").option("--preset <name>", "preset
     await cleanupFeature(cwd, current, "feature", feature);
   }
   await writeProjectConfig(cwd, next);
-  await syncPackageJson(join19(cwd, "package.json"), current, next);
-  const root = dirname5(cwd);
+  await syncPackageJson(join20(cwd, "package.json"), current, next);
+  const root = dirname6(cwd);
   await generateFrontendFiles(root, next);
   await generateUiFiles(root, next);
   await generateDatabaseFiles(root, next);
@@ -3290,7 +3315,7 @@ var upgradeCommand = new Command16("upgrade").option("--preset <name>", "preset
   await generateApiFiles(root, next);
   await generateFeatureFiles(root, next);
   const readme = buildProjectReadme(next);
-  await writeTextFile(join19(cwd, "README.md"), readme + "\n");
+  await writeTextFile(join20(cwd, "README.md"), readme + "\n");
   logger.info(`Upgraded project to preset: ${options.preset}`);
 });