create-ncf 0.1.0

package/dist/index.js

@@ -0,0 +1,813 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import * as p2 from "@clack/prompts";
+import { execSync } from "child_process";
+import fs3 from "fs-extra";
+import path3 from "path";
+import pc2 from "picocolors";
+
+// src/prompts.ts
+import * as p from "@clack/prompts";
+import pc from "picocolors";
+
+// src/types.ts
+var FEATURE_LABELS = {
+  trpc: {
+    label: "tRPC",
+    hint: "Type-safe API with React Query"
+  },
+  drizzle: {
+    label: "Drizzle ORM + D1",
+    hint: "Database with SQLite on Cloudflare"
+  },
+  auth: {
+    label: "better-auth",
+    hint: "Authentication with sign-in/sign-up pages"
+  },
+  r2: {
+    label: "Cloudflare R2",
+    hint: "Object storage helper"
+  },
+  queues: {
+    label: "Cloudflare Queues",
+    hint: "Background job processing with Worker consumer"
+  },
+  imageLoader: {
+    label: "Cloudflare Image Loader",
+    hint: "Custom Next.js image loader for CF Image Transformations"
+  },
+  posthog: {
+    label: "PostHog Analytics",
+    hint: "Product analytics"
+  },
+  shadcn: {
+    label: "shadcn/ui",
+    hint: "UI component library"
+  }
+};
+
+// src/prompts.ts
+async function runPrompts(cliProjectName) {
+  p.intro(pc.bgCyan(pc.black(" create-ncf ")));
+  const projectName = cliProjectName ?? await p.text({
+    message: "Where should we create your project?",
+    placeholder: "./my-app",
+    defaultValue: "./my-app",
+    validate(value) {
+      if (!value.trim()) return "Please enter a project name.";
+    }
+  });
+  if (p.isCancel(projectName)) {
+    p.cancel("Operation cancelled.");
+    process.exit(0);
+  }
+  const selectedFeatures = await p.multiselect({
+    message: "Which features would you like to include?",
+    options: [
+      {
+        value: "trpc",
+        label: FEATURE_LABELS.trpc.label,
+        hint: FEATURE_LABELS.trpc.hint
+      },
+      {
+        value: "drizzle",
+        label: FEATURE_LABELS.drizzle.label,
+        hint: FEATURE_LABELS.drizzle.hint
+      },
+      {
+        value: "auth",
+        label: FEATURE_LABELS.auth.label,
+        hint: FEATURE_LABELS.auth.hint
+      },
+      {
+        value: "r2",
+        label: FEATURE_LABELS.r2.label,
+        hint: FEATURE_LABELS.r2.hint
+      },
+      {
+        value: "queues",
+        label: FEATURE_LABELS.queues.label,
+        hint: FEATURE_LABELS.queues.hint
+      },
+      {
+        value: "imageLoader",
+        label: FEATURE_LABELS.imageLoader.label,
+        hint: FEATURE_LABELS.imageLoader.hint
+      },
+      {
+        value: "posthog",
+        label: FEATURE_LABELS.posthog.label,
+        hint: FEATURE_LABELS.posthog.hint
+      },
+      {
+        value: "shadcn",
+        label: FEATURE_LABELS.shadcn.label,
+        hint: FEATURE_LABELS.shadcn.hint
+      }
+    ],
+    initialValues: [
+      "trpc",
+      "drizzle",
+      "auth",
+      "shadcn"
+    ],
+    required: false
+  });
+  if (p.isCancel(selectedFeatures)) {
+    p.cancel("Operation cancelled.");
+    process.exit(0);
+  }
+  const features = [...selectedFeatures];
+  if (features.includes("auth") && !features.includes("drizzle")) {
+    features.push("drizzle");
+    p.log.info("better-auth requires Drizzle + D1. It has been automatically included.");
+  }
+  const featureList = features.length > 0 ? features.map((f) => FEATURE_LABELS[f].label).join(", ") : "None (base only)";
+  p.log.info(`Project: ${pc.cyan(projectName)}`);
+  p.log.info(`Features: ${pc.cyan(featureList)}`);
+  const confirmed = await p.confirm({
+    message: "Continue with these settings?"
+  });
+  if (p.isCancel(confirmed) || !confirmed) {
+    p.cancel("Operation cancelled.");
+    process.exit(0);
+  }
+  return {
+    projectName: projectName.replace(/^\.\//, ""),
+    features
+  };
+}
+
+// src/scaffolder.ts
+import fs2 from "fs-extra";
+import path2 from "path";
+
+// src/utils.ts
+import fs from "fs-extra";
+import path from "path";
+function detectPackageManager() {
+  const userAgent = process.env.npm_config_user_agent ?? "";
+  if (userAgent.startsWith("bun")) return "bun";
+  if (userAgent.startsWith("pnpm")) return "pnpm";
+  if (userAgent.startsWith("yarn")) return "yarn";
+  return "npm";
+}
+function getRunCommand(pm) {
+  return pm === "npm" ? "npm run" : `${pm} run`;
+}
+function getInstallCommand(pm) {
+  if (pm === "yarn") return "yarn";
+  return `${pm} install`;
+}
+async function copyDirectory(src, dest, filter) {
+  await fs.copy(src, dest, {
+    overwrite: true,
+    filter: (srcPath) => {
+      if (path.basename(srcPath) === "_dependencies.json") return false;
+      if (filter) return filter(srcPath);
+      return true;
+    }
+  });
+}
+function hasFeature(features, feature) {
+  return features.includes(feature);
+}
+function getTemplatesDir() {
+  return path.resolve(new URL(".", import.meta.url).pathname, "..", "templates");
+}
+
+// src/builders/cloudflare-env.ts
+function buildCloudflareEnvDts(features) {
+  const bindings = ["	ASSETS: Fetcher;"];
+  if (hasFeature(features, "drizzle")) {
+    bindings.push("	DB: D1Database;");
+  }
+  if (hasFeature(features, "auth")) {
+    bindings.push("	KV: KVNamespace;");
+  }
+  if (hasFeature(features, "r2")) {
+    bindings.push("	STORAGE: R2Bucket;");
+  }
+  if (hasFeature(features, "queues")) {
+    bindings.push("	QUEUE: Queue;");
+  }
+  return `// Generated by create-ncf. Run \`wrangler types\` to regenerate with full Cloudflare types.
+/// <reference types="@cloudflare/workers-types" />
+
+interface CloudflareEnv {
+${bindings.join("\n")}
+}
+`;
+}
+function buildLibEnvDts(features) {
+  const entries = [];
+  if (hasFeature(features, "drizzle")) {
+    entries.push("		DB: D1Database;");
+  }
+  if (hasFeature(features, "auth")) {
+    entries.push("		KV: KVNamespace;");
+  }
+  if (hasFeature(features, "r2")) {
+    entries.push("		STORAGE: R2Bucket;");
+  }
+  if (hasFeature(features, "queues")) {
+    entries.push("		QUEUE: Queue;");
+  }
+  if (entries.length === 0) {
+    return `declare namespace NodeJS {
+	interface ProcessEnv {
+		[key: string]: string | undefined;
+	}
+}
+`;
+  }
+  return `declare namespace NodeJS {
+	interface ProcessEnv {
+${entries.join("\n")}
+		[key: string]: string | undefined;
+	}
+}
+`;
+}
+
+// src/builders/env.ts
+function buildEnvJs(features) {
+  const serverVars = [
+    "		NODE_ENV: z",
+    '			.enum(["development", "test", "production"])',
+    '			.default("development"),',
+    "		SITE_URL: z.string().url(),"
+  ];
+  const clientVars = [];
+  const runtimeEnvServer = [
+    "		NODE_ENV: process.env.NODE_ENV,",
+    "		SITE_URL: process.env.SITE_URL,"
+  ];
+  const runtimeEnvClient = [];
+  if (hasFeature(features, "auth")) {
+    serverVars.push(
+      "		BETTER_AUTH_SECRET: z.string().min(1),",
+      "		BETTER_AUTH_URL: z.string().url(),"
+    );
+    runtimeEnvServer.push(
+      "		BETTER_AUTH_SECRET: process.env.BETTER_AUTH_SECRET,",
+      "		BETTER_AUTH_URL: process.env.BETTER_AUTH_URL,"
+    );
+  }
+  if (hasFeature(features, "r2")) {
+    clientVars.push("		NEXT_PUBLIC_R2_DOMAIN: z.string().url().optional(),");
+    runtimeEnvClient.push(
+      "		NEXT_PUBLIC_R2_DOMAIN: process.env.NEXT_PUBLIC_R2_DOMAIN,"
+    );
+  }
+  if (hasFeature(features, "imageLoader")) {
+    clientVars.push(
+      "		NEXT_PUBLIC_CDN_DOMAIN: z.string().url().optional(),"
+    );
+    runtimeEnvClient.push(
+      "		NEXT_PUBLIC_CDN_DOMAIN: process.env.NEXT_PUBLIC_CDN_DOMAIN,"
+    );
+  }
+  if (hasFeature(features, "posthog")) {
+    clientVars.push(
+      "		NEXT_PUBLIC_POSTHOG_KEY: z.string().min(1).optional(),",
+      "		NEXT_PUBLIC_POSTHOG_HOST: z.string().url().optional(),"
+    );
+    runtimeEnvClient.push(
+      "		NEXT_PUBLIC_POSTHOG_KEY: process.env.NEXT_PUBLIC_POSTHOG_KEY,",
+      "		NEXT_PUBLIC_POSTHOG_HOST: process.env.NEXT_PUBLIC_POSTHOG_HOST,"
+    );
+  }
+  const serverSection = serverVars.join("\n");
+  const clientSection = clientVars.length > 0 ? clientVars.join("\n") : "		// Add NEXT_PUBLIC_ client vars here";
+  const runtimeSection = [
+    ...runtimeEnvServer,
+    ...runtimeEnvClient
+  ].join("\n");
+  return `import { createEnv } from "@t3-oss/env-nextjs";
+import { z } from "zod";
+
+export const env = createEnv({
+	server: {
+${serverSection}
+	},
+	client: {
+${clientSection}
+	},
+	runtimeEnv: {
+${runtimeSection}
+	},
+	skipValidation: !!process.env.SKIP_ENV_VALIDATION,
+	emptyStringAsUndefined: true,
+});
+`;
+}
+function buildEnvExample(features) {
+  const lines = [
+    "NODE_ENV=development",
+    "SITE_URL=http://localhost:3000",
+    ""
+  ];
+  if (hasFeature(features, "auth")) {
+    lines.push(
+      "# Authentication (better-auth)",
+      "BETTER_AUTH_SECRET=replace-with-a-secure-random-string",
+      "BETTER_AUTH_URL=http://localhost:3000",
+      ""
+    );
+  }
+  if (hasFeature(features, "r2")) {
+    lines.push(
+      "# Cloudflare R2 Storage",
+      "NEXT_PUBLIC_R2_DOMAIN=https://your-r2-domain.com",
+      ""
+    );
+  }
+  if (hasFeature(features, "imageLoader")) {
+    lines.push(
+      "# Cloudflare Image Loader",
+      "NEXT_PUBLIC_CDN_DOMAIN=https://your-cdn-domain.com",
+      ""
+    );
+  }
+  if (hasFeature(features, "posthog")) {
+    lines.push(
+      "# PostHog Analytics",
+      "NEXT_PUBLIC_POSTHOG_KEY=your-posthog-project-api-key",
+      "NEXT_PUBLIC_POSTHOG_HOST=https://us.i.posthog.com",
+      ""
+    );
+  }
+  return lines.join("\n");
+}
+
+// src/builders/next-config.ts
+function buildNextConfig(features) {
+  const imports = [
+    'import { initOpenNextCloudflareForDev } from "@opennextjs/cloudflare";',
+    'import type { NextConfig } from "next";'
+  ];
+  const configParts = [];
+  if (hasFeature(features, "imageLoader")) {
+    configParts.push(`	images: {
+		loader: "custom",
+		loaderFile: "./src/lib/image-loader.ts",
+	},`);
+  }
+  if (hasFeature(features, "posthog")) {
+    configParts.push(`	async rewrites() {
+		return [
+			{
+				source: "/ingest/static/:path*",
+				destination: "https://us-assets.i.posthog.com/static/:path*",
+			},
+			{
+				source: "/ingest/:path*",
+				destination: "https://us.i.posthog.com/:path*",
+			},
+		];
+	},
+	skipTrailingSlashRedirect: true,`);
+  }
+  const configBody = configParts.length > 0 ? `
+${configParts.join("\n")}
+` : "";
+  return `${imports.join("\n")}
+
+initOpenNextCloudflareForDev();
+
+const nextConfig: NextConfig = {${configBody}};
+
+export default nextConfig;
+`;
+}
+
+// src/builders/package-json.ts
+function buildPackageJson(projectName, features) {
+  const pkg = {
+    name: projectName,
+    version: "0.1.0",
+    private: true,
+    type: "module",
+    scripts: {
+      check: "biome check .",
+      "check:write": "biome check --write .",
+      dev: "next dev --turbopack",
+      build: "next build",
+      start: "next start",
+      deploy: "opennextjs-cloudflare build && opennextjs-cloudflare deploy",
+      preview: "opennextjs-cloudflare build && opennextjs-cloudflare preview",
+      "cf-typegen": "wrangler types --env-interface CloudflareEnv ./cloudflare-env.d.ts"
+    },
+    dependencies: {
+      "@opennextjs/cloudflare": "^1.3.0",
+      "@t3-oss/env-nextjs": "^0.13.8",
+      next: "15.4.6",
+      react: "19.1.0",
+      "react-dom": "19.1.0",
+      zod: "^4.1.9",
+      clsx: "^2.1.1",
+      "tailwind-merge": "^3.5.0"
+    },
+    devDependencies: {
+      "@biomejs/biome": "^2.3.11",
+      "@cloudflare/workers-types": "^4.20260116.0",
+      "@tailwindcss/postcss": "^4",
+      "@types/node": "^24.5.2",
+      "@types/react": "^19",
+      "@types/react-dom": "^19",
+      tailwindcss: "^4",
+      typescript: "^5",
+      wrangler: "^4.47.0"
+    }
+  };
+  if (hasFeature(features, "trpc")) {
+    Object.assign(pkg.dependencies, {
+      "@trpc/client": "^11.1.2",
+      "@trpc/react-query": "^11.1.2",
+      "@trpc/server": "^11.1.2",
+      "@tanstack/react-query": "^5.89.0",
+      superjson: "^2.2.2"
+    });
+  }
+  if (hasFeature(features, "drizzle")) {
+    Object.assign(pkg.dependencies, {
+      "drizzle-orm": "^0.44.5"
+    });
+    Object.assign(pkg.devDependencies, {
+      "drizzle-kit": "^0.31.4"
+    });
+    Object.assign(pkg.scripts, {
+      "db:generate": "drizzle-kit generate",
+      "db:migrate": `wrangler d1 migrations apply ${projectName}`,
+      "db:migrate-remote": `wrangler d1 migrations apply ${projectName} --remote`
+    });
+  }
+  if (hasFeature(features, "auth")) {
+    Object.assign(pkg.dependencies, {
+      "better-auth": "^1.4.13",
+      "better-auth-cloudflare": "^0.2.9"
+    });
+  }
+  if (hasFeature(features, "posthog")) {
+    Object.assign(pkg.dependencies, {
+      "posthog-js": "^1.352.0",
+      "posthog-node": "^5.24.17"
+    });
+  }
+  if (hasFeature(features, "shadcn")) {
+    Object.assign(pkg.dependencies, {
+      "class-variance-authority": "^0.7.1",
+      "lucide-react": "^0.575.0",
+      "radix-ui": "^1.4.3",
+      sonner: "^2.0.7"
+    });
+    Object.assign(pkg.devDependencies, {
+      "tw-animate-css": "^1.3.8"
+    });
+  }
+  return JSON.stringify(pkg, null, "	");
+}
+
+// src/builders/wrangler.ts
+function buildWrangler(projectName, features) {
+  const lines = [
+    "{",
+    '	"$schema": "node_modules/wrangler/config-schema.json",',
+    `	"name": "${projectName}",`,
+    '	"main": "worker.ts",',
+    '	"compatibility_date": "2025-03-01",',
+    '	"compatibility_flags": ["nodejs_compat"],',
+    '	"assets": {',
+    '		"binding": "ASSETS",',
+    '		"directory": ".open-next/assets"',
+    "	},",
+    '	"observability": {',
+    '		"enabled": true',
+    "	}"
+  ];
+  if (hasFeature(features, "drizzle")) {
+    lines.push(
+      ",",
+      '	"d1_databases": [',
+      "		{",
+      '			"binding": "DB",',
+      `			"database_name": "${projectName}",`,
+      '			"database_id": "YOUR_DATABASE_ID",',
+      '			"migrations_dir": "migrations"',
+      "		}",
+      "	]"
+    );
+  }
+  if (hasFeature(features, "auth")) {
+    lines.push(
+      ",",
+      '	"kv_namespaces": [',
+      "		{",
+      '			"binding": "KV",',
+      '			"id": "YOUR_KV_NAMESPACE_ID"',
+      "		}",
+      "	]"
+    );
+  }
+  if (hasFeature(features, "r2")) {
+    lines.push(
+      ",",
+      '	"r2_buckets": [',
+      "		{",
+      '			"binding": "STORAGE",',
+      `			"bucket_name": "${projectName}"`,
+      "		}",
+      "	]"
+    );
+  }
+  if (hasFeature(features, "queues")) {
+    lines.push(
+      ",",
+      '	"queues": {',
+      '		"consumers": [',
+      "			{",
+      `				"queue": "${projectName}",`,
+      '				"max_retries": 3,',
+      `				"dead_letter_queue": "${projectName}-dlq"`,
+      "			},",
+      "			{",
+      `				"queue": "${projectName}-dlq"`,
+      "			}",
+      "		],",
+      '		"producers": [',
+      "			{",
+      '				"binding": "QUEUE",',
+      `				"queue": "${projectName}"`,
+      "			}",
+      "		]",
+      "	}"
+    );
+  }
+  const vars = {
+    SITE_URL: "http://localhost:3000"
+  };
+  if (hasFeature(features, "auth")) {
+    vars.BETTER_AUTH_URL = "http://localhost:3000";
+  }
+  if (hasFeature(features, "r2")) {
+    vars.NEXT_PUBLIC_R2_DOMAIN = "https://your-r2-domain.com";
+  }
+  if (hasFeature(features, "imageLoader")) {
+    vars.NEXT_PUBLIC_CDN_DOMAIN = "https://your-cdn-domain.com";
+  }
+  if (hasFeature(features, "posthog")) {
+    vars.NEXT_PUBLIC_POSTHOG_KEY = "your-posthog-key";
+    vars.NEXT_PUBLIC_POSTHOG_HOST = "https://us.i.posthog.com";
+  }
+  if (Object.keys(vars).length > 0) {
+    const varEntries = Object.entries(vars).map(([k, v]) => `		"${k}": "${v}"`).join(",\n");
+    lines.push(",", '	"vars": {', varEntries, "	}");
+  }
+  lines.push("}");
+  return lines.join("\n");
+}
+
+// src/builders/worker.ts
+function buildWorkerTs(features) {
+  const lines = [
+    "// @ts-ignore \u2014 .open-next is generated by opennextjs-cloudflare build",
+    'import openNextWorker from "./.open-next/worker";',
+    "",
+    "// Durable Objects exported from the package directly",
+    'export { BucketCachePurge } from "@opennextjs/cloudflare/durable-objects/bucket-cache-purge";',
+    'export { DOQueueHandler } from "@opennextjs/cloudflare/durable-objects/queue";',
+    'export { DOShardedTagCache } from "@opennextjs/cloudflare/durable-objects/sharded-tag-cache";'
+  ];
+  if (hasFeature(features, "queues")) {
+    lines.push(
+      "",
+      "async function handleQueue(",
+      "	batch: MessageBatch<unknown>,",
+      "	env: CloudflareEnv,",
+      ") {",
+      "	// Bridge Cloudflare env vars to process.env so modules importing ~/env work.",
+      "	for (const [key, value] of Object.entries(env)) {",
+      '		if (typeof value === "string") {',
+      "			process.env[key] = value;",
+      "		}",
+      "	}",
+      "",
+      '	const { handleBatch, handleDlqBatch } = await import("./src/server/queues/handler");',
+      "",
+      `	if (batch.queue.endsWith("-dlq")) {`,
+      "		await handleDlqBatch(batch, env);",
+      "		return;",
+      "	}",
+      "",
+      "	await handleBatch(batch, env);",
+      "}"
+    );
+  }
+  lines.push("", "export default {");
+  lines.push(
+    "	fetch(request: Request, env: CloudflareEnv, ctx: ExecutionContext) {",
+    "		return openNextWorker.fetch(request, env, ctx);",
+    "	},"
+  );
+  if (hasFeature(features, "queues")) {
+    lines.push(
+      "	async queue(batch: MessageBatch<unknown>, env: CloudflareEnv) {",
+      "		await handleQueue(batch, env);",
+      "	},"
+    );
+  }
+  lines.push("};");
+  return lines.join("\n");
+}
+
+// src/scaffolder.ts
+async function scaffold(targetDir, selections) {
+  const { projectName, features } = selections;
+  const templatesDir = getTemplatesDir();
+  await fs2.ensureDir(targetDir);
+  await copyDirectory(path2.join(templatesDir, "base"), targetDir);
+  const featureDirs = [];
+  if (hasFeature(features, "trpc")) {
+    featureDirs.push("trpc");
+  }
+  if (hasFeature(features, "drizzle")) {
+    featureDirs.push("drizzle");
+  }
+  if (hasFeature(features, "auth")) {
+    featureDirs.push("auth");
+  }
+  if (hasFeature(features, "r2")) {
+    featureDirs.push("r2");
+  }
+  if (hasFeature(features, "queues")) {
+    featureDirs.push("queues");
+  }
+  if (hasFeature(features, "imageLoader")) {
+    featureDirs.push("image-loader");
+  }
+  if (hasFeature(features, "posthog")) {
+    featureDirs.push("posthog");
+  }
+  if (hasFeature(features, "shadcn")) {
+    featureDirs.push("shadcn");
+  }
+  for (const dir of featureDirs) {
+    const featurePath = path2.join(templatesDir, dir);
+    if (await fs2.pathExists(featurePath)) {
+      await copyDirectory(featurePath, targetDir);
+    }
+  }
+  if (hasFeature(features, "trpc")) {
+    const trpcDir = path2.join(targetDir, "src", "server", "api");
+    if (hasFeature(features, "auth") && hasFeature(features, "drizzle")) {
+      const withAuthPath = path2.join(trpcDir, "trpc.with-auth.ts");
+      const trpcPath = path2.join(trpcDir, "trpc.ts");
+      if (await fs2.pathExists(withAuthPath)) {
+        await fs2.remove(trpcPath);
+        await fs2.rename(withAuthPath, trpcPath);
+      }
+    } else {
+      const withAuthPath = path2.join(trpcDir, "trpc.with-auth.ts");
+      if (await fs2.pathExists(withAuthPath)) {
+        await fs2.remove(withAuthPath);
+      }
+    }
+  }
+  if (hasFeature(features, "drizzle")) {
+    const schemaIndexPath = path2.join(
+      targetDir,
+      "src",
+      "server",
+      "db",
+      "schema",
+      "index.ts"
+    );
+    if (hasFeature(features, "auth")) {
+      await fs2.writeFile(
+        schemaIndexPath,
+        'export * from "./example";\nexport * from "./auth";\n'
+      );
+    }
+  }
+  await fs2.writeFile(
+    path2.join(targetDir, "package.json"),
+    buildPackageJson(projectName, features)
+  );
+  await fs2.writeFile(
+    path2.join(targetDir, "wrangler.jsonc"),
+    buildWrangler(projectName, features)
+  );
+  await fs2.writeFile(
+    path2.join(targetDir, "next.config.ts"),
+    buildNextConfig(features)
+  );
+  await fs2.writeFile(
+    path2.join(targetDir, "worker.ts"),
+    buildWorkerTs(features)
+  );
+  await fs2.writeFile(
+    path2.join(targetDir, "cloudflare-env.d.ts"),
+    buildCloudflareEnvDts(features)
+  );
+  await fs2.writeFile(
+    path2.join(targetDir, "lib.env.d.ts"),
+    buildLibEnvDts(features)
+  );
+  await fs2.writeFile(
+    path2.join(targetDir, "src", "env.js"),
+    buildEnvJs(features)
+  );
+  await fs2.writeFile(
+    path2.join(targetDir, ".env.example"),
+    buildEnvExample(features)
+  );
+}
+
+// src/cli.ts
+async function cli() {
+  const args = process.argv.slice(2);
+  const cliProjectName = args[0] && !args[0].startsWith("-") ? args[0] : void 0;
+  const selections = await runPrompts(cliProjectName);
+  const targetDir = path3.resolve(process.cwd(), selections.projectName);
+  if (await fs3.pathExists(targetDir)) {
+    const files = await fs3.readdir(targetDir);
+    if (files.length > 0) {
+      p2.log.error(`Directory ${pc2.cyan(selections.projectName)} is not empty.`);
+      process.exit(1);
+    }
+  }
+  const spinner2 = p2.spinner();
+  spinner2.start("Creating project structure...");
+  await scaffold(targetDir, selections);
+  spinner2.stop("Project structure created.");
+  const pm = detectPackageManager();
+  spinner2.start("Installing dependencies...");
+  try {
+    execSync(getInstallCommand(pm), {
+      cwd: targetDir,
+      stdio: "ignore"
+    });
+    spinner2.stop("Dependencies installed.");
+  } catch {
+    spinner2.stop("Failed to install dependencies. You can install them manually.");
+  }
+  spinner2.start("Initializing git repository...");
+  try {
+    execSync("git init && git add -A && git commit -m 'Initial commit from create-ncf'", {
+      cwd: targetDir,
+      stdio: "ignore"
+    });
+    spinner2.stop("Git repository initialized.");
+  } catch {
+    spinner2.stop("Failed to initialize git. You can do this manually.");
+  }
+  const runCmd = getRunCommand(pm);
+  p2.note(
+    [
+      `cd ${selections.projectName}`,
+      "cp .env.example .env.local",
+      "# Edit .env.local with your values",
+      `${runCmd} dev`
+    ].join("\n"),
+    "Next steps"
+  );
+  const cfSteps = [];
+  if (selections.features.includes("drizzle")) {
+    cfSteps.push(
+      `wrangler d1 create ${selections.projectName}`,
+      "# Update wrangler.jsonc with your database_id",
+      `${runCmd} db:generate`,
+      `${runCmd} db:migrate`
+    );
+  }
+  if (selections.features.includes("r2")) {
+    cfSteps.push(
+      `wrangler r2 bucket create ${selections.projectName}`,
+      "# Update wrangler.jsonc with your bucket name"
+    );
+  }
+  if (selections.features.includes("queues")) {
+    cfSteps.push(
+      `wrangler queues create ${selections.projectName}`,
+      `wrangler queues create ${selections.projectName}-dlq`
+    );
+  }
+  if (cfSteps.length > 0) {
+    p2.note(cfSteps.join("\n"), "Cloudflare setup");
+  }
+  if (selections.features.includes("imageLoader")) {
+    p2.log.warn(
+      pc2.yellow(
+        "Remember to enable Cloudflare Image Transformations on your zone:\nCloudflare Dashboard \u2192 Speed \u2192 Image Transformations \u2192 Enable"
+      )
+    );
+  }
+  p2.note(`${runCmd} deploy`, "Deploy");
+  p2.outro(pc2.green("Happy building!"));
+}
+
+// src/index.ts
+cli().catch(console.error);
+//# sourceMappingURL=index.js.map