@fluxy-chat/create-fluxy-chat 0.1.0

package/dist/index.js

@@ -0,0 +1,946 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { intro, log, note, outro, spinner } from "@clack/prompts";
+import pc from "picocolors";
+
+// src/prompts.ts
+import {
+  confirm,
+  isCancel,
+  select,
+  text
+} from "@clack/prompts";
+
+// src/utils.ts
+import fs from "fs";
+import path from "path";
+var PACKAGE_NAME_PATTERN = /^[a-z0-9][a-z0-9._-]*$/;
+var PACKAGE_MANAGERS = /* @__PURE__ */ new Set(["npm", "yarn", "pnpm"]);
+function validateProjectName(value) {
+  const name = value?.trim() ?? "";
+  if (!name) {
+    return "Project name is required";
+  }
+  if (name.startsWith(".") || name.startsWith("_") || name.includes("..") || !PACKAGE_NAME_PATTERN.test(name)) {
+    return "Use a valid npm package name (unscoped), like my-bot";
+  }
+}
+function isPackageManager(value) {
+  return PACKAGE_MANAGERS.has(value);
+}
+function isAdapterType(value) {
+  return ["basic", "slack", "telegram", "discord", "web"].includes(value);
+}
+function detectPackageManagerFromLockfiles(cwd) {
+  if (fs.existsSync(path.join(cwd, "pnpm-lock.yaml"))) {
+    return "pnpm";
+  }
+  if (fs.existsSync(path.join(cwd, "yarn.lock"))) {
+    return "yarn";
+  }
+  return "npm";
+}
+function detectPackageManager(userAgent = "") {
+  if (userAgent.startsWith("pnpm")) {
+    return "pnpm";
+  }
+  if (userAgent.startsWith("yarn")) {
+    return "yarn";
+  }
+  return "npm";
+}
+function installCommand(pm) {
+  switch (pm) {
+    case "pnpm":
+      return "pnpm install";
+    case "yarn":
+      return "yarn install";
+    default:
+      return "npm install";
+  }
+}
+function devCommand(pm) {
+  switch (pm) {
+    case "pnpm":
+      return "pnpm dev";
+    case "yarn":
+      return "yarn dev";
+    default:
+      return "npm run dev";
+  }
+}
+function writeFile(projectDir, filePath, content) {
+  const fullPath = path.join(projectDir, filePath);
+  fs.mkdirSync(path.dirname(fullPath), { recursive: true });
+  fs.writeFileSync(fullPath, content);
+}
+function writeJson(projectDir, filePath, value) {
+  writeFile(projectDir, filePath, `${JSON.stringify(value, null, 2)}
+`);
+}
+
+// src/prompts.ts
+var DEFAULT_PROJECT_NAME = "my-fluxy-bot";
+async function runPrompts(inputs) {
+  let name = inputs.name;
+  if (!name) {
+    if (inputs.yes) {
+      name = DEFAULT_PROJECT_NAME;
+    } else {
+      const result = await text({
+        message: "Project name:",
+        placeholder: DEFAULT_PROJECT_NAME,
+        validate: validateProjectName
+      });
+      if (isCancel(result)) return null;
+      name = String(result).trim();
+    }
+  }
+  const nameError = validateProjectName(name);
+  if (nameError) {
+    throw new Error(nameError);
+  }
+  let adapter = inputs.adapter;
+  if (!adapter) {
+    if (inputs.yes) {
+      adapter = "basic";
+    } else {
+      const result = await select({
+        message: "Select an adapter:",
+        options: [
+          { label: "Basic (Cloudflare Workers)", value: "basic" },
+          { label: "Slack", value: "slack" },
+          { label: "Telegram", value: "telegram" },
+          { label: "Discord", value: "discord" },
+          { label: "Web Chat", value: "web" }
+        ]
+      });
+      if (isCancel(result)) return null;
+      adapter = result;
+    }
+  }
+  let language = inputs.language;
+  if (!language) {
+    if (inputs.yes) {
+      language = "typescript";
+    } else {
+      const result = await select({
+        message: "Language:",
+        options: [
+          { label: "TypeScript", value: "typescript" },
+          { label: "JavaScript", value: "javascript" }
+        ]
+      });
+      if (isCancel(result)) return null;
+      language = result;
+    }
+  }
+  let packageManager = inputs.packageManager;
+  if (!packageManager) {
+    const detected = detectPackageManagerFromLockfiles(process.cwd()) || detectPackageManager(process.env.npm_config_user_agent);
+    if (inputs.yes) {
+      packageManager = detected;
+    } else {
+      const result = await select({
+        message: "Package manager:",
+        initialValue: detected,
+        options: [
+          { label: "npm", value: "npm" },
+          { label: "pnpm", value: "pnpm" },
+          { label: "yarn", value: "yarn" }
+        ]
+      });
+      if (isCancel(result)) return null;
+      packageManager = result;
+    }
+  }
+  const shouldInstall = inputs.shouldInstall ?? (inputs.yes ? true : await confirm({
+    message: "Install dependencies?",
+    initialValue: true
+  }));
+  if (isCancel(shouldInstall)) return null;
+  const shouldInitGit = inputs.shouldInitGit ?? (inputs.yes ? true : await confirm({
+    message: "Initialize git repository?",
+    initialValue: true
+  }));
+  if (isCancel(shouldInitGit)) return null;
+  return {
+    name,
+    adapter,
+    packageManager,
+    language,
+    shouldInstall,
+    shouldInitGit
+  };
+}
+
+// src/templates.ts
+function generatePackageJson(config) {
+  const deps = {
+    "@fluxy-chat/sdk": "latest"
+  };
+  const devDeps = {
+    typescript: "^5.6.0",
+    "@cloudflare/workers-types": "^4.0.0",
+    wrangler: "^3.0.0"
+  };
+  switch (config.adapter) {
+    case "slack":
+      deps["@slack/web-api"] = "^7.0.0";
+      deps["@slack/bolt"] = "^4.0.0";
+      break;
+    case "telegram":
+      deps["node-telegram-bot-api"] = "^0.66.0";
+      break;
+    case "discord":
+      deps["discord.js"] = "^14.0.0";
+      break;
+    case "web":
+      break;
+  }
+  const scripts = {
+    dev: "wrangler dev",
+    deploy: "wrangler deploy",
+    "type-check": "tsc --noEmit"
+  };
+  return {
+    name: config.name,
+    version: "0.1.0",
+    type: "module",
+    private: true,
+    scripts,
+    dependencies: sortRecord(deps),
+    devDependencies: sortRecord(devDeps)
+  };
+}
+function sortRecord(record) {
+  return Object.fromEntries(
+    Object.entries(record).sort(([a], [b]) => a.localeCompare(b))
+  );
+}
+function generateTsConfig() {
+  return {
+    compilerOptions: {
+      target: "ES2022",
+      module: "ESNext",
+      moduleResolution: "bundler",
+      lib: ["ES2022"],
+      types: ["@cloudflare/workers-types"],
+      strict: true,
+      esModuleInterop: true,
+      skipLibCheck: true,
+      forceConsistentCasingInFileNames: true,
+      resolveJsonModule: true,
+      allowSyntheticDefaultImports: true,
+      noEmit: true
+    },
+    include: ["src/**/*"],
+    exclude: ["node_modules", "dist"]
+  };
+}
+function generateWranglerToml(config) {
+  return `name = "${config.name}"
+main = "src/index.ts"
+compatibility_date = "2024-12-01"
+
+[vars]
+FLUXY_BASE_URL = "https://your-fluxychat-worker.example.com"
+
+# Set these via \`wrangler secret put\` for production
+# wrangler secret put FLUXY_API_KEY
+`;
+}
+function generateDevVars() {
+  return `# Local development environment variables
+# Copy this file to .dev.vars and fill in your values
+
+FLUXY_API_KEY=your-api-key-here
+FLUXY_BASE_URL=http://localhost:8787
+`;
+}
+function generateGitignore() {
+  return `node_modules/
+dist/
+.dev.vars
+.wrangler/
+*.log
+.DS_Store
+.env
+.env.local
+`;
+}
+function generateEnvExample(config) {
+  const lines = [
+    "# Bot Configuration",
+    `FLUXY_BASE_URL=https://your-fluxychat-worker.example.com`,
+    "FLUXY_API_KEY=your-api-key-here",
+    ""
+  ];
+  switch (config.adapter) {
+    case "slack":
+      lines.push(
+        "# Slack Configuration",
+        "SLACK_BOT_TOKEN=xoxb-your-bot-token",
+        "SLACK_SIGNING_SECRET=your-signing-secret",
+        "SLACK_PORT=3000",
+        ""
+      );
+      break;
+    case "telegram":
+      lines.push(
+        "# Telegram Configuration",
+        "TELEGRAM_BOT_TOKEN=your-telegram-bot-token",
+        "TELEGRAM_WEBHOOK_URL=https://your-worker.example.com/telegram/webhook",
+        ""
+      );
+      break;
+    case "discord":
+      lines.push(
+        "# Discord Configuration",
+        "DISCORD_BOT_TOKEN=your-discord-bot-token",
+        "DISCORD_APPLICATION_ID=your-application-id",
+        "DISCORD_PUBLIC_KEY=your-public-key",
+        ""
+      );
+      break;
+    case "web":
+      lines.push(
+        "# Web Chat Configuration",
+        "# The web adapter uses FluxyChat SDK directly, no extra secrets needed",
+        ""
+      );
+      break;
+  }
+  return `${lines.join("\n").trimEnd()}
+`;
+}
+function generateReadme(config) {
+  const adapterTitle = config.adapter.charAt(0).toUpperCase() + config.adapter.slice(1);
+  const pm = config.packageManager;
+  const endpoints = [];
+  if (config.adapter === "basic") {
+    endpoints.push("- Health check: `/`");
+    endpoints.push("- Webhook: `/webhook`");
+  } else if (config.adapter === "slack") {
+    endpoints.push("- Slack Events API: `/slack/events`");
+    endpoints.push("- Slack Interactive: `/slack/interactive`");
+  } else if (config.adapter === "telegram") {
+    endpoints.push("- Telegram Webhook: `/telegram/webhook`");
+  } else if (config.adapter === "discord") {
+    endpoints.push("- Discord Interactions: `/discord/interactions`");
+  } else if (config.adapter === "web") {
+    endpoints.push("- Chat API: `/api/chat`");
+    endpoints.push("- Health: `/`");
+  }
+  return `# ${config.name}
+
+A ${adapterTitle} bot built with [FluxyChat](https://github.com/AlessandroFare/fluxychat) and deployed on Cloudflare Workers.
+
+## Getting Started
+
+1. Copy the example environment file and fill in your credentials:
+
+\`\`\`bash
+cp .env.example .dev.vars
+\`\`\`
+
+2. Start the dev server:
+
+\`\`\`bash
+${devCommand(pm)}
+\`\`\`
+
+3. Deploy to Cloudflare Workers:
+
+\`\`\`bash
+${pm} run deploy
+\`\`\`
+
+## Endpoints
+
+${endpoints.join("\n")}
+
+## Project Structure
+
+\`\`\`
+src/
+  index.ts    Worker entry point
+  bot.ts      Bot handler with ${adapterTitle} adapter
+.dev.vars     Local development environment variables
+wrangler.toml Cloudflare Workers configuration
+\`\`\`
+
+## Scripts
+
+| Command | Description |
+| --- | --- |
+| \`${devCommand(pm)}\` | Start the development server |
+| \`${pm} run deploy\` | Deploy to Cloudflare Workers |
+| \`${pm} run type-check\` | Type-check the project |
+
+## Environment Variables
+
+See \`.env.example\` for all required environment variables.
+
+## Learn More
+
+- [FluxyChat SDK Documentation](https://github.com/AlessandroFare/fluxychat/tree/main/packages/sdk)
+- [Cloudflare Workers Docs](https://developers.cloudflare.com/workers/)
+
+## License
+
+MIT
+`;
+}
+function generateWorkerIndex(config) {
+  switch (config.adapter) {
+    case "slack":
+      return `import { handleSlackRequest, createSlackBot } from "./bot.js";
+
+const bot = createSlackBot();
+
+export default {
+  async fetch(request: Request, env: Record<string, string>): Promise<Response> {
+    const url = new URL(request.url);
+
+    if (url.pathname === "/slack/events" || url.pathname === "/slack/interactive") {
+      return handleSlackRequest(request, env, bot);
+    }
+
+    if (url.pathname === "/") {
+      return new Response("FluxyChat Slack bot is running!", { status: 200 });
+    }
+
+    return new Response("Not Found", { status: 404 });
+  },
+};
+`;
+    case "telegram":
+      return `import { handleTelegramUpdate } from "./bot.js";
+
+export default {
+  async fetch(request: Request, env: Record<string, string>): Promise<Response> {
+    const url = new URL(request.url);
+
+    if (url.pathname === "/telegram/webhook" && request.method === "POST") {
+      const update = await request.json();
+      return handleTelegramUpdate(update, env);
+    }
+
+    if (url.pathname === "/") {
+      return new Response("FluxyChat Telegram bot is running!", { status: 200 });
+    }
+
+    return new Response("Not Found", { status: 404 });
+  },
+};
+`;
+    case "discord":
+      return `import { handleDiscordInteraction } from "./bot.js";
+
+export default {
+  async fetch(request: Request, env: Record<string, string>): Promise<Response> {
+    const url = new URL(request.url);
+
+    if (url.pathname === "/discord/interactions" && request.method === "POST") {
+      return handleDiscordInteraction(request, env);
+    }
+
+    if (url.pathname === "/") {
+      return new Response("FluxyChat Discord bot is running!", { status: 200 });
+    }
+
+    return new Response("Not Found", { status: 404 });
+  },
+};
+`;
+    case "web":
+      return `import { handleWebChat } from "./bot.js";
+
+export default {
+  async fetch(request: Request, env: Record<string, string>): Promise<Response> {
+    const url = new URL(request.url);
+
+    if (url.pathname === "/api/chat" && request.method === "POST") {
+      return handleWebChat(request, env);
+    }
+
+    if (url.pathname === "/") {
+      return new Response("FluxyChat Web bot is running!", { status: 200 });
+    }
+
+    return new Response("Not Found", { status: 404 });
+  },
+};
+`;
+    default:
+      return `import { handleWebhook } from "./bot.js";
+
+export default {
+  async fetch(request: Request, env: Record<string, string>): Promise<Response> {
+    const url = new URL(request.url);
+
+    if (url.pathname === "/webhook" && request.method === "POST") {
+      return handleWebhook(request, env);
+    }
+
+    if (url.pathname === "/") {
+      return new Response("FluxyChat bot is running!", { status: 200 });
+    }
+
+    return new Response("Not Found", { status: 404 });
+  },
+};
+`;
+  }
+}
+function generateBotHandler(config) {
+  switch (config.adapter) {
+    case "slack":
+      return `import { FluxyChatClient } from "@fluxy-chat/sdk";
+
+interface BotEnv {
+  FLUXY_BASE_URL: string;
+  FLUXY_API_KEY: string;
+  SLACK_BOT_TOKEN: string;
+  SLACK_SIGNING_SECRET: string;
+}
+
+export interface SlackBot {
+  fluxyClient: FluxyChatClient;
+}
+
+export function createSlackBot(): SlackBot {
+  return {
+    fluxyClient: null as unknown as FluxyChatClient,
+  };
+}
+
+export async function handleSlackRequest(
+  request: Request,
+  env: BotEnv,
+  bot: SlackBot,
+): Promise<Response> {
+  const body = await request.text();
+
+  // Initialize FluxyChat client
+  const client = new FluxyChatClient({
+    baseUrl: env.FLUXY_BASE_URL,
+    userId: "slack-bot",
+    apiKey: env.FLUXY_API_KEY,
+  });
+
+  try {
+    const payload = JSON.parse(body);
+
+    // Handle Slack URL verification challenge
+    if (payload.type === "url_verification") {
+      return new Response(JSON.stringify({ challenge: payload.challenge }), {
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+
+    // Handle events
+    if (payload.event) {
+      const event = payload.event;
+
+      if (event.type === "message" && !event.bot_id) {
+        // Forward message to FluxyChat
+        const roomId = \`slack-\${event.channel}\`;
+        await client.createMessage(roomId, event.text || "");
+      }
+    }
+
+    return new Response("OK", { status: 200 });
+  } catch (error) {
+    console.error("Slack event error:", error);
+    return new Response("Internal Server Error", { status: 500 });
+  }
+}
+`;
+    case "telegram":
+      return `import { FluxyChatClient } from "@fluxy-chat/sdk";
+
+interface BotEnv {
+  FLUXY_BASE_URL: string;
+  FLUXY_API_KEY: string;
+  TELEGRAM_BOT_TOKEN: string;
+}
+
+export async function handleTelegramUpdate(
+  update: Record<string, unknown>,
+  env: BotEnv,
+): Promise<Response> {
+  const client = new FluxyChatClient({
+    baseUrl: env.FLUXY_BASE_URL,
+    userId: "telegram-bot",
+    apiKey: env.FLUXY_API_KEY,
+  });
+
+  try {
+    const message = update.message as
+      | { chat?: { id?: number }; text?: string; from?: { first_name?: string } }
+      | undefined;
+
+    if (message?.chat?.id && message.text) {
+      const roomId = \`telegram-\${message.chat.id}\`;
+
+      // Forward to FluxyChat
+      await client.createMessage(roomId, message.text);
+
+      // Send reply back to Telegram
+      const telegramApiUrl = \`https://api.telegram.org/bot\${env.TELEGRAM_BOT_TOKEN}/sendMessage\`;
+      await fetch(telegramApiUrl, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          chat_id: message.chat.id,
+          text: \`Hi \${message.from?.first_name ?? "there"}! Message received.\`,
+        }),
+      });
+    }
+
+    return new Response("OK", { status: 200 });
+  } catch (error) {
+    console.error("Telegram update error:", error);
+    return new Response("Internal Server Error", { status: 500 });
+  }
+}
+`;
+    case "discord":
+      return `import { FluxyChatClient } from "@fluxy-chat/sdk";
+
+interface BotEnv {
+  FLUXY_BASE_URL: string;
+  FLUXY_API_KEY: string;
+  DISCORD_BOT_TOKEN: string;
+  DISCORD_PUBLIC_KEY: string;
+}
+
+export async function handleDiscordInteraction(
+  request: Request,
+  env: BotEnv,
+): Promise<Response> {
+  const body = await request.text();
+
+  const client = new FluxyChatClient({
+    baseUrl: env.FLUXY_BASE_URL,
+    userId: "discord-bot",
+    apiKey: env.FLUXY_API_KEY,
+  });
+
+  try {
+    const interaction = JSON.parse(body);
+
+    // Handle Discord ping (verification)
+    if (interaction.type === 1) {
+      return new Response(JSON.stringify({ type: 1 }), {
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+
+    // Handle application command
+    if (interaction.type === 2) {
+      const commandName = interaction.data?.name;
+
+      if (commandName === "chat") {
+        const userId = interaction.member?.user?.id ?? interaction.user?.id ?? "unknown";
+        const text = interaction.data?.options?.[0]?.value ?? "";
+
+        // Forward to FluxyChat
+        const roomId = \`discord-\${interaction.channel_id}\`;
+        await client.createMessage(roomId, String(text));
+
+        return new Response(
+          JSON.stringify({
+            type: 4,
+            data: { content: "Message forwarded to FluxyChat!" },
+          }),
+          { headers: { "Content-Type": "application/json" } },
+        );
+      }
+    }
+
+    return new Response("Unknown interaction type", { status: 400 });
+  } catch (error) {
+    console.error("Discord interaction error:", error);
+    return new Response("Internal Server Error", { status: 500 });
+  }
+}
+`;
+    case "web":
+      return `import { FluxyChatClient } from "@fluxy-chat/sdk";
+
+interface BotEnv {
+  FLUXY_BASE_URL: string;
+  FLUXY_API_KEY: string;
+}
+
+export async function handleWebChat(
+  request: Request,
+  env: BotEnv,
+): Promise<Response> {
+  const body = await request.json() as {
+    roomId?: string;
+    message?: string;
+    userId?: string;
+  };
+
+  if (!body.roomId || !body.message) {
+    return new Response(
+      JSON.stringify({ error: "Missing roomId or message" }),
+      { status: 400, headers: { "Content-Type": "application/json" } },
+    );
+  }
+
+  const client = new FluxyChatClient({
+    baseUrl: env.FLUXY_BASE_URL,
+    userId: body.userId ?? "web-user",
+    apiKey: env.FLUXY_API_KEY,
+  });
+
+  try {
+    // Send user message to FluxyChat
+    await client.createMessage(body.roomId, body.message);
+
+    // Return a simple echo response
+    return new Response(
+      JSON.stringify({
+        ok: true,
+        reply: \`You said: \${body.message}\`,
+      }),
+      { status: 200, headers: { "Content-Type": "application/json" } },
+    );
+  } catch (error) {
+    console.error("Web chat error:", error);
+    return new Response(
+      JSON.stringify({ error: "Failed to process message" }),
+      { status: 500, headers: { "Content-Type": "application/json" } },
+    );
+  }
+}
+`;
+    default:
+      return `import { FluxyChatClient } from "@fluxy-chat/sdk";
+
+interface BotEnv {
+  FLUXY_BASE_URL: string;
+  FLUXY_API_KEY: string;
+}
+
+export async function handleWebhook(
+  request: Request,
+  env: BotEnv,
+): Promise<Response> {
+  const body = await request.json() as {
+    roomId?: string;
+    message?: string;
+    userId?: string;
+  };
+
+  const client = new FluxyChatClient({
+    baseUrl: env.FLUXY_BASE_URL,
+    userId: body.userId ?? "bot",
+    apiKey: env.FLUXY_API_KEY,
+  });
+
+  try {
+    if (body.roomId && body.message) {
+      await client.createMessage(body.roomId, body.message);
+    }
+
+    return new Response(
+      JSON.stringify({ ok: true }),
+      { status: 200, headers: { "Content-Type": "application/json" } },
+    );
+  } catch (error) {
+    console.error("Webhook error:", error);
+    return new Response(
+      JSON.stringify({ error: "Internal server error" }),
+      { status: 500, headers: { "Content-Type": "application/json" } },
+    );
+  }
+}
+`;
+  }
+}
+
+// src/index.ts
+import fs2 from "fs";
+import path2 from "path";
+import { exec } from "child_process";
+import { promisify } from "util";
+var execAsync = promisify(exec);
+function parseArgs(argv) {
+  const args = {
+    yes: false,
+    skipInstall: false,
+    noGit: false,
+    help: false
+  };
+  const positional = [];
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "-h" || arg === "--help") {
+      args.help = true;
+    } else if (arg === "-y" || arg === "--yes") {
+      args.yes = true;
+    } else if (arg === "--skip-install") {
+      args.skipInstall = true;
+    } else if (arg === "--no-git") {
+      args.noGit = true;
+    } else if (arg === "--adapter" || arg === "-a") {
+      const value = argv[++i];
+      if (value && isAdapterType(value)) {
+        args.adapter = value;
+      } else {
+        console.error(`Invalid adapter: ${value}. Choose: basic, slack, telegram, discord, web`);
+        process.exit(1);
+      }
+    } else if (arg === "--pm" || arg === "--package-manager") {
+      const value = argv[++i];
+      if (value && isPackageManager(value)) {
+        args.pm = value;
+      } else {
+        console.error(`Invalid package manager: ${value}. Choose: npm, pnpm, yarn`);
+        process.exit(1);
+      }
+    } else if (arg === "--language" || arg === "-l") {
+      const value = argv[++i];
+      if (value === "typescript" || value === "javascript") {
+        args.language = value;
+      } else {
+        console.error(`Invalid language: ${value}. Choose: typescript or javascript`);
+        process.exit(1);
+      }
+    } else if (arg?.startsWith("--")) {
+      console.error(`Unknown option: ${arg}`);
+      process.exit(1);
+    } else if (arg) {
+      positional.push(arg);
+    }
+  }
+  if (positional.length > 0) {
+    args.name = positional[0];
+  }
+  return args;
+}
+var HELP_TEXT = `
+${pc.bold("create-fluxy-chat")} \u2014 Scaffold a new FluxyChat bot project
+
+${pc.bold("Usage:")}
+  npx create-fluxy-chat [project-name] [options]
+
+${pc.bold("Options:")}
+  -a, --adapter <type>       Adapter: basic, slack, telegram, discord, web
+  --pm <manager>             Package manager: npm, pnpm, yarn
+  -l, --language <lang>      Language: typescript (default) or javascript
+  -y, --yes                  Skip prompts and accept defaults
+  --skip-install             Skip dependency installation
+  --no-git                   Skip git repository initialization
+  -h, --help                 Show this help
+
+${pc.bold("Examples:")}
+  ${pc.cyan("npx create-fluxy-chat my-bot")}
+  ${pc.cyan("npx create-fluxy-chat my-bot --adapter slack")}
+  ${pc.cyan("npx create-fluxy-chat my-bot --adapter telegram --pm pnpm")}
+  ${pc.cyan("npx create-fluxy-chat my-bot -y --adapter discord")}
+`;
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  if (args.help) {
+    console.log(HELP_TEXT);
+    process.exit(0);
+  }
+  intro(pc.bgCyan(pc.black(" create-fluxy-chat ")));
+  const config = await runPrompts({
+    name: args.name,
+    adapter: args.adapter,
+    packageManager: args.pm,
+    language: args.language,
+    yes: args.yes,
+    shouldInstall: args.skipInstall ? false : void 0,
+    shouldInitGit: args.noGit ? false : void 0
+  });
+  if (!config) {
+    outro(pc.gray("Cancelled."));
+    process.exitCode = 0;
+    return;
+  }
+  const projectDir = path2.resolve(process.cwd(), config.name);
+  if (fs2.existsSync(projectDir) && fs2.readdirSync(projectDir).length > 0) {
+    outro(
+      pc.red(
+        `Directory "${config.name}" already exists and is not empty.`
+      )
+    );
+    process.exitCode = 1;
+    return;
+  }
+  const s = spinner();
+  s.start("Creating project files");
+  try {
+    fs2.mkdirSync(projectDir, { recursive: true });
+    writeJson(projectDir, "package.json", generatePackageJson(config));
+    if (config.language === "typescript") {
+      writeJson(projectDir, "tsconfig.json", generateTsConfig());
+    }
+    writeFile(projectDir, "wrangler.toml", generateWranglerToml(config));
+    writeFile(projectDir, ".dev.vars", generateDevVars());
+    writeFile(projectDir, ".env.example", generateEnvExample(config));
+    writeFile(projectDir, ".gitignore", generateGitignore());
+    const ext = config.language === "typescript" ? "ts" : "js";
+    writeFile(projectDir, `src/index.${ext}`, generateWorkerIndex(config));
+    writeFile(projectDir, `src/bot.${ext}`, generateBotHandler(config));
+    writeFile(projectDir, "README.md", generateReadme(config));
+    s.stop("Project files created.");
+  } catch (error) {
+    s.stop("Failed to create project files.");
+    throw error;
+  }
+  if (config.shouldInitGit) {
+    const gitSpinner = spinner();
+    gitSpinner.start("Initializing git repository");
+    try {
+      await execAsync("git init", { cwd: projectDir });
+      gitSpinner.stop("Git repository initialized.");
+    } catch {
+      gitSpinner.stop("Failed to initialize git repository.");
+      log.warning('Run "git init" manually in the project directory.');
+    }
+  }
+  if (config.shouldInstall) {
+    const installSpinner = spinner();
+    installSpinner.start(
+      `Installing dependencies with ${config.packageManager}`
+    );
+    try {
+      await execAsync(installCommand(config.packageManager), {
+        cwd: projectDir
+      });
+      installSpinner.stop("Dependencies installed.");
+    } catch {
+      installSpinner.stop("Failed to install dependencies.");
+      log.warning(
+        `Run "${installCommand(config.packageManager)}" manually in the project directory.`
+      );
+    }
+  }
+  note(
+    [
+      `cd ${config.name}`,
+      "cp .env.example .dev.vars",
+      `${config.packageManager === "npm" ? "npm run" : config.packageManager} dev`
+    ].join("\n"),
+    "Next steps"
+  );
+  outro(
+    `${pc.green("Done!")} Visit ${pc.cyan("https://github.com/AlessandroFare/fluxychat")} for the docs.`
+  );
+}
+main().catch((error) => {
+  const message = error instanceof Error ? error.message : String(error);
+  outro(pc.red(message));
+  process.exitCode = 1;
+});