create-stackforge 0.0.1

package/dist/cli.js

@@ -0,0 +1,3148 @@
+// src/cli.ts
+import { Command as Command17 } from "commander";
+
+// src/cli/commands/create.ts
+import { Command } from "commander";
+
+// src/cli/prompts/index.ts
+import inquirer from "inquirer";
+
+// src/utils/package-manager.ts
+import { existsSync } from "fs";
+import { unlink } from "fs/promises";
+import { join } from "path";
+var LOCKFILES = [
+  { pm: "pnpm", file: "pnpm-lock.yaml" },
+  { pm: "yarn", file: "yarn.lock" },
+  { pm: "bun", file: "bun.lockb" },
+  { pm: "npm", file: "package-lock.json" }
+];
+function detectPackageManager(cwd) {
+  for (const entry of LOCKFILES) {
+    if (existsSync(join(cwd, entry.file))) {
+      return entry.pm;
+    }
+  }
+  return null;
+}
+async function removeLockfiles(cwd) {
+  for (const entry of LOCKFILES) {
+    const target = join(cwd, entry.file);
+    if (existsSync(target)) {
+      await unlink(target);
+    }
+  }
+}
+
+// src/presets/index.ts
+var presets = {
+  starter: {
+    frontend: { type: "nextjs", language: "ts" },
+    ui: { library: "tailwind" },
+    database: { provider: "postgres", orm: "drizzle" },
+    auth: { provider: "none" },
+    api: { type: "trpc" },
+    features: []
+  },
+  saas: {
+    frontend: { type: "nextjs", language: "ts" },
+    ui: { library: "tailwind" },
+    database: { provider: "postgres", orm: "prisma" },
+    auth: { provider: "nextauth" },
+    api: { type: "trpc" },
+    features: ["email", "payments"]
+  },
+  ecommerce: {
+    frontend: { type: "nextjs", language: "ts" },
+    ui: { library: "tailwind" },
+    database: { provider: "postgres", orm: "prisma" },
+    auth: { provider: "none" },
+    api: { type: "rest" },
+    features: ["payments", "storage"]
+  },
+  blog: {
+    frontend: { type: "nextjs", language: "ts" },
+    ui: { library: "tailwind" },
+    database: { provider: "sqlite", orm: "prisma" },
+    auth: { provider: "none" },
+    api: { type: "rest" },
+    features: ["storage"]
+  },
+  api: {
+    frontend: { type: "vite", language: "ts" },
+    ui: { library: "none" },
+    database: { provider: "postgres", orm: "drizzle" },
+    auth: { provider: "none" },
+    api: { type: "rest" },
+    features: []
+  }
+};
+function getPreset(name) {
+  if (!name) return null;
+  return presets[name] ?? null;
+}
+
+// src/cli/config-builder.ts
+function buildConfig(base) {
+  const preset = getPreset(base.preset);
+  const merged = preset ? {
+    ...base,
+    ...preset,
+    frontend: preset.frontend ?? base.frontend,
+    ui: preset.ui ?? base.ui,
+    database: preset.database ?? base.database,
+    auth: preset.auth ?? base.auth,
+    api: preset.api ?? base.api,
+    features: preset.features ?? base.features,
+    aiAgents: preset.aiAgents ?? base.aiAgents
+  } : base;
+  if (merged.ui.library === "shadcn") {
+    merged.ui = { library: "shadcn" };
+  }
+  return merged;
+}
+
+// src/cli/defaults.ts
+function defaultConfig() {
+  return {
+    projectName: "my-app",
+    packageManager: "npm",
+    frontend: { type: "nextjs", language: "ts" },
+    ui: { library: "none" },
+    database: { provider: "none" },
+    auth: { provider: "none" },
+    api: { type: "none" },
+    features: [],
+    aiAgents: []
+  };
+}
+
+// src/utils/supported.ts
+var supported = {
+  frontend: ["nextjs", "vite"],
+  ui: ["none", "tailwind", "shadcn", "mui", "chakra", "mantine", "antd", "nextui"],
+  database: ["none", "postgres", "mysql", "sqlite", "neon", "supabase"],
+  orm: ["drizzle", "prisma", "mongoose", "typeorm"],
+  auth: ["none", "nextauth", "clerk", "supabase"],
+  api: ["none", "rest", "trpc", "graphql"],
+  agents: ["claude", "copilot", "codex", "gemini", "cursor", "codeium", "windsurf", "tabnine"],
+  features: ["email", "storage", "payments", "analytics", "error-tracking"]
+};
+
+// src/cli/prompts/index.ts
+async function promptForConfig(input) {
+  if (input.skipPrompts) {
+    const base2 = defaultConfig();
+    const merged = {
+      ...base2,
+      projectName: input.projectName ?? base2.projectName,
+      preset: input.preset
+    };
+    return buildConfig(merged);
+  }
+  const detected = detectPackageManager(process.cwd());
+  const answers = await inquirer.prompt([
+    {
+      type: "input",
+      name: "projectName",
+      message: "Project name",
+      default: input.projectName || "my-app"
+    },
+    {
+      type: "list",
+      name: "packageManager",
+      message: "Package manager",
+      choices: [
+        { name: "npm", value: "npm" },
+        { name: "pnpm", value: "pnpm" },
+        { name: "yarn", value: "yarn" },
+        { name: "bun", value: "bun" }
+      ],
+      default: detected || "npm"
+    },
+    {
+      type: "list",
+      name: "frontend",
+      message: "Frontend framework",
+      choices: supported.frontend.map((v) => ({ name: v, value: v }))
+    },
+    {
+      type: "list",
+      name: "language",
+      message: "Language",
+      choices: [
+        { name: "TypeScript", value: "ts" },
+        { name: "JavaScript", value: "js" }
+      ]
+    },
+    {
+      type: "list",
+      name: "uiLibrary",
+      message: "UI library",
+      choices: supported.ui.map((v) => ({ name: v, value: v }))
+    },
+    {
+      type: "list",
+      name: "databaseProvider",
+      message: "Database provider",
+      choices: supported.database.map((v) => ({ name: v, value: v }))
+    },
+    {
+      type: "list",
+      name: "orm",
+      message: "ORM",
+      when: (ans) => ans.databaseProvider !== "none",
+      choices: supported.orm.map((v) => ({ name: v, value: v }))
+    },
+    {
+      type: "list",
+      name: "authProvider",
+      message: "Authentication",
+      choices: supported.auth.map((v) => ({ name: v, value: v }))
+    },
+    {
+      type: "list",
+      name: "apiType",
+      message: "API type",
+      choices: supported.api.map((v) => ({ name: v, value: v }))
+    },
+    {
+      type: "checkbox",
+      name: "features",
+      message: "Additional features",
+      choices: supported.features.map((v) => ({ name: v, value: v }))
+    }
+  ]);
+  const base = {
+    projectName: answers.projectName,
+    packageManager: answers.packageManager,
+    frontend: { type: answers.frontend, language: answers.language },
+    ui: { library: answers.uiLibrary },
+    database: { provider: answers.databaseProvider, orm: answers.orm },
+    auth: { provider: answers.authProvider },
+    api: { type: answers.apiType },
+    features: answers.features ?? [],
+    aiAgents: [],
+    preset: input.preset
+  };
+  return buildConfig(base);
+}
+
+// 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";
+import { dirname } from "path";
+async function ensureDir(path, ctx) {
+  if (ctx?.dryRun) {
+    ctx.log(`dry-run: mkdir ${path}`);
+    return;
+  }
+  await mkdir(path, { recursive: true });
+}
+async function writeTextFile(path, content, ctx) {
+  if (ctx?.dryRun) {
+    ctx.log(`dry-run: write ${path}`);
+    return;
+  }
+  await ensureDir(dirname(path), ctx);
+  await writeFile(path, content, "utf8");
+}
+async function readTextFile(path) {
+  return readFile(path, "utf8");
+}
+async function removePath(path, ctx) {
+  if (ctx?.dryRun) {
+    ctx.log(`dry-run: remove ${path}`);
+    return;
+  }
+  await rm(path, { recursive: true, force: true });
+}
+
+// src/generators/scripts/scripts-registry.ts
+function collectScripts(config) {
+  const scripts = {};
+  if (config.frontend.type === "nextjs") {
+    scripts["dev"] = "next dev";
+    scripts["build"] = "next build";
+    scripts["start"] = "next start";
+    scripts["lint"] = "next lint";
+  }
+  if (config.frontend.type === "vite") {
+    scripts["dev"] = "vite";
+    scripts["build"] = "vite build";
+    scripts["preview"] = "vite preview";
+    if (config.api.type === "rest" || config.api.type === "graphql" || config.api.type === "trpc") {
+      scripts["api:dev"] = config.frontend.language === "ts" ? "tsx src/server/index.ts" : "node src/server/index.js";
+    }
+  }
+  if (config.ui.library === "tailwind") {
+    scripts["css:build"] = "npx tailwindcss -i ./src/styles.css -o ./dist/styles.css";
+    scripts["css:watch"] = "npx tailwindcss -i ./src/styles.css -o ./dist/styles.css --watch";
+  }
+  if (config.database.orm === "drizzle") {
+    scripts["db:generate"] = "npx drizzle-kit generate";
+    scripts["db:migrate"] = "npx drizzle-kit migrate";
+  }
+  if (config.database.orm === "prisma") {
+    scripts["db:generate"] = "npx prisma generate";
+    scripts["db:migrate"] = "npx prisma migrate dev";
+    scripts["db:studio"] = "npx prisma studio";
+  }
+  if (config.ui.library === "shadcn") {
+    scripts["ui:add"] = "npx shadcn-ui@latest add";
+  }
+  if (config.database.orm === "typeorm") {
+    scripts["db:generate"] = "npx typeorm migration:generate";
+    scripts["db:migrate"] = "npx typeorm migration:run";
+  }
+  return scripts;
+}
+
+// src/utils/versions.ts
+var versions = {
+  next: "^16.0.10",
+  react: "^19.0.0",
+  reactDom: "^19.0.0",
+  vite: "^6.0.0",
+  viteReactSwc: "^3.5.0",
+  typescript: "^5.5.4",
+  typesReact: "^19.0.0",
+  typesReactDom: "^19.0.0",
+  typesNode: "^20.14.10",
+  tsx: "^4.16.5",
+  tailwindcss: "^3.4.0",
+  postcss: "^8.4.0",
+  autoprefixer: "^10.4.0",
+  cva: "^0.7.0",
+  clsx: "^2.1.1",
+  tailwindMerge: "^2.4.0",
+  muiMaterial: "^5.16.0",
+  muiEmotionReact: "^11.13.0",
+  muiEmotionStyled: "^11.13.0",
+  chakraUi: "^2.8.2",
+  chakraEmotionReact: "^11.11.0",
+  chakraEmotionStyled: "^11.11.0",
+  chakraFramerMotion: "^11.11.0",
+  mantineCore: "^7.12.0",
+  mantineHooks: "^7.12.0",
+  mantineDates: "^7.12.0",
+  mantineNotifications: "^7.12.0",
+  antd: "^5.20.0",
+  nextui: "^2.4.6",
+  drizzleOrm: "^0.36.0",
+  drizzleKit: "^0.24.0",
+  prisma: "^5.17.0",
+  prismaClient: "^5.17.0",
+  mongoose: "^8.5.0",
+  typeorm: "^0.3.20",
+  reflectMetadata: "^0.2.2",
+  pg: "^8.12.0",
+  typesPg: "^8.11.10",
+  mysql2: "^3.10.0",
+  betterSqlite3: "^9.4.0",
+  neonServerless: "^0.9.5",
+  nextAuth: "^4.24.0",
+  clerkNext: "^5.0.0",
+  supabaseJs: "^2.45.0",
+  supabaseSsr: "^0.5.2",
+  trpcServer: "^10.45.0",
+  trpcClient: "^10.45.0",
+  trpcReactQuery: "^10.45.0",
+  tanstackQuery: "^4.18.0",
+  zod: "^3.23.0",
+  graphql: "^16.9.0",
+  graphqlRequest: "^6.1.0",
+  graphqlYoga: "^5.7.0",
+  resend: "^3.5.0",
+  cloudinary: "^2.0.0",
+  stripe: "^14.0.0",
+  posthog: "^1.165.0",
+  sentryNext: "^8.35.0"
+};
+
+// src/generators/deps/deps-registry.ts
+function collectDependencies(config) {
+  const dependencies = {};
+  const devDependencies = {};
+  if (config.frontend.type === "nextjs") {
+    dependencies["next"] = versions.next;
+    dependencies["react"] = versions.react;
+    dependencies["react-dom"] = versions.reactDom;
+  }
+  if (config.frontend.type === "vite") {
+    dependencies["react"] = versions.react;
+    dependencies["react-dom"] = versions.reactDom;
+    devDependencies["vite"] = versions.vite;
+    devDependencies["@vitejs/plugin-react-swc"] = versions.viteReactSwc;
+    if ((config.api.type === "rest" || config.api.type === "graphql") && config.frontend.language === "ts") {
+      devDependencies["tsx"] = versions.tsx;
+      devDependencies["@types/node"] = versions.typesNode;
+    }
+  }
+  if (config.frontend.language === "ts") {
+    devDependencies["typescript"] = versions.typescript;
+    devDependencies["@types/react"] = versions.typesReact;
+    devDependencies["@types/react-dom"] = versions.typesReactDom;
+  }
+  if (config.ui.library === "tailwind" || config.ui.library === "shadcn") {
+    devDependencies["tailwindcss"] = versions.tailwindcss;
+    devDependencies["postcss"] = versions.postcss;
+    devDependencies["autoprefixer"] = versions.autoprefixer;
+  }
+  if (config.ui.library === "shadcn") {
+    dependencies["class-variance-authority"] = versions.cva;
+    dependencies["clsx"] = versions.clsx;
+    dependencies["tailwind-merge"] = versions.tailwindMerge;
+  }
+  if (config.ui.library === "mui") {
+    dependencies["@mui/material"] = versions.muiMaterial;
+    dependencies["@emotion/react"] = versions.muiEmotionReact;
+    dependencies["@emotion/styled"] = versions.muiEmotionStyled;
+  }
+  if (config.ui.library === "chakra") {
+    dependencies["@chakra-ui/react"] = versions.chakraUi;
+    dependencies["@emotion/react"] = versions.chakraEmotionReact;
+    dependencies["@emotion/styled"] = versions.chakraEmotionStyled;
+    dependencies["framer-motion"] = versions.chakraFramerMotion;
+  }
+  if (config.ui.library === "mantine") {
+    dependencies["@mantine/core"] = versions.mantineCore;
+    dependencies["@mantine/hooks"] = versions.mantineHooks;
+    dependencies["@mantine/dates"] = versions.mantineDates;
+    dependencies["@mantine/notifications"] = versions.mantineNotifications;
+  }
+  if (config.ui.library === "antd") {
+    dependencies["antd"] = versions.antd;
+  }
+  if (config.ui.library === "nextui") {
+    dependencies["@nextui-org/react"] = versions.nextui;
+  }
+  if (config.database.provider === "postgres" || config.database.provider === "neon" || config.database.provider === "supabase") {
+    dependencies["pg"] = versions.pg;
+    if (config.frontend.language === "ts") {
+      devDependencies["@types/pg"] = versions.typesPg;
+    }
+  }
+  if (config.database.provider === "mysql") {
+    dependencies["mysql2"] = versions.mysql2;
+  }
+  if (config.database.provider === "sqlite") {
+    dependencies["better-sqlite3"] = versions.betterSqlite3;
+  }
+  if (config.database.provider === "neon") {
+    dependencies["@neondatabase/serverless"] = versions.neonServerless;
+  }
+  if (config.database.provider === "supabase") {
+    dependencies["@supabase/supabase-js"] = versions.supabaseJs;
+  }
+  if (config.database.orm === "drizzle") {
+    dependencies["drizzle-orm"] = versions.drizzleOrm;
+    devDependencies["drizzle-kit"] = versions.drizzleKit;
+  }
+  if (config.database.orm === "prisma") {
+    devDependencies["prisma"] = versions.prisma;
+    dependencies["@prisma/client"] = versions.prismaClient;
+  }
+  if (config.database.orm === "mongoose") {
+    dependencies["mongoose"] = versions.mongoose;
+  }
+  if (config.database.orm === "typeorm") {
+    dependencies["typeorm"] = versions.typeorm;
+    dependencies["reflect-metadata"] = versions.reflectMetadata;
+  }
+  if (config.auth.provider === "nextauth") {
+    dependencies["next-auth"] = versions.nextAuth;
+  }
+  if (config.auth.provider === "clerk") {
+    dependencies["@clerk/nextjs"] = versions.clerkNext;
+  }
+  if (config.auth.provider === "supabase") {
+    dependencies["@supabase/supabase-js"] = versions.supabaseJs;
+    if (config.frontend.type === "nextjs") {
+      dependencies["@supabase/ssr"] = versions.supabaseSsr;
+    }
+  }
+  if (config.api.type === "trpc") {
+    dependencies["@trpc/server"] = versions.trpcServer;
+    dependencies["@trpc/client"] = versions.trpcClient;
+    dependencies["@trpc/react-query"] = versions.trpcReactQuery;
+    dependencies["@tanstack/react-query"] = versions.tanstackQuery;
+    dependencies["zod"] = versions.zod;
+    if (config.frontend.type === "vite") {
+      devDependencies["tsx"] = versions.tsx;
+      devDependencies["@types/node"] = versions.typesNode;
+    }
+  }
+  if (config.api.type === "graphql") {
+    dependencies["graphql"] = versions.graphql;
+    dependencies["graphql-request"] = versions.graphqlRequest;
+    dependencies["graphql-yoga"] = versions.graphqlYoga;
+  }
+  if (config.features.includes("email")) {
+    dependencies["resend"] = versions.resend;
+  }
+  if (config.features.includes("storage")) {
+    dependencies["cloudinary"] = versions.cloudinary;
+  }
+  if (config.features.includes("payments")) {
+    dependencies["stripe"] = versions.stripe;
+  }
+  if (config.features.includes("analytics")) {
+    dependencies["posthog-js"] = versions.posthog;
+  }
+  if (config.features.includes("error-tracking") && config.frontend.type === "nextjs") {
+    dependencies["@sentry/nextjs"] = versions.sentryNext;
+  }
+  return { dependencies, devDependencies };
+}
+
+// src/generators/core/readme.ts
+function formatDb(config) {
+  if (config.database.provider === "none") return "none";
+  return `${config.database.provider}${config.database.orm ? ` (${config.database.orm})` : ""}`;
+}
+function getDevCommand(config) {
+  if (config.frontend.type === "vite" && (config.api.type === "rest" || config.api.type === "graphql")) {
+    return "npm run dev (frontend) + npm run api:dev (API)";
+  }
+  return "npm run dev";
+}
+function formatFeatures(config) {
+  if (!config.features || config.features.length === 0) return "none";
+  return config.features.join(", ");
+}
+function buildProjectReadme(config) {
+  const featureLinks = config.features.map((f) => `- features/${f}/README.md`).join("\n");
+  return `# ${config.projectName}
+
+Generated by StackForge.
+
+## Stack
+- Frontend: ${config.frontend.type} (${config.frontend.language})
+- UI: ${config.ui.library}
+- Database: ${formatDb(config)}
+- Auth: ${config.auth.provider}
+- API: ${config.api.type}
+- Features: ${formatFeatures(config)}
+
+## Commands
+- Install: ${config.packageManager} install
+- Dev: ${getDevCommand(config)}
+
+${config.features.length ? `## Feature Docs
+${featureLinks}
+` : ""}
+## Notes
+- Update .env values before running in production.
+`;
+}
+
+// src/utils/project-config.ts
+import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+import { join as join2 } from "path";
+
+// src/utils/schema.ts
+var STACKFORGE_SCHEMA_VERSION = 1;
+
+// src/utils/migrations.ts
+function migrateConfig(input) {
+  let current = input._schemaVersion ?? 0;
+  let config = { ...input };
+  if (current < 1) {
+    config = { ...config, _schemaVersion: 1 };
+    current = 1;
+  }
+  if (current !== STACKFORGE_SCHEMA_VERSION) {
+    config._schemaVersion = STACKFORGE_SCHEMA_VERSION;
+  }
+  return config;
+}
+
+// src/utils/project-config.ts
+async function writeProjectConfig(root, config) {
+  const path = join2(root, "stackforge.json");
+  const payload = { ...config, _schemaVersion: STACKFORGE_SCHEMA_VERSION };
+  await writeFile2(path, JSON.stringify(payload, null, 2) + "\n", "utf8");
+}
+async function readProjectConfig(root) {
+  const path = join2(root, "stackforge.json");
+  const raw = await readFile2(path, "utf8");
+  const parsed = JSON.parse(raw);
+  const migrated = migrateConfig(parsed);
+  if (migrated._schemaVersion !== parsed._schemaVersion) {
+    await writeFile2(path, JSON.stringify(migrated, null, 2) + "\n", "utf8");
+  }
+  return migrated;
+}
+
+// src/generators/core/project-creator.ts
+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);
+  const pkg = {
+    name: config.projectName,
+    version: "0.0.0",
+    private: true
+  };
+  const featureScripts = collectScripts(config);
+  const featureDeps = collectDependencies(config);
+  if (Object.keys(featureScripts).length > 0) {
+    pkg.scripts = featureScripts;
+  }
+  pkg.dependencies = featureDeps.dependencies;
+  pkg.devDependencies = featureDeps.devDependencies;
+  await writeTextFile(join3(projectRoot, "package.json"), JSON.stringify(pkg, null, 2) + "\n", ctx);
+  if (!ctx?.dryRun) {
+    await writeProjectConfig(projectRoot, config);
+  }
+  if (config.frontend.language === "ts") {
+    const tsconfig = {
+      compilerOptions: {
+        target: "ES2022",
+        module: "ESNext",
+        moduleResolution: "Bundler",
+        strict: true,
+        jsx: "preserve",
+        baseUrl: ".",
+        paths: {
+          "@/*": ["src/*"]
+        },
+        esModuleInterop: true,
+        resolveJsonModule: true,
+        incremental: true,
+        noEmit: true,
+        forceConsistentCasingInFileNames: true,
+        skipLibCheck: true
+      },
+      include: ["src", "app"]
+    };
+    await writeTextFile(join3(projectRoot, "tsconfig.json"), JSON.stringify(tsconfig, null, 2) + "\n", ctx);
+  }
+}
+
+// src/generators/database/database-files.ts
+import { join as join4 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+
+// src/utils/env-file.ts
+import { readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
+import { dirname as dirname2 } from "path";
+async function appendEnvLine(path, line, ctx) {
+  if (ctx?.dryRun) {
+    ctx.log(`dry-run: append ${path} -> ${line}`);
+    return;
+  }
+  await ensureDir(dirname2(path), ctx);
+  let existing = "";
+  try {
+    existing = await readFile3(path, "utf8");
+  } catch {
+    existing = "";
+  }
+  const normalized = existing.endsWith("\n") || existing.length === 0 ? existing : existing + "\n";
+  const content = normalized + line + (line.endsWith("\n") ? "" : "\n");
+  await writeFile3(path, content, "utf8");
+}
+async function removeEnvKey(path, key, ctx) {
+  if (ctx?.dryRun) {
+    ctx.log(`dry-run: remove env ${key} from ${path}`);
+    return;
+  }
+  let existing = "";
+  try {
+    existing = await readFile3(path, "utf8");
+  } catch {
+    return;
+  }
+  const lines = existing.split(/\r?\n/).filter((line) => line.trim() !== "");
+  const filtered = lines.filter((line) => !line.startsWith(`${key}=`) && !line.startsWith(`${key}="`));
+  await writeFile3(path, filtered.join("\n") + (filtered.length ? "\n" : ""), "utf8");
+}
+
+// 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));
+  if (config.database.provider !== "none") {
+    const envPath = join4(projectRoot, ".env.example");
+    await appendEnvLine(envPath, 'DATABASE_URL=""', 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");
+      await ensureDir(providerDir, ctx);
+      const providerReadme = await readTextFile(join4(templatesRoot, "database", "providers", "neon.README.md"));
+      await writeTextFile(join4(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");
+      await ensureDir(providerDir, ctx);
+      const providerReadme = await readTextFile(join4(templatesRoot, "database", "providers", "supabase.README.md"));
+      await writeTextFile(join4(providerDir, "README.md"), providerReadme, ctx);
+    }
+  }
+  if (config.database.orm === "drizzle") {
+    const drizzleDir = join4(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 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);
+  }
+  if (config.database.orm === "prisma") {
+    const prismaDir = join4(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");
+    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);
+  }
+  if (config.database.orm === "mongoose") {
+    const dbDir = join4(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);
+  }
+  if (config.database.orm === "typeorm") {
+    const dbDir = join4(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 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 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");
+    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);
+  }
+  if (config.database.orm === "drizzle") {
+    const dbDir = join4(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);
+  }
+}
+
+// src/generators/frontend/frontend-files.ts
+import { join as join5 } from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
+
+// src/generators/templates/template-engine.ts
+function applyTemplate(content, vars) {
+  let out = content;
+  for (const [key, value] of Object.entries(vars)) {
+    out = out.replaceAll(`{{${key}}}`, value);
+  }
+  return out;
+}
+
+// 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));
+  if (config.frontend.type === "nextjs") {
+    const appDir = join5(projectRoot, "app");
+    await ensureDir(appDir, ctx);
+    const uiCssImports = buildUiCssImports(config, "nextjs");
+    const importCss = uiCssImports.length ? uiCssImports.join("") + "\n" : "";
+    const hasTrpc = config.api.type === "trpc";
+    const hasUiProvider = requiresUiProvider(config);
+    const hasProviders = hasTrpc || hasUiProvider;
+    const providersImport = hasProviders ? "import { Providers } from './providers';\n" : "";
+    const wrapChildren = hasProviders ? "<Providers>{children}</Providers>" : "{children}";
+    const layoutTemplatePath = join5(
+      templatesRoot,
+      "nextjs",
+      "app",
+      config.frontend.language === "ts" ? "layout.tsx" : "layout.jsx"
+    );
+    const pageTemplatePath = join5(
+      templatesRoot,
+      "nextjs",
+      "app",
+      config.frontend.language === "ts" ? "page.tsx" : "page.jsx"
+    );
+    const actionsTemplatePath = join5(
+      templatesRoot,
+      "nextjs",
+      "app",
+      config.frontend.language === "ts" ? "actions.ts" : "actions.js"
+    );
+    const nextConfigTemplatePath = join5(
+      templatesRoot,
+      "nextjs",
+      config.frontend.language === "ts" ? "next.config.ts" : "next.config.js"
+    );
+    const layoutTemplate = await readTextFile(layoutTemplatePath);
+    const pageTemplate = await readTextFile(pageTemplatePath);
+    const examplesTemplate = await readTextFile(
+      join5(
+        templatesRoot,
+        "nextjs",
+        "app",
+        config.frontend.language === "ts" ? "examples-page.tsx" : "examples-page.jsx"
+      )
+    );
+    const nextConfigTemplate = await readTextFile(nextConfigTemplatePath);
+    const actionsTemplate = await readTextFile(actionsTemplatePath);
+    const layout = applyTemplate(layoutTemplate, {
+      importCss,
+      providersImport,
+      wrapChildren
+    });
+    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"),
+      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);
+    if (config.api.type !== "none") {
+      const examplesDir = join5(appDir, "examples");
+      await ensureDir(examplesDir, ctx);
+      const { imports, components } = buildApiExamples(config, "nextjs");
+      const featureNotes = buildFeatureNotes(config);
+      const { uiDemoImport, uiDemoComponent } = buildUiDemoTokens(config, "nextjs");
+      const examplesPage = applyTemplate(examplesTemplate, {
+        imports,
+        components,
+        featureNotes,
+        uiDemoImport,
+        uiDemoComponent
+      });
+      await writeTextFile(
+        join5(examplesDir, config.frontend.language === "ts" ? "page.tsx" : "page.jsx"),
+        examplesPage,
+        ctx
+      );
+    }
+    if (hasProviders) {
+      const providers = buildProvidersComponent(config, "nextjs");
+      await writeTextFile(
+        join5(appDir, config.frontend.language === "ts" ? "providers.tsx" : "providers.jsx"),
+        providers,
+        ctx
+      );
+    }
+  }
+  if (config.frontend.type === "vite") {
+    const srcDir = join5(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 mainTemplate = await readTextFile(mainTemplatePath);
+    const appTemplate = await readTextFile(appTemplatePath);
+    const indexTemplate = await readTextFile(indexTemplatePath);
+    const viteConfigTemplate = await readTextFile(viteConfigTemplatePath);
+    const viteEnvTemplate = await readTextFile(viteEnvTemplatePath);
+    const hasTrpc = config.api.type === "trpc";
+    const hasUiProvider = requiresUiProvider(config);
+    const hasProviders = hasTrpc || hasUiProvider;
+    const providersImport = hasProviders ? "import { Providers } from './providers';\n" : "";
+    const wrapApp = hasProviders ? "<Providers><App /></Providers>" : "<App />";
+    const { initImports, initCalls } = buildFeatureInit(config, "vite");
+    const main = applyTemplate(mainTemplate, {
+      importCss: cssImport,
+      providersImport,
+      wrapApp,
+      initImports,
+      initCalls
+    });
+    const { imports, components } = buildApiExamples(config, "vite");
+    const featureNotes = buildFeatureNotes(config);
+    const { uiDemoImport, uiDemoComponent } = buildUiDemoTokens(config, "vite");
+    const apiImports = imports ? imports + "\n" : "";
+    const apiExamples = components || "";
+    const app = applyTemplate(appTemplate, {
+      projectName: config.projectName,
+      apiImports,
+      apiExamples,
+      featureNotes,
+      uiDemoImport,
+      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);
+    if (config.frontend.language === "ts") {
+      await writeTextFile(join5(srcDir, "vite-env.d.ts"), viteEnvTemplate, ctx);
+    }
+    await appendEnvLine(join5(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);
+    }
+  }
+}
+function buildUiCssImports(config, target) {
+  const imports = [];
+  const tailwindPath = target === "nextjs" ? "../src/styles.css" : "./styles.css";
+  if (config.ui.library === "tailwind") {
+    imports.push(`import '${tailwindPath}';
+`);
+  }
+  if (config.ui.library === "mantine") {
+    imports.push("import '@mantine/core/styles.css';\n");
+    imports.push("import '@mantine/dates/styles.css';\n");
+    imports.push("import '@mantine/notifications/styles.css';\n");
+  }
+  if (config.ui.library === "antd") {
+    imports.push("import 'antd/dist/reset.css';\n");
+  }
+  return imports;
+}
+function requiresUiProvider(config) {
+  return ["mui", "chakra", "mantine", "antd", "nextui"].includes(config.ui.library);
+}
+function buildProvidersComponent(config, target) {
+  const hasTrpc = config.api.type === "trpc";
+  const ui = config.ui.library;
+  const needsTheme = ["mui", "chakra", "mantine", "antd", "nextui"].includes(ui);
+  const isTypescript = config.frontend.language === "ts";
+  const hasFeatureInit = config.features.includes("analytics") || config.features.includes("error-tracking");
+  const themeImportPath = target === "nextjs" ? "../src/theme" : "./theme";
+  const imports = [];
+  const lines = [];
+  if (target === "nextjs") {
+    lines.push('"use client";\n');
+  }
+  if (hasTrpc && isTypescript) {
+    imports.push("import type React from 'react';");
+    imports.push("import { useState, useEffect } from 'react';");
+  } else if (hasTrpc) {
+    imports.push("import { useState, useEffect } from 'react';");
+  } else if (isTypescript) {
+    imports.push("import type React from 'react';");
+    if (hasFeatureInit) {
+      imports.push("import { useEffect } from 'react';");
+    }
+  } else if (hasFeatureInit) {
+    imports.push("import { useEffect } from 'react';");
+  }
+  if (hasTrpc) {
+    imports.push("import { QueryClient, QueryClientProvider } from '@tanstack/react-query';");
+  }
+  if (ui === "mui") {
+    imports.push("import { ThemeProvider, CssBaseline } from '@mui/material';");
+  }
+  if (ui === "chakra") {
+    imports.push("import { ChakraProvider } from '@chakra-ui/react';");
+  }
+  if (ui === "mantine") {
+    imports.push("import { MantineProvider } from '@mantine/core';");
+  }
+  if (ui === "antd") {
+    imports.push("import { ConfigProvider } from 'antd';");
+  }
+  if (ui === "nextui") {
+    imports.push("import { NextUIProvider } from '@nextui-org/react';");
+  }
+  if (needsTheme) {
+    imports.push(`import { theme } from '${themeImportPath}';`);
+  }
+  if (config.features.includes("analytics")) {
+    const analyticsPath = target === "nextjs" ? "../src/lib/posthog" : "./lib/posthog";
+    imports.push(`import { initPosthog } from '${analyticsPath}';`);
+  }
+  if (config.features.includes("error-tracking")) {
+    const sentryPath = target === "nextjs" ? "../src/lib/sentry" : "./lib/sentry";
+    imports.push(`import { initSentry } from '${sentryPath}';`);
+  }
+  lines.push(imports.join("\n") + "\n");
+  const propsType = isTypescript ? ": { children: React.ReactNode }" : "";
+  lines.push(`export function Providers({ children }${propsType}) {
+`);
+  if (hasTrpc) {
+    lines.push("  const [client] = useState(() => new QueryClient());\n\n");
+  }
+  if (hasFeatureInit) {
+    lines.push("  useEffect(() => {\n");
+    if (config.features.includes("analytics")) {
+      lines.push("    initPosthog();\n");
+    }
+    if (config.features.includes("error-tracking")) {
+      lines.push("    initSentry();\n");
+    }
+    lines.push("  }, []);\n\n");
+  }
+  let body = "{children}";
+  if (ui === "mui") {
+    body = "<ThemeProvider theme={theme}><CssBaseline />{children}</ThemeProvider>";
+  } else if (ui === "chakra") {
+    body = "<ChakraProvider theme={theme}>{children}</ChakraProvider>";
+  } else if (ui === "mantine") {
+    body = "<MantineProvider theme={theme}>{children}</MantineProvider>";
+  } else if (ui === "antd") {
+    body = "<ConfigProvider theme={theme}>{children}</ConfigProvider>";
+  } else if (ui === "nextui") {
+    body = "<NextUIProvider theme={theme}>{children}</NextUIProvider>";
+  }
+  if (hasTrpc) {
+    body = `<QueryClientProvider client={client}>${body}</QueryClientProvider>`;
+  }
+  lines.push(`  return ${body};
+`);
+  lines.push("}\n");
+  return lines.join("");
+}
+function buildFeatureInit(config, target) {
+  if (target !== "vite") return { initImports: "", initCalls: "" };
+  const imports = [];
+  const calls = [];
+  if (config.features.includes("analytics")) {
+    imports.push("import { initPosthog } from './lib/posthog';");
+    calls.push("initPosthog();");
+  }
+  if (config.features.includes("error-tracking")) {
+    imports.push("import { initSentry } from './lib/sentry';");
+    calls.push("initSentry();");
+  }
+  return {
+    initImports: imports.length ? imports.join("\n") + "\n" : "",
+    initCalls: calls.length ? calls.join("\n") + "\n" : ""
+  };
+}
+function buildApiExamples(config, target) {
+  if (config.api.type === "none") {
+    return { imports: "", components: "" };
+  }
+  const imports = [];
+  const components = [];
+  if (config.api.type === "rest") {
+    const path = target === "nextjs" ? "../../src/api/client-usage" : "./api/client-usage";
+    imports.push(`import { RestExample } from '${path}';`);
+    components.push("<RestExample />");
+  }
+  if (config.api.type === "graphql") {
+    const path = target === "nextjs" ? "../../src/graphql/client-usage" : "./graphql/client-usage";
+    imports.push(`import { GraphqlExample } from '${path}';`);
+    components.push("<GraphqlExample />");
+  }
+  if (config.api.type === "trpc") {
+    const path = target === "nextjs" ? "../../src/trpc/client-usage" : "./trpc/client-usage";
+    imports.push(`import { TrpcExample } from '${path}';`);
+    components.push("<TrpcExample />");
+  }
+  return { imports: imports.join("\n") + "\n", components: components.join("\n      ") };
+}
+function buildFeatureNotes(config) {
+  const notes = [];
+  if (config.features.includes("analytics")) notes.push("<p>Analytics enabled (PostHog).</p>");
+  if (config.features.includes("error-tracking")) notes.push("<p>Error tracking enabled (Sentry).</p>");
+  if (config.features.includes("email")) notes.push("<p>Email feature enabled (Resend).</p>");
+  if (config.features.includes("payments")) notes.push("<p>Payments feature enabled (Stripe).</p>");
+  if (config.features.includes("storage")) notes.push("<p>Storage feature enabled (Cloudinary).</p>");
+  if (!notes.length) return "";
+  return notes.join("\n      ");
+}
+function buildUiDemoTokens(config, target) {
+  if (config.ui.library === "none") {
+    return { uiDemoImport: "", uiDemoComponent: "" };
+  }
+  const importPath = target === "nextjs" ? "../../src/components/ui-demo" : "./components/ui-demo";
+  return {
+    uiDemoImport: `import { UiDemo } from '${importPath}';
+`,
+    uiDemoComponent: "<UiDemo />"
+  };
+}
+function buildPageLinks(config) {
+  const items = [];
+  if (config.api.type === "rest") {
+    items.push('<li><Link href="/api/hello">REST hello</Link></li>');
+  }
+  if (config.api.type === "graphql") {
+    items.push('<li><Link href="/api/graphql">GraphQL endpoint</Link></li>');
+  }
+  if (config.api.type !== "none") {
+    items.push('<li><Link href="/examples">API examples</Link></li>');
+  }
+  if (config.auth.provider !== "none") {
+    items.push('<li><Link href="/auth/protected">Auth protected page</Link></li>');
+  }
+  return items.join("\n        ");
+}
+
+// src/generators/ui/ui-files.ts
+import { join as join6 } from "path";
+import { fileURLToPath as fileURLToPath4 } from "url";
+async function generateUiFiles(root, config, ctx) {
+  const projectRoot = join6(root, config.projectName);
+  const templatesRoot = fileURLToPath4(new URL("../../../templates", import.meta.url));
+  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");
+    await ensureDir(stylesDir, ctx);
+    await writeTextFile(join6(stylesDir, "styles.css"), stylesTemplate, ctx);
+    const demo = await readTextFile(
+      join6(templatesRoot, "ui", config.frontend.language === "ts" ? "demo-tailwind.tsx" : "demo-tailwind.jsx")
+    );
+    await ensureDir(join6(projectRoot, "src", "components"), ctx);
+    await writeTextFile(
+      join6(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);
+    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 buttonTemplate = await readTextFile(
+      join6(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);
+    const demo = await readTextFile(
+      join6(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"),
+      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(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 demo = await readTextFile(
+      join6(templatesRoot, "ui", `demo-${config.ui.library}.${config.frontend.language === "ts" ? "tsx" : "jsx"}`)
+    );
+    await ensureDir(join6(srcDir, "components"), ctx);
+    await writeTextFile(
+      join6(srcDir, "components", config.frontend.language === "ts" ? "ui-demo.tsx" : "ui-demo.jsx"),
+      demo,
+      ctx
+    );
+  }
+}
+
+// src/generators/auth/auth-files.ts
+import { join as join7 } from "path";
+import { fileURLToPath as fileURLToPath5 } from "url";
+async function generateAuthFiles(root, config, ctx) {
+  const projectRoot = join7(root, config.projectName);
+  const templatesRoot = fileURLToPath5(new URL("../../../templates", import.meta.url));
+  if (config.auth.provider === "nextauth") {
+    await appendEnvLine(join7(projectRoot, ".env.example"), 'NEXTAUTH_SECRET=""', ctx);
+    await appendEnvLine(join7(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]");
+      await ensureDir(routeDir, ctx);
+      const route = await readTextFile(join7(templatesRoot, "auth", "nextauth-route.ts"));
+      await writeTextFile(join7(routeDir, config.frontend.language === "ts" ? "route.ts" : "route.js"), route, ctx);
+    }
+    const authDir = join7(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);
+    if (config.frontend.type === "nextjs") {
+      const protectedDir = join7(projectRoot, "app", "auth", "protected");
+      await ensureDir(protectedDir, ctx);
+      const protectedPage = await readTextFile(
+        join7(templatesRoot, "auth", `nextauth-protected-page.${ext}x`)
+      );
+      await writeTextFile(join7(protectedDir, `page.${ext}x`), protectedPage, ctx);
+      const signInDir = join7(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);
+    } else {
+      const protectedPage = await readTextFile(join7(templatesRoot, "auth", `nextauth-protected.${ext}x`));
+      await writeTextFile(join7(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 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);
+    if (config.frontend.type === "nextjs") {
+      const middleware = `import { authMiddleware } from '@clerk/nextjs';
+
+export default authMiddleware();
+
+export const config = {
+  matcher: ['/((?!.*\\..*|_next).*)', '/', '/(api|trpc)(.*)']
+};
+`;
+      await writeTextFile(join7(projectRoot, `middleware.${ext}`), middleware, ctx);
+    }
+    const authDir = join7(projectRoot, "auth");
+    await ensureDir(authDir, ctx);
+    const readme = await readTextFile(join7(templatesRoot, "auth", "clerk.README.md"));
+    await writeTextFile(join7(authDir, "README.md"), readme, ctx);
+    if (config.frontend.type === "nextjs") {
+      const protectedDir = join7(projectRoot, "app", "auth", "protected");
+      await ensureDir(protectedDir, ctx);
+      const protectedPage = await readTextFile(
+        join7(templatesRoot, "auth", `clerk-protected-page.${ext}x`)
+      );
+      await writeTextFile(join7(protectedDir, `page.${ext}x`), protectedPage, ctx);
+      const signInDir = join7(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);
+    } else {
+      const protectedPage = await readTextFile(join7(templatesRoot, "auth", `clerk-protected.${ext}x`));
+      await writeTextFile(join7(authDir, `protected.${ext}x`), protectedPage, 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 ensureDir(libDir, ctx);
+    const supabaseClient = `import { createClient } from '@supabase/supabase-js';
+
+const url = process.env.NEXT_PUBLIC_SUPABASE_URL || '';
+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);
+    if (config.frontend.type === "nextjs") {
+      const supabaseServer = `import { createServerClient } from '@supabase/ssr';
+import { cookies } from 'next/headers';
+
+export function createSupabaseServerClient() {
+  const cookieStore = cookies();
+  return createServerClient(
+    process.env.NEXT_PUBLIC_SUPABASE_URL || '',
+    process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY || '',
+    {
+      cookies: {
+        get(name) {
+          return cookieStore.get(name)?.value;
+        }
+      }
+    }
+  );
+}
+`;
+      await writeTextFile(join7(libDir, `supabase-server.${ext}`), supabaseServer, ctx);
+    }
+    const authDir = join7(projectRoot, "auth");
+    await ensureDir(authDir, ctx);
+    const readme = await readTextFile(join7(templatesRoot, "auth", "supabase.README.md"));
+    await writeTextFile(join7(authDir, "README.md"), readme, ctx);
+    if (config.frontend.type === "nextjs") {
+      const protectedDir = join7(projectRoot, "app", "auth", "protected");
+      await ensureDir(protectedDir, ctx);
+      const protectedPage = await readTextFile(
+        join7(templatesRoot, "auth", `supabase-protected-page.${ext}x`)
+      );
+      await writeTextFile(join7(protectedDir, `page.${ext}x`), protectedPage, ctx);
+      const signInDir = join7(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);
+    } else {
+      const protectedPage = await readTextFile(join7(templatesRoot, "auth", `supabase-protected.${ext}x`));
+      await writeTextFile(join7(authDir, `protected.${ext}x`), protectedPage, ctx);
+      const signin = await readTextFile(
+        join7(templatesRoot, "auth", `supabase-vite-signin.${ext}x`)
+      );
+      const authUiDir = join7(projectRoot, "src", "auth");
+      await ensureDir(authUiDir, ctx);
+      await writeTextFile(join7(authUiDir, `signin.${ext}x`), signin, ctx);
+    }
+  }
+}
+
+// src/generators/api/api-files.ts
+import { join as join8 } from "path";
+import { fileURLToPath as fileURLToPath6 } from "url";
+async function generateApiFiles(root, config, ctx) {
+  const projectRoot = join8(root, config.projectName);
+  const templatesRoot = fileURLToPath6(new URL("../../../templates", import.meta.url));
+  if (config.api.type === "rest") {
+    const apiDir = join8(projectRoot, "api");
+    await ensureDir(apiDir, ctx);
+    await writeTextFile(
+      join8(apiDir, "README.md"),
+      `# REST API
+
+## Overview
+- Next.js: app/api/hello/route.(ts|js) provides a sample GET route.
+- If a database is selected, app/api/users/route.(ts|js) includes CRUD examples.
+- Vite: src/server/index.(ts|js) hosts the API server (run npm run api:dev).
+
+## Client usage
+- src/api/client.(ts|js) wraps fetch helpers.
+- src/api/client-usage.(tsx|jsx) shows usage in the UI.
+- For Vite, set VITE_API_URL in .env to point at the API server.
+`,
+      ctx
+    );
+    if (config.frontend.type === "nextjs") {
+      const routeDir = join8(projectRoot, "app", "api", "hello");
+      await ensureDir(routeDir, ctx);
+      const handler = await readTextFile(join8(templatesRoot, "api", "rest", "route.ts"));
+      await writeTextFile(join8(routeDir, config.frontend.language === "ts" ? "route.ts" : "route.js"), handler, ctx);
+      if (config.database.orm) {
+        const usersDir = join8(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")
+        );
+        await writeTextFile(
+          join8(usersDir, config.frontend.language === "ts" ? "route.ts" : "route.js"),
+          usersRoute,
+          ctx
+        );
+      }
+    }
+    if (config.frontend.type === "vite") {
+      const serverDir = join8(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")
+      );
+      await writeTextFile(
+        join8(serverDir, config.frontend.language === "ts" ? "index.ts" : "index.js"),
+        serverTemplate,
+        ctx
+      );
+    }
+    const clientDir = join8(projectRoot, "src", "api");
+    await ensureDir(clientDir, ctx);
+    const client = await readTextFile(
+      join8(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);
+    const usage = await readTextFile(
+      join8(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"),
+      usage,
+      ctx
+    );
+  }
+  if (config.api.type === "trpc") {
+    const apiDir = join8(projectRoot, "api");
+    await ensureDir(apiDir, ctx);
+    await writeTextFile(
+      join8(apiDir, "README.md"),
+      `# tRPC Setup
+
+## Overview
+- Router lives in src/server/api/trpc.ts and src/server/api/root.ts.
+- Next.js: app/api/trpc/[trpc]/route.(ts|js) wires the handler.
+- Vite: src/server/index.(ts|js) runs the API server (npm run api:dev).
+
+## Client usage
+- src/trpc/client.(ts|js) configures the tRPC client.
+- src/trpc/client-usage.(tsx|jsx) shows usage in the UI.
+- For Vite, set VITE_API_URL in .env to point at the API server.
+`,
+      ctx
+    );
+    if (config.frontend.type === "nextjs") {
+      const trpcDir = join8(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]");
+      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");
+      await ensureDir(clientDir, ctx);
+      const client = await readTextFile(
+        join8(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);
+      const usage = await readTextFile(
+        join8(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"),
+        usage,
+        ctx
+      );
+    }
+    if (config.frontend.type === "vite") {
+      const trpcDir = join8(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");
+      await ensureDir(clientDir, ctx);
+      const client = await readTextFile(
+        join8(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);
+      const usage = await readTextFile(
+        join8(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"),
+        usage,
+        ctx
+      );
+      const serverDir = join8(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")
+      );
+      await writeTextFile(
+        join8(serverDir, config.frontend.language === "ts" ? "index.ts" : "index.js"),
+        serverTemplate,
+        ctx
+      );
+    }
+  }
+  if (config.api.type === "graphql") {
+    const apiDir = join8(projectRoot, "api");
+    await ensureDir(apiDir, ctx);
+    await writeTextFile(
+      join8(apiDir, "README.md"),
+      `# GraphQL Setup
+
+## Overview
+- Schema in src/graphql/schema.graphql.
+- Next.js: app/api/graphql/route.(ts|js) runs the Yoga handler.
+- Vite: src/server/index.(ts|js) runs the API server (npm run api:dev).
+
+## Client usage
+- src/graphql/client.(ts|js) configures the GraphQL client.
+- src/graphql/client-usage.(tsx|jsx) shows usage in the UI.
+- For Vite, set VITE_API_URL in .env to point at the API server.
+`,
+      ctx
+    );
+    if (config.frontend.type === "nextjs") {
+      const gqlDir = join8(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");
+      await ensureDir(routeDir, ctx);
+      const handler = await readTextFile(join8(templatesRoot, "api", "graphql", "route.ts"));
+      await writeTextFile(join8(routeDir, config.frontend.language === "ts" ? "route.ts" : "route.js"), handler, ctx);
+      const clientDir = join8(projectRoot, "src", "graphql");
+      const client = await readTextFile(
+        join8(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);
+      const usage = await readTextFile(
+        join8(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"),
+        usage,
+        ctx
+      );
+    }
+    if (config.frontend.type === "vite") {
+      const gqlDir = join8(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");
+      await ensureDir(serverDir, ctx);
+      const serverTemplate = await readTextFile(
+        join8(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"),
+        serverTemplate,
+        ctx
+      );
+      const clientDir = join8(projectRoot, "src", "graphql");
+      const client = await readTextFile(
+        join8(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);
+      const usage = await readTextFile(
+        join8(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"),
+        usage,
+        ctx
+      );
+    }
+  }
+}
+
+// src/ai-agents/config-generator.ts
+import { join as join9 } from "path";
+import { existsSync as existsSync2 } from "fs";
+function buildAgentContext(config) {
+  return {
+    stack: {
+      frontend: config.frontend,
+      ui: config.ui,
+      database: config.database,
+      auth: config.auth,
+      api: config.api
+    },
+    features: config.features,
+    aiAgents: config.aiAgents,
+    hints: buildHints(config)
+  };
+}
+function buildTools(config) {
+  const tools = [];
+  if (config.database.provider !== "none") tools.push("database");
+  if (config.database.orm) tools.push("orm");
+  if (config.api.type !== "none") tools.push("api");
+  if (config.auth.provider !== "none") tools.push("auth");
+  if (config.features.includes("email")) tools.push("email");
+  if (config.features.includes("storage")) tools.push("storage");
+  if (config.features.includes("payments")) tools.push("payments");
+  if (config.features.includes("analytics")) tools.push("analytics");
+  if (config.features.includes("error-tracking")) tools.push("error-tracking");
+  return tools;
+}
+function buildFunctionDefinitions(tools) {
+  return tools.map((tool) => {
+    switch (tool) {
+      case "database":
+        return {
+          name: "stackforge_database",
+          description: "Inspect database connection and configuration.",
+          parameters: {
+            type: "object",
+            properties: {
+              action: { type: "string", enum: ["status", "env", "client-paths"] }
+            },
+            required: ["action"]
+          }
+        };
+      case "orm":
+        return {
+          name: "stackforge_orm",
+          description: "Inspect ORM configuration and schema locations.",
+          parameters: {
+            type: "object",
+            properties: {
+              action: { type: "string", enum: ["schema", "migrations", "examples"] }
+            },
+            required: ["action"]
+          }
+        };
+      case "api":
+        return {
+          name: "stackforge_api",
+          description: "Inspect API routes and clients.",
+          parameters: {
+            type: "object",
+            properties: {
+              action: { type: "string", enum: ["routes", "clients", "examples"] }
+            },
+            required: ["action"]
+          }
+        };
+      case "auth":
+        return {
+          name: "stackforge_auth",
+          description: "Inspect auth routes and helpers.",
+          parameters: {
+            type: "object",
+            properties: {
+              action: { type: "string", enum: ["routes", "helpers", "env"] }
+            },
+            required: ["action"]
+          }
+        };
+      case "email":
+        return {
+          name: "stackforge_email",
+          description: "Inspect email client and docs.",
+          parameters: {
+            type: "object",
+            properties: {
+              action: { type: "string", enum: ["client", "docs", "env"] }
+            },
+            required: ["action"]
+          }
+        };
+      case "storage":
+        return {
+          name: "stackforge_storage",
+          description: "Inspect storage setup.",
+          parameters: {
+            type: "object",
+            properties: {
+              action: { type: "string", enum: ["docs", "env"] }
+            },
+            required: ["action"]
+          }
+        };
+      case "payments":
+        return {
+          name: "stackforge_payments",
+          description: "Inspect payments setup.",
+          parameters: {
+            type: "object",
+            properties: {
+              action: { type: "string", enum: ["client", "docs", "env"] }
+            },
+            required: ["action"]
+          }
+        };
+      case "analytics":
+        return {
+          name: "stackforge_analytics",
+          description: "Inspect analytics setup.",
+          parameters: {
+            type: "object",
+            properties: {
+              action: { type: "string", enum: ["client", "env"] }
+            },
+            required: ["action"]
+          }
+        };
+      case "error-tracking":
+        return {
+          name: "stackforge_error-tracking",
+          description: "Inspect error tracking setup.",
+          parameters: {
+            type: "object",
+            properties: {
+              action: { type: "string", enum: ["client", "env"] }
+            },
+            required: ["action"]
+          }
+        };
+      default:
+        return {
+          name: `stackforge_${tool}`,
+          description: `Access ${tool} helpers for this project.`,
+          parameters: {
+            type: "object",
+            properties: {
+              action: { type: "string" }
+            },
+            required: ["action"]
+          }
+        };
+    }
+  });
+}
+function buildHints(config) {
+  const hints = [];
+  if (config.api.type === "trpc") hints.push("tRPC router at src/server/api/root.ts");
+  if (config.api.type === "graphql") hints.push("GraphQL schema at src/graphql/schema.graphql");
+  if (config.api.type === "rest") {
+    hints.push(
+      config.frontend.type === "nextjs" ? "REST route at app/api/hello/route.ts" : "REST server at src/server/index.ts"
+    );
+  }
+  if (config.database.orm === "drizzle") hints.push("Drizzle schema at drizzle/schema.ts");
+  if (config.database.orm === "prisma") hints.push("Prisma schema at prisma/schema.prisma");
+  if (config.database.orm === "mongoose") hints.push("Mongoose connection at src/db/mongoose.ts");
+  if (config.database.orm === "typeorm") hints.push("TypeORM data source at src/db/data-source.ts");
+  if (config.ui.library === "mui") hints.push("MUI components docs in components/README.md");
+  if (config.ui.library === "chakra") hints.push("Chakra UI docs in components/README.md");
+  if (config.ui.library === "mantine") hints.push("Mantine docs in components/README.md");
+  if (config.ui.library === "antd") hints.push("Ant Design docs in components/README.md");
+  if (config.ui.library === "nextui") hints.push("NextUI docs in components/README.md");
+  if (config.features.includes("analytics")) hints.push("Analytics client at src/lib/posthog.ts");
+  if (config.features.includes("error-tracking")) hints.push("Error tracking at src/lib/sentry.ts");
+  if (config.auth.provider === "nextauth") hints.push("NextAuth route at app/api/auth/[...nextauth]/route.ts");
+  if (config.auth.provider === "clerk") hints.push("Clerk middleware at middleware.ts");
+  if (config.auth.provider === "supabase") hints.push("Supabase client at src/lib/supabase.ts");
+  return hints;
+}
+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");
+  await ensureDir(agentsRoot, ctx);
+  const serversRoot = join9(agentsRoot, "servers");
+  await ensureDir(serversRoot, ctx);
+  const protocolsRoot = join9(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);
+    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);
+    const toolsJson = JSON.stringify({ tools }, null, 2);
+    await writeTextFile(join9(agentDir, "tools.json"), toolsJson + "\n", ctx);
+    if (agent === "claude") {
+      const content = JSON.stringify(
+        {
+          mcpServers: {
+            stackforge: {
+              command: "node",
+              args: [`.ai-agents/servers/claude/mcp-server.${ext}`]
+            }
+          }
+        },
+        null,
+        2
+      );
+      await writeTextFile(join9(agentDir, "claude_desktop_config.json"), content + "\n", ctx);
+      const claudeRoot = join9(projectRoot, ".claude");
+      await ensureDir(claudeRoot, ctx);
+      await writeTextFile(join9(claudeRoot, "claude_desktop_config.json"), content + "\n", ctx);
+      await writeTextFile(
+        join9(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");
+      await ensureDir(serverDir, ctx);
+      const serverContent = buildMcpServerContent(ext, tools, hints);
+      await writeTextFile(join9(serverDir, `mcp-server.${ext}`), serverContent, ctx);
+      const mcpSpec = JSON.stringify(
+        {
+          name: "stackforge",
+          tools
+        },
+        null,
+        2
+      );
+      await writeTextFile(join9(serverDir, "mcp.json"), mcpSpec + "\n", ctx);
+      await writeTextFile(
+        join9(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 ensureDir(serverDir, ctx);
+      const serverContent = `export const functions = ${JSON.stringify(buildFunctionDefinitions(tools), null, 2)};
+
+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);
+    }
+    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 ensureDir(codexRoot, ctx);
+      await writeTextFile(join9(codexRoot, "functions.json"), content + "\n", ctx);
+      await writeTextFile(
+        join9(codexRoot, "README.md"),
+        "StackForge generated this folder for Codex. Use functions.json for OpenAI function calling integrations.\n",
+        ctx
+      );
+      const serverDir = join9(serversRoot, "codex");
+      await ensureDir(serverDir, ctx);
+      const serverContent = `export const functions = ${JSON.stringify(buildFunctionDefinitions(tools), null, 2)};
+
+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);
+    }
+    if (agent === "gemini") {
+      const content = JSON.stringify({ functions: buildFunctionDefinitions(tools) }, null, 2);
+      await writeTextFile(join9(agentDir, "function_declarations.json"), content + "\n", ctx);
+      await writeTextFile(join9(agentDir, "function-declarations.json"), content + "\n", ctx);
+      const serverDir = join9(serversRoot, "gemini");
+      await ensureDir(serverDir, ctx);
+      const serverContent = `export const functions = ${JSON.stringify(buildFunctionDefinitions(tools), null, 2)};
+
+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(join9(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 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 ensureDir(serverDir, ctx);
+      const serverContent = `# Cursor uses .cursorrules for guidance.
+`;
+      await writeTextFile(join9(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);
+    }
+    if (agent === "windsurf") {
+      const windsurfRoot = join9(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);
+    }
+    if (agent === "tabnine") {
+      const tabnineRoot = join9(projectRoot, ".tabnine");
+      await ensureDir(tabnineRoot, ctx);
+      const content = JSON.stringify({ tools, hints }, null, 2);
+      await writeTextFile(join9(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);
+  const lspSchema = JSON.stringify(
+    {
+      version: "0.1",
+      capabilities: {
+        tools: protocolTools
+      }
+    },
+    null,
+    2
+  );
+  await writeTextFile(join9(protocolsRoot, "lsp.json"), lspSchema + "\n", ctx);
+  const docsDir = join9(projectRoot, "docs");
+  await ensureDir(docsDir, ctx);
+  const aiDoc = buildAiAgentsDoc(config);
+  await writeTextFile(join9(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);
+}
+function buildAiAgentsDoc(config) {
+  const agentsList = config.aiAgents.map((agent) => `- ${agent}`).join("\n");
+  const tools = buildTools(config).map((tool) => `- ${tool}`).join("\n");
+  const hints = buildHints(config).map((hint) => `- ${hint}`).join("\n");
+  return `# AI Agent Integrations
+
+This project includes configuration files for the selected AI agents.
+
+## Enabled Agents
+${agentsList || "- none"}
+
+## Tools Enabled
+${tools || "- none"}
+
+## Project Hints
+${hints || "- none"}
+
+## Files
+- .ai-agents/<agent>/context.json
+- .ai-agents/<agent>/tools.json
+- .ai-agents/servers/<agent>/
+- .claude/claude_desktop_config.json (when Claude is enabled)
+- .codex/functions.json (when Codex is enabled)
+- .cursor/extensions.json and .cursorrules (when Cursor is enabled)
+- .windsurf/cascade.json (when Windsurf is enabled)
+- .tabnine/config.json (when Tabnine is enabled)
+
+## Setup Notes
+- Claude Desktop: copy .ai-agents/claude/claude_desktop_config.json into your Claude config folder.
+- Claude MCP server: run .ai-agents/servers/claude/mcp-server.(ts|js).
+- Copilot: use .ai-agents/copilot/functions.json for function calling.
+- Codex: use .codex/functions.json for function calling.
+- Gemini: use .ai-agents/gemini/function_declarations.json in AI Studio.
+- Cursor: .ai-agents/cursor/.cursorrules is auto-discovered when opening the project.
+- Codeium: use .ai-agents/codeium/server-config.json for LSP tools.
+- Windsurf: use .windsurf/cascade.json for Cascade protocol.
+- Tabnine: use .tabnine/config.json for plugin configuration.
+
+## Notes
+- Agent configs are generated based on stackforge.json.
+- Re-run \`stackforge configure-agents\` after changing your stack.
+`;
+}
+function buildMcpServerContent(ext, tools, hints) {
+  const toolCases = [
+    "case 'stackforge_database':\\n      return { ok: true, message: 'Check DATABASE_URL in .env and review db clients in src/db or drizzle/' };",
+    "case 'stackforge_orm':\\n      return { ok: true, message: 'Review ORM schema or models in drizzle/ or prisma/ or src/db' };",
+    "case 'stackforge_api':\\n      return { ok: true, message: 'API routes in app/api and clients in src/api, src/graphql, or src/trpc' };",
+    "case 'stackforge_auth':\\n      return { ok: true, message: 'Auth routes in app/api/auth and auth helpers in auth/' };",
+    "case 'stackforge_email':\\n      return { ok: true, message: 'Email client at src/lib/resend.ts and docs in features/email' };",
+    "case 'stackforge_storage':\\n      return { ok: true, message: 'Storage docs in features/storage' };",
+    "case 'stackforge_payments':\\n      return { ok: true, message: 'Stripe client at src/lib/stripe.ts and docs in features/payments' };",
+    "case 'stackforge_analytics':\\n      return { ok: true, message: 'PostHog client at src/lib/posthog.ts' };",
+    "case 'stackforge_error-tracking':\\n      return { ok: true, message: 'Sentry client at src/lib/sentry.ts' };"
+  ].join("\\n    ");
+  const common = `const tools = ${JSON.stringify(tools, null, 2)};\\nconst hints = ${JSON.stringify(
+    hints,
+    null,
+    2
+  )};\\n\\nfunction handleTool(name${ext === "ts" ? ": string" : ""}, action${ext === "ts" ? ": string" : ""}) {\\n  switch (name) {\\n    ${toolCases}\\n    default:\\n      return { ok: false, message: 'Unknown tool' };\\n  }\\n}\\n\\nconst server = ${ext === "ts" ? "createServer" : "http.createServer"}((req, res) => {\\n  if (req.url === '/tools') {\\n    res.writeHead(200, { 'Content-Type': 'application/json' });\\n    res.end(JSON.stringify({ tools, hints }));\\n    return;\\n  }\\n  if (req.url === '/invoke' && req.method === 'POST') {\\n    let body = '';\\n    req.on('data', (chunk) => (body += chunk));\\n    req.on('end', () => {\\n      try {\\n        const payload = JSON.parse(body || '{}');\\n        const name = payload.name || '';\\n        const action = payload.arguments?.action || '';\\n        const result = handleTool(name, action);\\n        res.writeHead(200, { 'Content-Type': 'application/json' });\\n        res.end(JSON.stringify(result));\\n      } catch (err) {\\n        res.writeHead(400, { 'Content-Type': 'application/json' });\\n        res.end(JSON.stringify({ ok: false, message: 'Invalid JSON' }));\\n      }\\n    });\\n    return;\\n  }\\n  res.writeHead(404);\\n  res.end();\\n});\\n\\nconst port = Number(process.env.MCP_PORT || 7341);\\nserver.listen(port, () => {\\n  console.log('MCP server listening on', port);\\n});\\n`;
+  if (ext === "ts") {
+    return `import { createServer } from 'node:http';\\n\\n${common}`;
+  }
+  return `const http = require('node:http');\\n\\n${common}`;
+}
+
+// src/generators/features/feature-files.ts
+import { join as join10 } from "path";
+import { fileURLToPath as fileURLToPath7 } from "url";
+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 isTs = config.frontend.language === "ts";
+  if (config.features.includes("email")) {
+    const dir = join10(projectRoot, "features", "email");
+    await ensureDir(dir, ctx);
+    await ensureDir(libDir, ctx);
+    const readme = await readTextFile(join10(templatesRoot, "features", "email", "README.md"));
+    const resendClient = await readTextFile(
+      join10(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);
+  }
+  if (config.features.includes("storage")) {
+    const dir = join10(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 storageClient = await readTextFile(
+      join10(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);
+  }
+  if (config.features.includes("payments")) {
+    const dir = join10(projectRoot, "features", "payments");
+    await ensureDir(dir, ctx);
+    await ensureDir(libDir, ctx);
+    const readme = await readTextFile(join10(templatesRoot, "features", "payments", "README.md"));
+    const stripeClient = await readTextFile(
+      join10(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);
+  }
+  if (config.features.includes("analytics")) {
+    const dir = join10(projectRoot, "features", "analytics");
+    await ensureDir(dir, ctx);
+    await ensureDir(libDir, ctx);
+    const readme = await readTextFile(join10(templatesRoot, "features", "analytics", "README.md"));
+    const client = await readTextFile(
+      join10(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);
+  }
+  if (config.features.includes("error-tracking")) {
+    const dir = join10(projectRoot, "features", "error-tracking");
+    await ensureDir(dir, ctx);
+    await ensureDir(libDir, ctx);
+    const readme = await readTextFile(join10(templatesRoot, "features", "error-tracking", "README.md"));
+    const client = await readTextFile(
+      join10(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);
+  }
+}
+
+// src/cli/run-generators.ts
+async function runGenerators(cwd, config, ctx) {
+  await createProjectSkeleton(cwd, config, ctx);
+  await generateFrontendFiles(cwd, config, ctx);
+  await generateUiFiles(cwd, config, ctx);
+  await generateDatabaseFiles(cwd, config, ctx);
+  await generateAuthFiles(cwd, config, ctx);
+  await generateApiFiles(cwd, config, ctx);
+  await generateFeatureFiles(cwd, config, ctx);
+  await generateAiAgentConfigs(cwd, config, ctx);
+}
+
+// src/cli/validators/config.ts
+function validateConfig(config) {
+  if (!supported.frontend.includes(config.frontend.type)) {
+    throw new Error(`Unsupported frontend: ${config.frontend.type}`);
+  }
+  if (!supported.ui.includes(config.ui.library)) {
+    throw new Error(`Unsupported UI library: ${config.ui.library}`);
+  }
+  if (!supported.database.includes(config.database.provider)) {
+    throw new Error(`Unsupported database: ${config.database.provider}`);
+  }
+  if (config.database.orm && !supported.orm.includes(config.database.orm)) {
+    throw new Error(`Unsupported ORM: ${config.database.orm}`);
+  }
+  if (!supported.auth.includes(config.auth.provider)) {
+    throw new Error(`Unsupported auth: ${config.auth.provider}`);
+  }
+  if (!supported.api.includes(config.api.type)) {
+    throw new Error(`Unsupported API: ${config.api.type}`);
+  }
+  for (const feature of config.features) {
+    if (!supported.features.includes(feature)) {
+      throw new Error(`Unsupported feature: ${feature}`);
+    }
+  }
+  if (config.auth.provider === "nextauth" && config.frontend.type !== "nextjs") {
+    throw new Error("NextAuth requires Next.js.");
+  }
+  if (config.api.type === "trpc" && config.frontend.language !== "ts") {
+    throw new Error("tRPC requires TypeScript.");
+  }
+  if (config.database.orm && config.database.provider === "none") {
+    throw new Error("ORM requires a database provider.");
+  }
+}
+
+// src/cli/validators/compatibility.ts
+function validateCompatibility(config) {
+  if (config.auth.provider === "nextauth" && config.frontend.type !== "nextjs") {
+    throw new Error("NextAuth requires Next.js.");
+  }
+  if (config.auth.provider === "clerk" && config.frontend.type !== "nextjs") {
+    throw new Error("Clerk requires Next.js.");
+  }
+  if (config.api.type === "trpc" && config.frontend.language !== "ts") {
+    throw new Error("tRPC requires TypeScript.");
+  }
+  if (config.database.orm === "typeorm") {
+    const supported2 = ["postgres", "mysql", "sqlite"];
+    if (!supported2.includes(config.database.provider)) {
+      throw new Error("TypeORM requires postgres, mysql, or sqlite.");
+    }
+  }
+  if (config.features.includes("error-tracking") && config.frontend.type !== "nextjs") {
+    throw new Error("Error tracking (Sentry) requires Next.js.");
+  }
+}
+
+// src/utils/version-manager.ts
+function resolveVersions(options) {
+  return versions;
+}
+
+// src/utils/dependency-resolver.ts
+function resolveDependencies(config, options) {
+  resolveVersions(options);
+  return collectDependencies(config);
+}
+function resolveScripts(config) {
+  return collectScripts(config);
+}
+
+// src/cli/validators/dependencies.ts
+function validateDependencies(config) {
+  const deps = resolveDependencies(config);
+  const scripts = resolveScripts(config);
+  if (Object.keys(scripts).length === 0) {
+    throw new Error("No scripts resolved for the selected stack.");
+  }
+  if (Object.keys(deps.dependencies).length === 0 && Object.keys(deps.devDependencies).length === 0) {
+    throw new Error("No dependencies resolved for the selected stack.");
+  }
+}
+
+// src/utils/logger.ts
+var logger = {
+  info(message) {
+    console.log(message);
+  },
+  warn(message) {
+    console.warn(message);
+  },
+  error(message) {
+    console.error(message);
+  }
+};
+
+// src/utils/install.ts
+import { exec } from "child_process";
+function getInstallCommand(pm) {
+  switch (pm) {
+    case "pnpm":
+      return "pnpm install";
+    case "yarn":
+      return "yarn install";
+    case "bun":
+      return "bun install";
+    default:
+      return "npm install";
+  }
+}
+function runInstall(pm, cwd) {
+  const command = getInstallCommand(pm);
+  return new Promise((resolve2, reject) => {
+    const child = exec(command, { cwd }, (err) => {
+      if (err) reject(err);
+      else resolve2();
+    });
+    child.stdout?.pipe(process.stdout);
+    child.stderr?.pipe(process.stderr);
+  });
+}
+
+// src/cli/commands/create.ts
+import { join as join11, resolve } from "path";
+function parseCsv(input) {
+  if (!input) return void 0;
+  return input.split(",").map((a) => a.trim()).filter(Boolean);
+}
+var createCommand = new Command("create").argument("[project-name]", "name of the project").option("--preset <name>", "use a preset config").option("--no-install", "skip dependency install").option("--dry-run", "print planned actions without writing files").option("--ai-agents <list>", "comma-separated list of AI agents to configure").option("--features <list>", "comma-separated list of features to include").option("--yes", "skip prompts and use defaults").option("--no-prompts", "alias for --yes").option("--out-dir <path>", "output directory (defaults to current working directory)").action(async (projectName, options) => {
+  logger.info("Starting StackForge create flow...");
+  const skipPrompts = Boolean(options.yes || options.noPrompts);
+  const config = await promptForConfig({ projectName, preset: options.preset, skipPrompts });
+  if (options.aiAgents) {
+    config.aiAgents = parseCsv(options.aiAgents) ?? [];
+  }
+  if (options.features) {
+    config.features = parseCsv(options.features) ?? [];
+  }
+  validateConfig(config);
+  validateCompatibility(config);
+  validateDependencies(config);
+  const ctx = {
+    dryRun: Boolean(options.dryRun),
+    log: (message) => logger.info(message)
+  };
+  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);
+    logger.info("Installing dependencies...");
+    await runInstall(config.packageManager, projectRoot);
+  }
+  logger.info(`Project created: ${config.projectName}`);
+});
+
+// src/cli/commands/list.ts
+import { Command as Command2 } from "commander";
+var listCommand = new Command2("list").option("--available", "show available features").option("--category <name>", "filter by category").action(async (options) => {
+  if (options.available) {
+    logger.info("Available features:");
+    logger.info(`frontend: ${supported.frontend.join(", ")}`);
+    logger.info(`ui: ${supported.ui.join(", ")}`);
+    logger.info(`database: ${supported.database.join(", ")}`);
+    logger.info(`orm: ${supported.orm.join(", ")}`);
+    logger.info(`auth: ${supported.auth.join(", ")}`);
+    logger.info(`api: ${supported.api.join(", ")}`);
+    logger.info(`features: ${supported.features.join(", ")}`);
+    return;
+  }
+  const config = await readProjectConfig(process.cwd());
+  if (!options.category) {
+    logger.info(`frontend: ${config.frontend.type} (${config.frontend.language})`);
+    logger.info(`ui: ${config.ui.library}`);
+    logger.info(`database: ${config.database.provider}${config.database.orm ? " (" + config.database.orm + ")" : ""}`);
+    logger.info(`auth: ${config.auth.provider}`);
+    logger.info(`api: ${config.api.type}`);
+    logger.info(`features: ${config.features.length ? config.features.join(", ") : "none"}`);
+    return;
+  }
+  switch (options.category) {
+    case "frontend":
+      logger.info(`frontend: ${config.frontend.type} (${config.frontend.language})`);
+      break;
+    case "ui":
+      logger.info(`ui: ${config.ui.library}`);
+      break;
+    case "database":
+      logger.info(`database: ${config.database.provider}${config.database.orm ? " (" + config.database.orm + ")" : ""}`);
+      break;
+    case "auth":
+      logger.info(`auth: ${config.auth.provider}`);
+      break;
+    case "api":
+      logger.info(`api: ${config.api.type}`);
+      break;
+    case "features":
+      logger.info(`features: ${config.features.length ? config.features.join(", ") : "none"}`);
+      break;
+    default:
+      logger.error(`Unknown category: ${options.category}`);
+  }
+});
+
+// src/cli/commands/add.ts
+import { Command as Command3 } from "commander";
+
+// src/utils/package-json.ts
+import { readFile as readFile4, writeFile as writeFile4 } from "fs/promises";
+async function readPackageJson(path) {
+  const raw = await readFile4(path, "utf8");
+  return JSON.parse(raw);
+}
+async function writePackageJson(path, pkg) {
+  await writeFile4(path, JSON.stringify(pkg, null, 2) + "\n", "utf8");
+}
+function mergeScripts(pkg, scripts) {
+  return { ...pkg, scripts: { ...pkg.scripts ?? {}, ...scripts } };
+}
+function mergeDependencies(pkg, deps) {
+  return {
+    ...pkg,
+    dependencies: { ...pkg.dependencies ?? {}, ...deps.dependencies },
+    devDependencies: { ...pkg.devDependencies ?? {}, ...deps.devDependencies }
+  };
+}
+function removeScripts(pkg, scriptsToRemove) {
+  if (!pkg.scripts) return pkg;
+  const next = { ...pkg.scripts };
+  for (const key of Object.keys(scriptsToRemove)) {
+    delete next[key];
+  }
+  return { ...pkg, scripts: next };
+}
+function removeDependencies(pkg, depsToRemove) {
+  const nextDeps = { ...pkg.dependencies ?? {} };
+  const nextDev = { ...pkg.devDependencies ?? {} };
+  for (const key of Object.keys(depsToRemove.dependencies)) {
+    delete nextDeps[key];
+  }
+  for (const key of Object.keys(depsToRemove.devDependencies)) {
+    delete nextDev[key];
+  }
+  return { ...pkg, dependencies: nextDeps, devDependencies: nextDev };
+}
+
+// src/utils/feature-update.ts
+function updateConfigForFeature(config, category, value, action) {
+  const next = { ...config, database: { ...config.database }, ui: { ...config.ui }, auth: { ...config.auth }, api: { ...config.api } };
+  switch (category) {
+    case "ui":
+      if (action === "add" && value && !supported.ui.includes(value)) {
+        throw new Error(`Unsupported UI library: ${value}`);
+      }
+      next.ui.library = action === "remove" ? "none" : value;
+      break;
+    case "auth":
+      if (action === "add" && value && !supported.auth.includes(value)) {
+        throw new Error(`Unsupported auth provider: ${value}`);
+      }
+      next.auth.provider = action === "remove" ? "none" : value;
+      break;
+    case "api":
+      if (action === "add" && value && !supported.api.includes(value)) {
+        throw new Error(`Unsupported API type: ${value}`);
+      }
+      next.api.type = action === "remove" ? "none" : value;
+      break;
+    case "database":
+      if (action === "add" && value && !supported.database.includes(value)) {
+        throw new Error(`Unsupported database: ${value}`);
+      }
+      next.database.provider = action === "remove" ? "none" : value;
+      if (action === "remove" || value === "none") next.database.orm = void 0;
+      break;
+    case "orm":
+      if (action === "add" && value && !supported.orm.includes(value)) {
+        throw new Error(`Unsupported ORM: ${value}`);
+      }
+      next.database.orm = action === "remove" ? void 0 : value;
+      break;
+    case "feature":
+      if (action === "add" && value && !supported.features.includes(value)) {
+        throw new Error(`Unsupported feature: ${value}`);
+      }
+      if (action === "add" && value) {
+        next.features = Array.from(/* @__PURE__ */ new Set([...next.features, value]));
+      } else if (action === "remove" && value) {
+        next.features = next.features.filter((f) => f !== value);
+      }
+      break;
+    default:
+      throw new Error(`Unknown feature category: ${category}`);
+  }
+  return next;
+}
+function diffKeys(oldMap, newMap) {
+  const diff = {};
+  for (const key of Object.keys(oldMap)) {
+    if (!(key in newMap)) diff[key] = oldMap[key];
+  }
+  return diff;
+}
+async function syncPackageJson(path, oldConfig, newConfig) {
+  const pkg = await readPackageJson(path);
+  const oldScripts = collectScripts(oldConfig);
+  const newScripts = collectScripts(newConfig);
+  const oldDeps = collectDependencies(oldConfig);
+  const newDeps = collectDependencies(newConfig);
+  const scriptsToRemove = diffKeys(oldScripts, newScripts);
+  const depsToRemove = {
+    dependencies: diffKeys(oldDeps.dependencies, newDeps.dependencies),
+    devDependencies: diffKeys(oldDeps.devDependencies, newDeps.devDependencies)
+  };
+  let nextPkg = removeScripts(pkg, scriptsToRemove);
+  nextPkg = removeDependencies(nextPkg, depsToRemove);
+  nextPkg = mergeScripts(nextPkg, newScripts);
+  nextPkg = mergeDependencies(nextPkg, newDeps);
+  await writePackageJson(path, nextPkg);
+}
+
+// src/cli/commands/add.ts
+import { dirname as dirname3, join as join12 } from "path";
+function parseFeature(feature) {
+  const [category, value] = feature.split(":");
+  if (!category || !value) {
+    throw new Error("Feature must be in the form category:value (e.g., auth:nextauth).");
+  }
+  return { category, value };
+}
+var addCommand = new Command3("add").argument("<feature>", "feature to add (category:value)").action(async (feature) => {
+  const cwd = process.cwd();
+  const { category, value } = parseFeature(feature);
+  const current = await readProjectConfig(cwd);
+  const next = updateConfigForFeature(current, category, value, "add");
+  validateConfig(next);
+  validateCompatibility(next);
+  validateDependencies(next);
+  await writeProjectConfig(cwd, next);
+  await syncPackageJson(`${cwd}/package.json`, current, next);
+  const root = dirname3(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");
+  logger.info(`Added ${feature}`);
+});
+
+// src/cli/commands/remove.ts
+import { Command as Command4 } from "commander";
+
+// src/utils/feature-cleanup.ts
+import { join as join13 } 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"));
+    }
+    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"));
+    }
+    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"));
+    }
+  }
+  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");
+    }
+    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");
+    }
+    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"));
+  }
+  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"));
+    }
+    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"));
+    }
+    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(join13(root, "api"));
+  }
+  if (category === "database") {
+    if (config.database.orm === "drizzle") {
+      await removePath(join13(root, "drizzle.config.ts"));
+      await removePath(join13(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"));
+    }
+    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"));
+    }
+    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 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");
+  }
+  if (category === "orm") {
+    if (config.database.orm === "drizzle") {
+      await removePath(join13(root, "drizzle.config.ts"));
+      await removePath(join13(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"));
+    }
+    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"));
+    }
+    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"));
+    }
+  }
+  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"));
+    }
+    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"));
+    }
+    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"));
+    }
+    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"));
+    }
+    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"));
+    }
+  }
+}
+
+// src/cli/commands/remove.ts
+import { join as join14 } from "path";
+function parseFeature2(feature) {
+  const [category, value] = feature.split(":");
+  if (!category || !value) {
+    throw new Error("Feature must be in the form category:value (e.g., auth:nextauth).");
+  }
+  return { category, value };
+}
+function assertRemovalTarget(category, value, current) {
+  switch (category) {
+    case "ui":
+      if (current.ui.library !== value) {
+        throw new Error(`UI library ${value} is not installed.`);
+      }
+      break;
+    case "auth":
+      if (current.auth.provider !== value) {
+        throw new Error(`Auth provider ${value} is not installed.`);
+      }
+      break;
+    case "api":
+      if (current.api.type !== value) {
+        throw new Error(`API type ${value} is not installed.`);
+      }
+      break;
+    case "database":
+      if (current.database.provider !== value) {
+        throw new Error(`Database provider ${value} is not installed.`);
+      }
+      break;
+    case "orm":
+      if (current.database.orm !== value) {
+        throw new Error(`ORM ${value} is not installed.`);
+      }
+      break;
+    case "feature":
+      if (!current.features.includes(value)) {
+        throw new Error(`Feature ${value} is not installed.`);
+      }
+      break;
+    default:
+      throw new Error(`Unknown feature category: ${category}`);
+  }
+}
+var removeCommand = new Command4("remove").argument("<feature>", "feature to remove (category:value)").action(async (feature) => {
+  const cwd = process.cwd();
+  const { category, value } = parseFeature2(feature);
+  const current = await readProjectConfig(cwd);
+  assertRemovalTarget(category, value, current);
+  await cleanupFeature(cwd, current, category, value);
+  const next = updateConfigForFeature(current, category, value, "remove");
+  validateConfig(next);
+  validateCompatibility(next);
+  validateDependencies(next);
+  await writeProjectConfig(cwd, next);
+  await syncPackageJson(`${cwd}/package.json`, current, next);
+  const readme = buildProjectReadme(next);
+  await writeTextFile(join14(cwd, "README.md"), readme + "\n");
+  logger.info(`Removed ${feature}`);
+});
+
+// src/cli/commands/update.ts
+import { Command as Command5 } from "commander";
+import { join as join15 } 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) => {
+  const cwd = process.cwd();
+  const config = await readProjectConfig(cwd);
+  const pkgPath = join15(cwd, "package.json");
+  if (options.check) {
+    const pkg = JSON.parse(await readFile5(pkgPath, "utf8"));
+    const expectedScripts = resolveScripts(config);
+    const expectedDeps = resolveDependencies(config, { allowMajor: Boolean(options.major) });
+    const issues = [];
+    for (const key of Object.keys(expectedScripts)) {
+      if (!pkg.scripts || !(key in pkg.scripts)) {
+        issues.push(`Missing script: ${key}`);
+      } else if (pkg.scripts[key] !== expectedScripts[key]) {
+        issues.push(`Script mismatch: ${key}`);
+      }
+    }
+    for (const key of Object.keys(expectedDeps.dependencies)) {
+      if (!pkg.dependencies || !(key in pkg.dependencies)) {
+        issues.push(`Missing dependency: ${key}`);
+      } else if (pkg.dependencies[key] !== expectedDeps.dependencies[key]) {
+        issues.push(`Dependency version mismatch: ${key}`);
+      }
+    }
+    for (const key of Object.keys(expectedDeps.devDependencies)) {
+      if (!pkg.devDependencies || !(key in pkg.devDependencies)) {
+        issues.push(`Missing devDependency: ${key}`);
+      } else if (pkg.devDependencies[key] !== expectedDeps.devDependencies[key]) {
+        issues.push(`Dev dependency version mismatch: ${key}`);
+      }
+    }
+    if (options.live) {
+      const { fetchLatestVersion } = await import("./npm-registry-F7EVX3RR.js");
+      const allDeps = {
+        ...expectedDeps.dependencies,
+        ...expectedDeps.devDependencies
+      };
+      for (const [name, version] of Object.entries(allDeps)) {
+        const latest = await fetchLatestVersion(name);
+        if (latest && !version.includes(latest)) {
+          issues.push(`Latest available: ${name}@${latest} (current ${version})`);
+        }
+      }
+    }
+    if (issues.length === 0) {
+      logger.info("No updates needed.");
+    } else {
+      for (const issue of issues) logger.warn(issue);
+    }
+    return;
+  }
+  await syncPackageJson(pkgPath, config, config);
+  if (options.live) {
+    const { fetchLatestVersion } = await import("./npm-registry-F7EVX3RR.js");
+    const pkg = await readPackageJson(pkgPath);
+    const allowMajor = Boolean(options.major);
+    const updateMap = async (deps) => {
+      if (!deps) return;
+      for (const [name, current] of Object.entries(deps)) {
+        const latest = await fetchLatestVersion(name);
+        if (!latest) continue;
+        const currentMajor = parseMajor(current);
+        const latestMajor = parseMajor(latest);
+        if (!allowMajor && currentMajor !== null && latestMajor !== null && latestMajor > currentMajor) {
+          continue;
+        }
+        deps[name] = `^${latest}`;
+      }
+    };
+    await updateMap(pkg.dependencies);
+    await updateMap(pkg.devDependencies);
+    await writePackageJson(pkgPath, pkg);
+  }
+  const readme = buildProjectReadme(config);
+  await writeTextFile(join15(cwd, "README.md"), readme + "\n");
+  logger.info("Project updated.");
+});
+function parseMajor(version) {
+  const match = version.match(/(\d+)\./);
+  if (!match) return null;
+  return Number(match[1]);
+}
+
+// src/cli/commands/doctor.ts
+import { Command as Command6 } from "commander";
+import { existsSync as existsSync4 } from "fs";
+import { join as join17 } from "path";
+
+// src/utils/doctor.ts
+import { existsSync as existsSync3 } from "fs";
+import { readFile as readFile6 } from "fs/promises";
+import { join as join16, dirname as dirname4, basename } from "path";
+function requiredEnvKeys(config) {
+  const keys = [];
+  if (config.database.provider !== "none") keys.push("DATABASE_URL");
+  if (config.database.provider === "neon") keys.push("NEON_API_KEY", "NEON_PROJECT_ID");
+  if (config.database.provider === "supabase") keys.push("SUPABASE_URL", "SUPABASE_ANON_KEY");
+  if (config.auth.provider === "nextauth") keys.push("NEXTAUTH_SECRET", "NEXTAUTH_URL");
+  if (config.auth.provider === "clerk") keys.push("CLERK_SECRET_KEY", "NEXT_PUBLIC_CLERK_PUBLISHABLE_KEY");
+  if (config.auth.provider === "supabase") keys.push("NEXT_PUBLIC_SUPABASE_URL", "NEXT_PUBLIC_SUPABASE_ANON_KEY");
+  if (config.features.includes("email")) keys.push("RESEND_API_KEY");
+  if (config.features.includes("storage")) keys.push("CLOUDINARY_URL");
+  if (config.features.includes("payments")) keys.push("STRIPE_SECRET_KEY");
+  if (config.features.includes("analytics")) keys.push("NEXT_PUBLIC_POSTHOG_KEY", "NEXT_PUBLIC_POSTHOG_HOST");
+  if (config.features.includes("error-tracking")) keys.push("SENTRY_DSN");
+  return keys;
+}
+function agentFiles(agent) {
+  const files = ["context.json", "tools.json"];
+  if (agent === "claude") files.push("claude_desktop_config.json");
+  if (agent === "copilot") files.push("functions.json");
+  if (agent === "codex") files.push("functions.json");
+  if (agent === "gemini") files.push("function_declarations.json");
+  if (agent === "cursor") files.push(".cursorrules");
+  if (agent === "codeium") files.push("server-config.json");
+  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 issues = [];
+  if (!existsSync3(configPath)) {
+    return {
+      issues: ["Missing stackforge.json. Run from a StackForge project root."],
+      config: await Promise.reject(new Error("Missing stackforge.json")),
+      pkgPath,
+      envPath,
+      hasConfig: false,
+      hasPackageJson: existsSync3(pkgPath)
+    };
+  }
+  if (!existsSync3(pkgPath)) {
+    return {
+      issues: ["Missing package.json"],
+      config: await readProjectConfig(cwd),
+      pkgPath,
+      envPath,
+      hasConfig: true,
+      hasPackageJson: false
+    };
+  }
+  const config = await readProjectConfig(cwd);
+  const pkg = JSON.parse(await readFile6(pkgPath, "utf8"));
+  const requiredScripts = collectScripts(config);
+  const requiredDeps = collectDependencies(config);
+  for (const key of Object.keys(requiredScripts)) {
+    if (!pkg.scripts || !(key in pkg.scripts)) {
+      issues.push(`Missing script: ${key}`);
+    }
+  }
+  for (const key of Object.keys(requiredDeps.dependencies)) {
+    if (!pkg.dependencies || !(key in pkg.dependencies)) {
+      issues.push(`Missing dependency: ${key}`);
+    }
+  }
+  for (const key of Object.keys(requiredDeps.devDependencies)) {
+    if (!pkg.devDependencies || !(key in pkg.devDependencies)) {
+      issues.push(`Missing devDependency: ${key}`);
+    }
+  }
+  let envContent = "";
+  if (existsSync3(envPath)) {
+    envContent = 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])
+  );
+  const requiredEnv = requiredEnvKeys(config);
+  for (const key of requiredEnv) {
+    if (!envKeys.has(key)) {
+      issues.push(`Missing env key in .env.example: ${key}`);
+    }
+  }
+  for (const agent of config.aiAgents) {
+    const agentRoot = join16(cwd, ".ai-agents", agent);
+    for (const file of agentFiles(agent)) {
+      if (!existsSync3(join16(agentRoot, file))) {
+        issues.push(`Missing AI agent file: .ai-agents/${agent}/${file}`);
+      }
+    }
+    if (agent === "claude" && !existsSync3(join16(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"))) {
+      issues.push("Missing Codex config: .codex/functions.json");
+    }
+    if (agent === "cursor" && !existsSync3(join16(cwd, ".cursor", "extensions.json"))) {
+      issues.push("Missing Cursor config: .cursor/extensions.json");
+    }
+    if (agent === "windsurf" && !existsSync3(join16(cwd, ".windsurf", "cascade.json"))) {
+      issues.push("Missing Windsurf config: .windsurf/cascade.json");
+    }
+    if (agent === "tabnine" && !existsSync3(join16(cwd, ".tabnine", "config.json"))) {
+      issues.push("Missing Tabnine config: .tabnine/config.json");
+    }
+  }
+  return {
+    issues,
+    config,
+    pkgPath,
+    envPath,
+    hasConfig: true,
+    hasPackageJson: true
+  };
+}
+async function fixProject(result) {
+  const { config, pkgPath, envPath } = result;
+  await syncPackageJson(pkgPath, config, config);
+  const envContent = existsSync3(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])
+  );
+  const missingEnv = requiredEnvKeys(config).filter((key) => !envKeys.has(key));
+  for (const key of missingEnv) {
+    await appendEnvLine(envPath, `${key}=""`);
+  }
+  if (config.aiAgents.length > 0) {
+    const base = basename(process.cwd()) === config.projectName ? dirname4(process.cwd()) : process.cwd();
+    await generateAiAgentConfigs(base, config);
+  }
+  const readme = buildProjectReadme(config);
+  await writeTextFile(join16(process.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)) {
+    logger.error("Missing stackforge.json. Run from a StackForge project root.");
+    return;
+  }
+  let config;
+  try {
+    const raw = JSON.parse(await readFile7(configPath, "utf8"));
+    const schemaVersion = raw._schemaVersion ?? 0;
+    if (schemaVersion !== STACKFORGE_SCHEMA_VERSION) {
+      logger.warn(`stackforge.json schema version ${schemaVersion} (expected ${STACKFORGE_SCHEMA_VERSION})`);
+    } else {
+      logger.info("stackforge.json OK");
+    }
+    config = await readProjectConfig(cwd);
+  } catch (err) {
+    logger.error("Failed to read stackforge.json");
+    return;
+  }
+  const pkgPath = join17(cwd, "package.json");
+  if (!existsSync4(pkgPath)) {
+    logger.error("Missing package.json");
+    return;
+  }
+  const result = await checkProject(cwd);
+  if (result.issues.length === 0) {
+    logger.info("No issues found.");
+    return;
+  }
+  for (const issue of result.issues) {
+    logger.warn(issue);
+  }
+  if (options.fix) {
+    await fixProject(result);
+    logger.info("Applied fixes.");
+  }
+});
+
+// src/cli/commands/configure-agents.ts
+import { Command as Command7 } from "commander";
+var configureAgentsCommand = new Command7("configure-agents").option("--agents <list>", "comma-separated list of agents").action(async (options) => {
+  const cwd = process.cwd();
+  const config = await readProjectConfig(cwd);
+  const agents = options.agents ? String(options.agents).split(",").map((a) => a.trim()).filter(Boolean) : config.aiAgents;
+  const invalid = (agents ?? []).filter((a) => !supported.agents.includes(a));
+  if (invalid.length) {
+    throw new Error(`Unsupported agents: ${invalid.join(", ")}`);
+  }
+  const next = { ...config, aiAgents: agents };
+  await writeProjectConfig(cwd, next);
+  await generateAiAgentConfigs(cwd, next, { dryRun: false, log: logger.info });
+  logger.info("AI agents configured.");
+});
+
+// src/cli/commands/add-agent.ts
+import { Command as Command8 } from "commander";
+var addAgentCommand = new Command8("add-agent").argument("<agent>", "agent to add").action(async (agent) => {
+  if (!supported.agents.includes(agent)) {
+    throw new Error(`Unsupported agent: ${agent}`);
+  }
+  const cwd = process.cwd();
+  const config = await readProjectConfig(cwd);
+  const set = new Set(config.aiAgents ?? []);
+  set.add(agent);
+  const next = { ...config, aiAgents: Array.from(set) };
+  await writeProjectConfig(cwd, next);
+  await generateAiAgentConfigs(cwd, next, { dryRun: false, log: logger.info });
+  logger.info(`Added agent: ${agent}`);
+});
+
+// src/cli/commands/remove-agent.ts
+import { Command as Command9 } from "commander";
+var removeAgentCommand = new Command9("remove-agent").argument("<agent>", "agent to remove").action(async (agent) => {
+  if (!supported.agents.includes(agent)) {
+    throw new Error(`Unsupported agent: ${agent}`);
+  }
+  const cwd = process.cwd();
+  const config = await readProjectConfig(cwd);
+  const next = { ...config, aiAgents: (config.aiAgents ?? []).filter((a) => a !== agent) };
+  await writeProjectConfig(cwd, next);
+  await generateAiAgentConfigs(cwd, next, { dryRun: false, log: logger.info });
+  logger.info(`Removed agent: ${agent}`);
+});
+
+// src/cli/commands/list-agents.ts
+import { Command as Command10 } from "commander";
+var listAgentsCommand = new Command10("list-agents").action(async () => {
+  const config = await readProjectConfig(process.cwd());
+  const agents = config.aiAgents ?? [];
+  if (agents.length === 0) {
+    logger.info("No agents configured.");
+    return;
+  }
+  logger.info(`Configured agents: ${agents.join(", ")}`);
+});
+
+// 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";
+var migrateCommand = new Command11("migrate").option("--dry-run", "show planned migration without writing").action(async (options) => {
+  const cwd = process.cwd();
+  const path = join18(cwd, "stackforge.json");
+  const raw = await readFile8(path, "utf8");
+  const parsed = JSON.parse(raw);
+  const current = parsed._schemaVersion ?? 0;
+  if (current === STACKFORGE_SCHEMA_VERSION) {
+    logger.info("No migration needed.");
+    return;
+  }
+  logger.info(`Migrating schema ${current} -> ${STACKFORGE_SCHEMA_VERSION}`);
+  const migrated = migrateConfig(parsed);
+  if (!options.dryRun) {
+    await writeFile5(path, JSON.stringify(migrated, null, 2) + "\n", "utf8");
+    logger.info("Migration complete.");
+  }
+});
+
+// src/cli/commands/list-presets.ts
+import { Command as Command12 } from "commander";
+var listPresetsCommand = new Command12("list-presets").option("--details", "show preset details").action((options) => {
+  const presets2 = ["starter", "saas", "ecommerce", "blog", "api"];
+  for (const name of presets2) {
+    const preset = getPreset(name);
+    if (!preset) {
+      logger.info(`${name}: missing`);
+      continue;
+    }
+    if (options.details) {
+      const features = preset.features && preset.features.length ? preset.features.join(", ") : "none";
+      logger.info(`${name}: frontend=${preset.frontend?.type ?? "n/a"} ui=${preset.ui?.library ?? "n/a"} db=${preset.database?.provider ?? "n/a"} orm=${preset.database?.orm ?? "n/a"} auth=${preset.auth?.provider ?? "n/a"} api=${preset.api?.type ?? "n/a"} features=${features}`);
+    } else {
+      logger.info(`${name}: available`);
+    }
+  }
+});
+
+// src/cli/commands/use.ts
+import { Command as Command13 } from "commander";
+var PACKAGE_MANAGERS = ["npm", "pnpm", "yarn", "bun"];
+var useCommand = new Command13("use").argument("<packageManager>", "npm | pnpm | yarn | bun").option("--no-install", "skip installing dependencies after switching").action(async (packageManager, options) => {
+  if (!PACKAGE_MANAGERS.includes(packageManager)) {
+    throw new Error(`Unsupported package manager: ${packageManager}`);
+  }
+  const cwd = process.cwd();
+  const config = await readProjectConfig(cwd);
+  const nextManager = packageManager;
+  if (config.packageManager === nextManager) {
+    logger.info(`Package manager already set to ${nextManager}.`);
+    return;
+  }
+  await removeLockfiles(cwd);
+  await writeProjectConfig(cwd, { ...config, packageManager: nextManager });
+  if (options.install !== false) {
+    await runInstall(nextManager, cwd);
+  }
+  logger.info(`Package manager switched to ${nextManager}.`);
+});
+
+// src/cli/commands/validate.ts
+import { Command as Command14 } from "commander";
+var validateCommand = new Command14("validate").description("validate project configuration and generated files").action(async () => {
+  const result = await checkProject(process.cwd());
+  if (result.issues.length === 0) {
+    logger.info("Validation passed.");
+    return;
+  }
+  for (const issue of result.issues) {
+    logger.error(issue);
+  }
+  process.exitCode = 1;
+});
+
+// src/cli/commands/fix.ts
+import { Command as Command15 } from "commander";
+var fixCommand = new Command15("fix").description("apply safe fixes to project configuration").action(async () => {
+  const result = await checkProject(process.cwd());
+  if (result.issues.length === 0) {
+    logger.info("No issues found.");
+    return;
+  }
+  await fixProject(result);
+  logger.info("Applied fixes.");
+});
+
+// src/cli/commands/upgrade.ts
+import { Command as Command16 } from "commander";
+import { join as join19, dirname as dirname5 } 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);
+  const preset = getPreset(options.preset);
+  if (!preset) {
+    throw new Error("Unknown preset. Use stackforge list-presets.");
+  }
+  const next = {
+    ...current,
+    ...preset,
+    preset: options.preset,
+    projectName: current.projectName,
+    packageManager: current.packageManager,
+    aiAgents: current.aiAgents
+  };
+  if (current.frontend.type !== next.frontend.type || current.frontend.language !== next.frontend.language) {
+    throw new Error("Preset upgrade does not support changing frontend type or language yet.");
+  }
+  validateConfig(next);
+  validateCompatibility(next);
+  validateDependencies(next);
+  if (current.ui.library !== next.ui.library) {
+    await cleanupFeature(cwd, current, "ui", current.ui.library);
+  }
+  if (current.database.provider !== next.database.provider) {
+    await cleanupFeature(cwd, current, "database", current.database.provider);
+  }
+  if (current.database.orm !== next.database.orm) {
+    await cleanupFeature(cwd, current, "orm", current.database.orm);
+  }
+  if (current.auth.provider !== next.auth.provider) {
+    await cleanupFeature(cwd, current, "auth", current.auth.provider);
+  }
+  if (current.api.type !== next.api.type) {
+    await cleanupFeature(cwd, current, "api", current.api.type);
+  }
+  const removedFeatures = current.features.filter((f) => !next.features.includes(f));
+  for (const feature of removedFeatures) {
+    await cleanupFeature(cwd, current, "feature", feature);
+  }
+  await writeProjectConfig(cwd, next);
+  await syncPackageJson(join19(cwd, "package.json"), current, next);
+  const root = dirname5(cwd);
+  await generateFrontendFiles(root, next);
+  await generateUiFiles(root, next);
+  await generateDatabaseFiles(root, next);
+  await generateAuthFiles(root, next);
+  await generateApiFiles(root, next);
+  await generateFeatureFiles(root, next);
+  const readme = buildProjectReadme(next);
+  await writeTextFile(join19(cwd, "README.md"), readme + "\n");
+  logger.info(`Upgraded project to preset: ${options.preset}`);
+});
+
+// src/cli.ts
+var program = new Command17();
+program.name("create-stackforge").description("Universal full-stack boilerplate generator").version("0.0.0");
+program.addCommand(createCommand);
+program.addCommand(listCommand);
+program.addCommand(addCommand);
+program.addCommand(removeCommand);
+program.addCommand(updateCommand);
+program.addCommand(doctorCommand);
+program.addCommand(configureAgentsCommand);
+program.addCommand(addAgentCommand);
+program.addCommand(removeAgentCommand);
+program.addCommand(listAgentsCommand);
+program.addCommand(migrateCommand);
+program.addCommand(listPresetsCommand);
+program.addCommand(useCommand);
+program.addCommand(validateCommand);
+program.addCommand(fixCommand);
+program.addCommand(upgradeCommand);
+program.parseAsync(process.argv).catch((err) => {
+  logger.error(err instanceof Error ? err.message : String(err));
+  process.exitCode = 1;
+});
+//# sourceMappingURL=cli.js.map