@thinhnguyencth1204/nextcli 0.1.0

package/dist/cli.js

@@ -0,0 +1,1439 @@
+#!/usr/bin/env node
+
+// src/commands/add.ts
+import path4 from "path";
+
+// src/core/fs.ts
+import {
+  copyFile,
+  cp,
+  mkdir,
+  readdir,
+  readFile,
+  stat,
+  writeFile
+} from "fs/promises";
+import path from "path";
+async function ensureDir(targetPath) {
+  await mkdir(targetPath, { recursive: true });
+}
+async function pathExists(targetPath) {
+  try {
+    await stat(targetPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function copyDirectory(source, destination) {
+  await ensureDir(destination);
+  await cp(source, destination, { recursive: true });
+}
+async function copyDirectorySafely(source, destination) {
+  const report = {
+    copiedCount: 0,
+    skippedConflicts: []
+  };
+  async function walk(currentSource, currentDestination) {
+    await ensureDir(currentDestination);
+    const entries = await readdir(currentSource, { withFileTypes: true });
+    for (const entry of entries) {
+      const sourcePath = path.join(currentSource, entry.name);
+      const destinationPath = path.join(currentDestination, entry.name);
+      if (entry.isDirectory()) {
+        await walk(sourcePath, destinationPath);
+        continue;
+      }
+      if (!entry.isFile()) {
+        continue;
+      }
+      if (await pathExists(destinationPath)) {
+        report.skippedConflicts.push(path.relative(destination, destinationPath));
+        continue;
+      }
+      await ensureDir(path.dirname(destinationPath));
+      await copyFile(sourcePath, destinationPath);
+      report.copiedCount += 1;
+    }
+  }
+  await walk(source, destination);
+  return report;
+}
+var textExtensions = /* @__PURE__ */ new Set([
+  ".env",
+  ".example",
+  ".development",
+  ".json",
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  ".md",
+  ".txt",
+  ".css",
+  ".yml",
+  ".yaml",
+  ".prisma"
+]);
+function isTextFile(filePath) {
+  const base = path.basename(filePath);
+  if (base === ".env" || base === ".env.example" || base === ".env.development") {
+    return true;
+  }
+  const ext = path.extname(filePath);
+  return textExtensions.has(ext);
+}
+async function replaceTokensInDirectory(directoryPath, replacements) {
+  const entries = await readdir(directoryPath, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path.join(directoryPath, entry.name);
+    if (entry.isDirectory()) {
+      await replaceTokensInDirectory(fullPath, replacements);
+      continue;
+    }
+    if (!entry.isFile() || !isTextFile(fullPath)) {
+      continue;
+    }
+    const content = await readFile(fullPath, "utf8");
+    let nextContent = content;
+    for (const [token, value] of Object.entries(replacements)) {
+      nextContent = nextContent.replaceAll(token, value);
+    }
+    if (nextContent !== content) {
+      await writeFile(fullPath, nextContent, "utf8");
+    }
+  }
+}
+async function mergeEnvFile(envFilePath, entries) {
+  const envExists = await pathExists(envFilePath);
+  const currentContent = envExists ? await readFile(envFilePath, "utf8") : "";
+  const lines = currentContent ? currentContent.split("\n") : [];
+  const existingKeys = /* @__PURE__ */ new Set();
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) {
+      continue;
+    }
+    const [key] = trimmed.split("=");
+    if (key) {
+      existingKeys.add(key.trim());
+    }
+  }
+  const additions = [];
+  for (const [key, value] of Object.entries(entries)) {
+    if (!existingKeys.has(key)) {
+      additions.push(`${key}=${formatEnvValue(value)}`);
+    }
+  }
+  if (additions.length === 0) {
+    return;
+  }
+  const separator = currentContent.endsWith("\n") || currentContent.length === 0 ? "" : "\n";
+  const nextContent = `${currentContent}${separator}${additions.join("\n")}
+`;
+  await writeFile(envFilePath, nextContent, "utf8");
+}
+function formatEnvValue(value) {
+  if (value === "") {
+    return '""';
+  }
+  if (/^[a-zA-Z0-9._:/-]+$/.test(value)) {
+    return value;
+  }
+  return JSON.stringify(value);
+}
+async function addDependencies(packageJsonPath, dependencies) {
+  const packageRaw = await readFile(packageJsonPath, "utf8");
+  const packageJson = JSON.parse(packageRaw);
+  const current = packageJson.dependencies ?? {};
+  packageJson.dependencies = {
+    ...current,
+    ...dependencies
+  };
+  await writeFile(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}
+`, "utf8");
+}
+
+// src/commands/add.ts
+import { readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
+
+// src/core/templates.ts
+import path2 from "path";
+import { fileURLToPath } from "url";
+var currentDir = path2.dirname(fileURLToPath(import.meta.url));
+var rootDir = path2.resolve(currentDir, "../");
+var templatePaths = {
+  base: path2.join(rootDir, "templates/next-base"),
+  chat: path2.join(rootDir, "templates/features/chat"),
+  supabase: path2.join(rootDir, "templates/features/supabase"),
+  supabaseRealtime: path2.join(rootDir, "templates/features/supabase-realtime"),
+  seo: path2.join(rootDir, "templates/features/seo")
+};
+
+// src/core/modules.ts
+var optionalModules = [
+  {
+    id: "chat",
+    label: "Chat module",
+    description: "Adds chat API route, hooks/components, and chat Prisma models",
+    templatePath: templatePaths.chat,
+    env: {
+      NEXT_PUBLIC_ENABLE_CHAT: "true"
+    }
+  },
+  {
+    id: "supabase",
+    label: "Supabase",
+    description: "Adds Supabase client and storage upload helpers",
+    templatePath: templatePaths.supabase,
+    env: {
+      NEXT_PUBLIC_SUPABASE_URL: "",
+      NEXT_PUBLIC_SUPABASE_ANON_KEY: "",
+      NEXT_PUBLIC_SUPABASE_STORAGE_BUCKET: "public"
+    },
+    dependencies: {
+      "@supabase/supabase-js": "^2.44.2"
+    }
+  },
+  {
+    id: "supabase-realtime",
+    label: "Supabase Realtime",
+    description: "Adds Realtime channel helper and hooks",
+    templatePath: templatePaths.supabaseRealtime,
+    env: {
+      NEXT_PUBLIC_SUPABASE_URL: "",
+      NEXT_PUBLIC_SUPABASE_ANON_KEY: ""
+    },
+    dependencies: {
+      "@supabase/supabase-js": "^2.44.2"
+    }
+  },
+  {
+    id: "seo",
+    label: "SEO pack",
+    description: "Adds robots/sitemap and JsonLd helper files",
+    templatePath: templatePaths.seo,
+    env: {}
+  }
+];
+function getModuleById(moduleId) {
+  const module = optionalModules.find((item) => item.id === moduleId);
+  if (!module) {
+    throw new Error(`Unknown optional module: ${moduleId}`);
+  }
+  return module;
+}
+
+// src/core/prompts.ts
+import {
+  cancel,
+  confirm,
+  intro,
+  isCancel,
+  multiselect,
+  outro,
+  select
+} from "@clack/prompts";
+
+// src/core/theme.ts
+var reset = "\x1B[0m";
+function paint(code, text) {
+  return `${code}${text}${reset}`;
+}
+var theme = {
+  cyan: (text) => paint("\x1B[36m", text),
+  green: (text) => paint("\x1B[32m", text),
+  yellow: (text) => paint("\x1B[33m", text),
+  red: (text) => paint("\x1B[31m", text),
+  blue: (text) => paint("\x1B[34m", text),
+  magenta: (text) => paint("\x1B[35m", text),
+  dim: (text) => paint("\x1B[2m", text),
+  bold: (text) => paint("\x1B[1m", text)
+};
+var bannerGradient = [
+  "\x1B[38;5;51m",
+  "\x1B[38;5;45m",
+  "\x1B[38;5;39m",
+  "\x1B[38;5;33m",
+  "\x1B[38;5;27m"
+];
+var log = {
+  info(message) {
+    console.log(`${theme.cyan("\u2139")} ${message}`);
+  },
+  success(message) {
+    console.log(`${theme.green("\u2714")} ${message}`);
+  },
+  warn(message) {
+    console.log(`${theme.yellow("\u26A0")} ${message}`);
+  },
+  error(message) {
+    console.error(`${theme.red("\u2716")} ${message}`);
+  },
+  step(message) {
+    console.log(`${theme.blue("\u2192")} ${message}`);
+  },
+  detail(label, value) {
+    console.log(`${theme.dim(`${label}:`)} ${theme.cyan(value)}`);
+  },
+  command(command) {
+    console.log(`${theme.dim("  ")}${theme.magenta(command)}`);
+  }
+};
+
+// src/core/prompts.ts
+function handleCancelled(value) {
+  if (!isCancel(value)) {
+    return;
+  }
+  cancel(theme.red("Operation cancelled."));
+  process.exit(0);
+}
+function startPrompt(title) {
+  intro(theme.cyan(theme.bold(title)));
+}
+function finishPrompt(message) {
+  outro(theme.green(message));
+}
+async function askSelect(message, options, initialValue) {
+  const value = await select({
+    message,
+    options,
+    initialValue
+  });
+  handleCancelled(value);
+  return value;
+}
+async function askMultiSelect(message, options, initialValues = []) {
+  const values = await multiselect({
+    message,
+    options,
+    initialValues,
+    required: false
+  });
+  handleCancelled(values);
+  return values;
+}
+async function askConfirm(message, initialValue = false) {
+  const value = await confirm({
+    message,
+    initialValue
+  });
+  handleCancelled(value);
+  return Boolean(value);
+}
+
+// src/core/auth-bootstrap.ts
+import { spawn } from "child_process";
+async function runCommand(command, args, cwd, silent = true) {
+  return new Promise((resolve) => {
+    const chunks = [];
+    const child = spawn(command, args, {
+      cwd,
+      shell: process.platform === "win32",
+      stdio: silent ? "pipe" : "inherit"
+    });
+    if (silent) {
+      child.stdout?.on("data", (chunk) => chunks.push(String(chunk)));
+      child.stderr?.on("data", (chunk) => chunks.push(String(chunk)));
+    }
+    child.on("error", () => {
+      resolve({ ok: false, output: chunks.join("") });
+    });
+    child.on("close", (code) => {
+      resolve({ ok: code === 0, output: chunks.join("") });
+    });
+  });
+}
+async function ensureBetterAuthGenerate(cwd, options = {}) {
+  const localCheck = await runCommand("npx", ["--no-install", "auth", "--help"], cwd);
+  const hasCli = localCheck.ok;
+  let canInstall = hasCli;
+  if (!hasCli) {
+    if (options.nonInteractive) {
+      log.warn("Better Auth CLI not detected. Skipping schema generation in non-interactive mode.");
+      return;
+    }
+    const approved = await askConfirm(
+      "Better Auth CLI is not installed. Install/use npx auth@latest and run schema generation now?",
+      true
+    );
+    if (!approved) {
+      log.warn("Skipped Better Auth schema generation.");
+      log.command("npx auth@latest generate --config src/lib/auth.ts");
+      return;
+    }
+    canInstall = true;
+  }
+  if (!canInstall) {
+    return;
+  }
+  const generateArgs = hasCli ? ["auth", "generate", "--config", "src/lib/auth.ts"] : ["auth@latest", "generate", "--config", "src/lib/auth.ts"];
+  const result = await runCommand("npx", generateArgs, cwd, false);
+  if (!result.ok) {
+    log.error("Better Auth generate command failed. Run manually:");
+    log.command("npx auth@latest generate --config src/lib/auth.ts");
+  }
+}
+
+// src/core/chat-schema.ts
+import path3 from "path";
+import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+var chatSchemaBlock = `
+
+// ------------------------------------------------------------
+// Optional Chatbox Models (Provider-Agnostic)
+// Review carefully before running migrations on production.
+// ------------------------------------------------------------
+model ChatConversation {
+  id           String            @id @default(cuid())
+  title        String?
+  createdAt    DateTime          @default(now())
+  updatedAt    DateTime          @updatedAt
+  participants ChatParticipant[]
+  messages     ChatMessage[]
+}
+
+model ChatParticipant {
+  id             String              @id @default(cuid())
+  conversationId String
+  userId         String
+  role           ChatParticipantRole @default(MEMBER)
+  createdAt      DateTime            @default(now())
+  conversation   ChatConversation    @relation(fields: [conversationId], references: [id], onDelete: Cascade)
+  user           User                @relation(fields: [userId], references: [id], onDelete: Cascade)
+
+  @@unique([conversationId, userId])
+  @@index([userId])
+}
+
+model ChatMessage {
+  id             String           @id @default(cuid())
+  conversationId String
+  senderId       String
+  content        String
+  kind           ChatMessageKind  @default(TEXT)
+  createdAt      DateTime         @default(now())
+  updatedAt      DateTime         @updatedAt
+  conversation   ChatConversation @relation(fields: [conversationId], references: [id], onDelete: Cascade)
+  sender         User             @relation(fields: [senderId], references: [id], onDelete: Cascade)
+
+  @@index([conversationId, createdAt])
+}
+
+enum ChatParticipantRole {
+  OWNER
+  MEMBER
+}
+
+enum ChatMessageKind {
+  TEXT
+  SYSTEM
+}
+`;
+function ensureUserRelations(schema) {
+  if (schema.includes("chatParticipants") && schema.includes("chatMessages")) {
+    return schema;
+  }
+  const userBlockRegex = /model User \{[\s\S]*?\n\}/m;
+  const userBlock = schema.match(userBlockRegex)?.[0];
+  if (!userBlock) {
+    return schema;
+  }
+  const relationLines = [];
+  if (!userBlock.includes("chatParticipants")) {
+    relationLines.push("  chatParticipants ChatParticipant[]");
+  }
+  if (!userBlock.includes("chatMessages")) {
+    relationLines.push("  chatMessages     ChatMessage[]");
+  }
+  if (relationLines.length === 0) {
+    return schema;
+  }
+  const nextUserBlock = userBlock.replace(/\n\}$/, `
+${relationLines.join("\n")}
+}`);
+  return schema.replace(userBlock, nextUserBlock);
+}
+async function ensureChatSchemaInProject(projectRoot) {
+  const schemaPath = path3.join(projectRoot, "prisma", "schema.prisma");
+  if (!await pathExists(schemaPath)) {
+    return "skipped";
+  }
+  let schema = await readFile2(schemaPath, "utf8");
+  schema = ensureUserRelations(schema);
+  if (schema.includes("model ChatConversation")) {
+    await writeFile2(schemaPath, schema, "utf8");
+    return "exists";
+  }
+  const nextSchema = `${schema.trimEnd()}${chatSchemaBlock}
+`;
+  await writeFile2(schemaPath, nextSchema, "utf8");
+  return "added";
+}
+
+// src/commands/add.ts
+function toKebabCase(input) {
+  return input.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function toPascalCase(slug) {
+  return slug.split("-").filter(Boolean).map((part) => `${part.charAt(0).toUpperCase()}${part.slice(1)}`).join("");
+}
+function toCamelCase(input) {
+  return `${input.charAt(0).toLowerCase()}${input.slice(1)}`;
+}
+function singularizeWord(word) {
+  if (word.endsWith("ies") && word.length > 3) {
+    return `${word.slice(0, -3)}y`;
+  }
+  if (/(xes|ches|shes|sses|zes)$/.test(word)) {
+    return word.slice(0, -2);
+  }
+  if (word.endsWith("s") && !/(ss|us|is)$/.test(word)) {
+    return word.slice(0, -1);
+  }
+  return word;
+}
+function buildFeatureServicesContent(modelPascal, modelDelegate) {
+  return `import prisma from "@/lib/prisma";
+
+export async function list${modelPascal}s() {
+  return prisma.${modelDelegate}.findMany({
+    orderBy: {
+      createdAt: "desc",
+    },
+  });
+}
+
+export async function get${modelPascal}ById(id: string) {
+  return prisma.${modelDelegate}.findUnique({
+    where: { id },
+  });
+}
+
+export async function create${modelPascal}(data: {
+  name: string;
+  description?: string;
+}) {
+  return prisma.${modelDelegate}.create({
+    data,
+  });
+}
+
+export async function update${modelPascal}(
+  id: string,
+  data: {
+    name?: string;
+    description?: string;
+  },
+) {
+  return prisma.${modelDelegate}.update({
+    where: { id },
+    data,
+  });
+}
+
+export async function delete${modelPascal}(id: string) {
+  return prisma.${modelDelegate}.delete({
+    where: { id },
+  });
+}
+`;
+}
+function buildFeatureValidationContent(modelPascal) {
+  return `import { z } from "zod";
+
+export const create${modelPascal}Schema = z.object({
+  name: z.string().min(2),
+  description: z.string().max(500).optional(),
+});
+
+export const update${modelPascal}Schema = create${modelPascal}Schema.partial();
+
+export const ${toCamelCase(modelPascal)}IdSchema = z.object({
+  id: z.string().min(1),
+});
+
+export type Create${modelPascal}Input = z.infer<typeof create${modelPascal}Schema>;
+export type Update${modelPascal}Input = z.infer<typeof update${modelPascal}Schema>;
+`;
+}
+function buildFeatureHooksContent(featureSlug, modelPascal) {
+  return `import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import { api } from "@/lib/axios-instance";
+import type { ApiSuccess } from "@/types";
+import type { Create${modelPascal}Input, Update${modelPascal}Input } from "../validations";
+
+type ${modelPascal}Item = {
+  id: string;
+  name: string;
+  description?: string | null;
+  createdAt: string;
+  updatedAt: string;
+};
+
+export function use${modelPascal}s() {
+  return useQuery({
+    queryKey: ["${featureSlug}", "items"],
+    queryFn: async () => {
+      const { data } = await api.get("/api/v1/${featureSlug}");
+      return (data as ApiSuccess<{ items: ${modelPascal}Item[] }>).data.items;
+    },
+  });
+}
+
+export function useCreate${modelPascal}() {
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: async (payload: Create${modelPascal}Input) => {
+      const { data } = await api.post("/api/v1/${featureSlug}", payload);
+      return (data as ApiSuccess<${modelPascal}Item>).data;
+    },
+    onSuccess: async () => {
+      await queryClient.invalidateQueries({ queryKey: ["${featureSlug}", "items"] });
+    },
+  });
+}
+
+export function useUpdate${modelPascal}() {
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: async (payload: { id: string; data: Update${modelPascal}Input }) => {
+      const { data } = await api.put("/api/v1/${featureSlug}/" + payload.id, payload.data);
+      return (data as ApiSuccess<${modelPascal}Item>).data;
+    },
+    onSuccess: async () => {
+      await queryClient.invalidateQueries({ queryKey: ["${featureSlug}", "items"] });
+    },
+  });
+}
+
+export function useDelete${modelPascal}() {
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: async (id: string) => {
+      const { data } = await api.delete("/api/v1/${featureSlug}/" + id);
+      return (data as ApiSuccess<{ deleted: boolean }>).data;
+    },
+    onSuccess: async () => {
+      await queryClient.invalidateQueries({ queryKey: ["${featureSlug}", "items"] });
+    },
+  });
+}
+`;
+}
+function buildCollectionRouteContent(featureSlug, modelPascal) {
+  return `import { fail, ok } from "@/lib/api-response";
+import {
+  create${modelPascal},
+  list${modelPascal}s,
+} from "@/features/${featureSlug}/services";
+import { create${modelPascal}Schema } from "@/features/${featureSlug}/validations";
+
+export async function GET() {
+  try {
+    const items = await list${modelPascal}s();
+    return ok({ items });
+  } catch {
+    return fail("INTERNAL_ERROR", "Failed to load ${featureSlug}.", { status: 500 });
+  }
+}
+
+export async function POST(request: Request) {
+  const payload = await request.json().catch(() => null);
+  const parsed = create${modelPascal}Schema.safeParse(payload);
+  if (!parsed.success) {
+    return fail("VALIDATION_ERROR", "Invalid payload.", {
+      status: 400,
+      details: parsed.error.flatten(),
+    });
+  }
+
+  try {
+    const created = await create${modelPascal}(parsed.data);
+    return ok(created, { status: 201 });
+  } catch {
+    return fail("INTERNAL_ERROR", "Failed to create ${featureSlug}.", { status: 500 });
+  }
+}
+`;
+}
+function buildItemRouteContent(featureSlug, modelPascal) {
+  return `import { fail, ok } from "@/lib/api-response";
+import {
+  delete${modelPascal},
+  get${modelPascal}ById,
+  update${modelPascal},
+} from "@/features/${featureSlug}/services";
+import { update${modelPascal}Schema } from "@/features/${featureSlug}/validations";
+
+export async function GET(
+  _request: Request,
+  context: { params: Promise<{ id: string }> },
+) {
+  const { id } = await context.params;
+  const item = await get${modelPascal}ById(id);
+
+  if (!item) {
+    return fail("NOT_FOUND", "${modelPascal} not found.", { status: 404 });
+  }
+
+  return ok(item);
+}
+
+export async function PUT(
+  request: Request,
+  context: { params: Promise<{ id: string }> },
+) {
+  const { id } = await context.params;
+  const payload = await request.json().catch(() => null);
+  const parsed = update${modelPascal}Schema.safeParse(payload);
+  if (!parsed.success) {
+    return fail("VALIDATION_ERROR", "Invalid payload.", {
+      status: 400,
+      details: parsed.error.flatten(),
+    });
+  }
+
+  try {
+    const updated = await update${modelPascal}(id, parsed.data);
+    return ok(updated);
+  } catch {
+    return fail("INTERNAL_ERROR", "Failed to update ${featureSlug}.", { status: 500 });
+  }
+}
+
+export async function DELETE(
+  _request: Request,
+  context: { params: Promise<{ id: string }> },
+) {
+  const { id } = await context.params;
+  try {
+    await delete${modelPascal}(id);
+    return ok({ deleted: true });
+  } catch {
+    return fail("INTERNAL_ERROR", "Failed to delete ${featureSlug}.", { status: 500 });
+  }
+}
+`;
+}
+async function appendFeatureModelToPrismaSchema(cwd, modelPascal) {
+  const schemaPath = path4.join(cwd, "prisma", "schema.prisma");
+  if (!await pathExists(schemaPath)) {
+    return "skipped";
+  }
+  const schemaContent = await readFile3(schemaPath, "utf8");
+  const modelRegex = new RegExp(`\\bmodel\\s+${modelPascal}\\b`);
+  if (modelRegex.test(schemaContent)) {
+    return "exists";
+  }
+  const modelBlock = `
+
+// Example feature model generated by NexTCLI.
+// Review fields/indexes before running migration on production.
+model ${modelPascal} {
+  id          String   @id @default(cuid())
+  name        String
+  description String?
+  createdAt   DateTime @default(now())
+  updatedAt   DateTime @updatedAt
+}
+`;
+  await writeFile3(schemaPath, `${schemaContent.trimEnd()}${modelBlock}
+`, "utf8");
+  return "added";
+}
+var authProviderStartMarker = "// AUTO_GENERATED_AUTH_PROVIDERS_START";
+var authProviderEndMarker = "// AUTO_GENERATED_AUTH_PROVIDERS_END";
+function buildProviderSnippet(providers) {
+  const lines = [];
+  if (providers.includes("google")) {
+    lines.push(
+      "  google: {",
+      '    clientId: process.env.GOOGLE_CLIENT_ID ?? "",',
+      '    clientSecret: process.env.GOOGLE_CLIENT_SECRET ?? "",',
+      "  },"
+    );
+  }
+  if (providers.includes("facebook")) {
+    lines.push(
+      "  facebook: {",
+      '    clientId: process.env.FACEBOOK_CLIENT_ID ?? "",',
+      '    clientSecret: process.env.FACEBOOK_CLIENT_SECRET ?? "",',
+      "  },"
+    );
+  }
+  return lines.join("\n");
+}
+function readConfiguredProviders(content) {
+  const providers = [];
+  if (/\bgoogle\s*:/.test(content)) {
+    providers.push("google");
+  }
+  if (/\bfacebook\s*:/.test(content)) {
+    providers.push("facebook");
+  }
+  return providers;
+}
+function patchAuthProviders(content, providers) {
+  const snippet = buildProviderSnippet(providers);
+  const regex = new RegExp(
+    `(${authProviderStartMarker})([\\s\\S]*?)(${authProviderEndMarker})`,
+    "m"
+  );
+  return content.replace(regex, `$1
+${snippet ? `${snippet}
+` : ""}  $3`);
+}
+function normalizeModuleSelection(moduleIds) {
+  const selected = [...new Set(moduleIds)];
+  const autoAdded = [];
+  if (selected.includes("chat") && !selected.includes("supabase-realtime")) {
+    selected.unshift("supabase-realtime");
+    autoAdded.push("supabase-realtime");
+  }
+  return {
+    selectedModules: [...new Set(selected)],
+    autoAddedModules: autoAdded
+  };
+}
+async function upsertEnvValue(envFilePath, key, value) {
+  if (!await pathExists(envFilePath)) {
+    return;
+  }
+  const content = await readFile3(envFilePath, "utf8");
+  const entry = `${key}=${value}`;
+  const pattern = new RegExp(`^${key}=.*$`, "m");
+  if (pattern.test(content)) {
+    const next = content.replace(pattern, entry);
+    if (next !== content) {
+      await writeFile3(envFilePath, next, "utf8");
+    }
+    return;
+  }
+  const separator = content.endsWith("\n") || content.length === 0 ? "" : "\n";
+  await writeFile3(envFilePath, `${content}${separator}${entry}
+`, "utf8");
+}
+function registerAddCommand(program2) {
+  const add = program2.command("add").description("Add modules to an existing app");
+  add.command("feature").description("Scaffold a feature folder under src/features").argument("<feature-name>", "Feature name").action(async (featureName) => {
+    const featureSlug = toKebabCase(featureName);
+    if (!featureSlug) {
+      log.error("Invalid feature name.");
+      process.exitCode = 1;
+      return;
+    }
+    const cwd = process.cwd();
+    const srcPath = path4.join(cwd, "src");
+    if (!await pathExists(srcPath)) {
+      log.error("Run this command from your generated Next.js project root (missing ./src).");
+      process.exitCode = 1;
+      return;
+    }
+    const featurePascal = toPascalCase(featureSlug);
+    const modelPascal = singularizeWord(featurePascal);
+    const modelDelegate = toCamelCase(modelPascal);
+    const featureRoot = path4.join(cwd, "src/features", featureSlug);
+    if (await pathExists(featureRoot)) {
+      log.error(`Feature already exists: ${featureRoot}`);
+      process.exitCode = 1;
+      return;
+    }
+    await ensureDir(path4.join(featureRoot, "api"));
+    await ensureDir(path4.join(featureRoot, "components"));
+    await writeFile3(
+      path4.join(featureRoot, "services.ts"),
+      buildFeatureServicesContent(modelPascal, modelDelegate),
+      "utf8"
+    );
+    await writeFile3(
+      path4.join(featureRoot, "validations.ts"),
+      buildFeatureValidationContent(modelPascal),
+      "utf8"
+    );
+    await writeFile3(
+      path4.join(featureRoot, "api", `use-${featureSlug}.ts`),
+      buildFeatureHooksContent(featureSlug, modelPascal),
+      "utf8"
+    );
+    const routeFilePath = path4.join(cwd, "src/app/api/v1", featureSlug, "route.ts");
+    await ensureDir(path4.dirname(routeFilePath));
+    await writeFile3(routeFilePath, buildCollectionRouteContent(featureSlug, modelPascal), "utf8");
+    const idRoutePath = path4.join(cwd, "src/app/api/v1", featureSlug, "[id]", "route.ts");
+    await ensureDir(path4.dirname(idRoutePath));
+    await writeFile3(idRoutePath, buildItemRouteContent(featureSlug, modelPascal), "utf8");
+    const schemaStatus = await appendFeatureModelToPrismaSchema(cwd, modelPascal);
+    const schemaMessage = schemaStatus === "added" ? `Model ${modelPascal} appended to prisma/schema.prisma` : schemaStatus === "exists" ? `Model ${modelPascal} already exists in prisma/schema.prisma` : "Skipped prisma/schema.prisma update (file not found)";
+    log.success(`Feature generated with CRUD: src/features/${featureSlug}`);
+    log.info(schemaMessage);
+    log.warn("No migration was executed. Run your migration command manually when ready.");
+  });
+  add.command("module").description("Add optional modules using interactive multi-select").option("--module <module...>", "Preselect module ids").option("--yes", "Skip prompts").action(async (options) => {
+    const cwd = process.cwd();
+    const hasSrc = await pathExists(path4.join(cwd, "src"));
+    const hasPackageJson = await pathExists(path4.join(cwd, "package.json"));
+    if (!hasSrc || !hasPackageJson) {
+      log.error("Run this command from your generated Next.js project root.");
+      process.exitCode = 1;
+      return;
+    }
+    const validIds = new Set(optionalModules.map((module) => module.id));
+    const requestedIds = options.module ? options.module.flatMap((value) => value.split(",")).map((value) => value.trim()).filter(Boolean) : [];
+    for (const moduleId of requestedIds) {
+      if (!validIds.has(moduleId)) {
+        log.error(`Unknown module: ${moduleId}`);
+        process.exitCode = 1;
+        return;
+      }
+    }
+    startPrompt("NexTCLI optional modules");
+    const rawModules = requestedIds.length > 0 ? [...new Set(requestedIds)] : options.yes ? [] : await askMultiSelect(
+      "Select modules to add:",
+      optionalModules.map((module) => ({
+        value: module.id,
+        label: module.label,
+        hint: module.description
+      })),
+      []
+    );
+    const { selectedModules, autoAddedModules } = normalizeModuleSelection(rawModules);
+    if (selectedModules.length === 0) {
+      finishPrompt("No modules selected.");
+      return;
+    }
+    const skippedConflictsByModule = [];
+    let copiedFileCount = 0;
+    for (const moduleId of selectedModules) {
+      const module = getModuleById(moduleId);
+      const copyReport = await copyDirectorySafely(module.templatePath, cwd);
+      copiedFileCount += copyReport.copiedCount;
+      if (copyReport.skippedConflicts.length > 0) {
+        skippedConflictsByModule.push({
+          moduleId,
+          paths: copyReport.skippedConflicts
+        });
+      }
+    }
+    let chatSchemaStatus;
+    if (selectedModules.includes("chat")) {
+      chatSchemaStatus = await ensureChatSchemaInProject(cwd);
+    }
+    const envEntries = selectedModules.reduce((acc, moduleId) => {
+      const module = getModuleById(moduleId);
+      return {
+        ...acc,
+        ...module.env
+      };
+    }, {});
+    if (Object.keys(envEntries).length > 0) {
+      const envTargets = [
+        ".env",
+        ".env.example",
+        ".env.development"
+      ];
+      for (const envFile of envTargets) {
+        const envPath = path4.join(cwd, envFile);
+        if (await pathExists(envPath)) {
+          await mergeEnvFile(envPath, envEntries);
+        }
+      }
+    }
+    if (selectedModules.includes("chat")) {
+      const envTargets = [
+        ".env",
+        ".env.example",
+        ".env.development"
+      ];
+      for (const envFile of envTargets) {
+        await upsertEnvValue(path4.join(cwd, envFile), "NEXT_PUBLIC_ENABLE_CHAT", "true");
+      }
+    }
+    const dependencyEntries = selectedModules.reduce((acc, moduleId) => {
+      const module = getModuleById(moduleId);
+      return {
+        ...acc,
+        ...module.dependencies ?? {}
+      };
+    }, {});
+    if (Object.keys(dependencyEntries).length > 0) {
+      await addDependencies(path4.join(cwd, "package.json"), dependencyEntries);
+    }
+    finishPrompt(`Added modules: ${selectedModules.join(", ")}`);
+    log.detail("Copied files", String(copiedFileCount));
+    if (autoAddedModules.length > 0) {
+      log.detail("Auto-added", autoAddedModules.join(", "));
+    }
+    if (skippedConflictsByModule.length > 0) {
+      const totalSkipped = skippedConflictsByModule.reduce(
+        (total, item) => total + item.paths.length,
+        0
+      );
+      log.warn(
+        `Skipped ${totalSkipped} existing file(s). Existing project files were kept unchanged.`
+      );
+      for (const conflict of skippedConflictsByModule) {
+        const preview = conflict.paths.slice(0, 3).join(", ");
+        const suffix = conflict.paths.length > 3 ? ", ..." : "";
+        log.detail(`Skipped (${conflict.moduleId})`, `${preview}${suffix}`);
+      }
+    }
+    if (chatSchemaStatus === "added") {
+      log.info("Optional chat schema block was appended to prisma/schema.prisma.");
+    }
+    log.step("Next: run your package manager install to apply new dependencies.");
+  });
+  add.command("auth-provider").description("Add social auth providers to existing Better Auth setup").option("--provider <provider...>", "Preselect providers: google,facebook").option("--yes", "Skip prompts").action(async (options) => {
+    const cwd = process.cwd();
+    const authFilePath = path4.join(cwd, "src/lib/auth.ts");
+    const hasSrc = await pathExists(path4.join(cwd, "src"));
+    const hasPackageJson = await pathExists(path4.join(cwd, "package.json"));
+    const hasAuthFile = await pathExists(authFilePath);
+    if (!hasSrc || !hasPackageJson || !hasAuthFile) {
+      log.error("Run this command from a generated Next.js project with src/lib/auth.ts.");
+      process.exitCode = 1;
+      return;
+    }
+    const requestedProviders = options.provider ? options.provider.flatMap((value) => value.split(",")).map((value) => value.trim().toLowerCase()).filter(Boolean) : [];
+    const allowed = /* @__PURE__ */ new Set(["google", "facebook"]);
+    for (const provider of requestedProviders) {
+      if (!allowed.has(provider)) {
+        log.error(`Unknown provider: ${provider}`);
+        process.exitCode = 1;
+        return;
+      }
+    }
+    startPrompt("NexTCLI auth provider setup");
+    const selectedProviders = requestedProviders.length > 0 ? [...new Set(requestedProviders)] : options.yes ? [] : await askMultiSelect(
+      "Select social providers to enable:",
+      [
+        { value: "google", label: "Google", hint: "Google OAuth login" },
+        { value: "facebook", label: "Facebook", hint: "Facebook OAuth login" }
+      ],
+      []
+    );
+    if (selectedProviders.length === 0) {
+      finishPrompt("No auth providers selected.");
+      return;
+    }
+    const authContent = await readFile3(authFilePath, "utf8");
+    const existingProviders = readConfiguredProviders(authContent);
+    const mergedProviders = [.../* @__PURE__ */ new Set([...existingProviders, ...selectedProviders])];
+    const nextAuthContent = patchAuthProviders(authContent, mergedProviders);
+    await writeFile3(authFilePath, nextAuthContent, "utf8");
+    const envEntries = {};
+    if (mergedProviders.includes("google")) {
+      envEntries.GOOGLE_CLIENT_ID = "";
+      envEntries.GOOGLE_CLIENT_SECRET = "";
+    }
+    if (mergedProviders.includes("facebook")) {
+      envEntries.FACEBOOK_CLIENT_ID = "";
+      envEntries.FACEBOOK_CLIENT_SECRET = "";
+    }
+    const envTargets = [
+      ".env",
+      ".env.example",
+      ".env.development"
+    ];
+    for (const envFile of envTargets) {
+      const envPath = path4.join(cwd, envFile);
+      if (await pathExists(envPath)) {
+        await mergeEnvFile(envPath, envEntries);
+      }
+    }
+    finishPrompt(`Enabled providers: ${mergedProviders.join(", ")}`);
+    await ensureBetterAuthGenerate(cwd, { nonInteractive: Boolean(options.yes) });
+    log.step("Next: set provider secrets in .env and restart dev server.");
+  });
+}
+
+// src/commands/create.ts
+import { spawn as spawn2 } from "child_process";
+import { randomBytes } from "crypto";
+import path5 from "path";
+async function runInstall(packageManager, cwd) {
+  const installArgsMap = {
+    npm: ["install"],
+    pnpm: ["install"],
+    yarn: ["install"],
+    bun: ["install"]
+  };
+  await new Promise((resolve, reject) => {
+    const child = spawn2(packageManager, installArgsMap[packageManager], {
+      cwd,
+      stdio: "inherit",
+      shell: process.platform === "win32"
+    });
+    child.on("error", reject);
+    child.on("close", (code) => {
+      if (code === 0) {
+        resolve();
+        return;
+      }
+      reject(new Error(`Dependency installation failed with code ${code ?? "unknown"}`));
+    });
+  });
+}
+function parseModuleIds(moduleValues) {
+  if (!moduleValues || moduleValues.length === 0) {
+    return [];
+  }
+  const flattened = moduleValues.flatMap((value) => value.split(","));
+  const normalized = flattened.map((value) => value.trim()).filter(Boolean);
+  const validIds = new Set(optionalModules.map((module) => module.id));
+  for (const moduleId of normalized) {
+    if (!validIds.has(moduleId)) {
+      throw new Error(`Unknown module: ${moduleId}`);
+    }
+  }
+  return [...new Set(normalized)];
+}
+function toProjectSlug(input) {
+  return input.trim().toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function normalizeModuleSelection2(moduleIds) {
+  const selected = [...new Set(moduleIds)];
+  const autoAdded = [];
+  if (selected.includes("chat") && !selected.includes("supabase-realtime")) {
+    selected.unshift("supabase-realtime");
+    autoAdded.push("supabase-realtime");
+  }
+  return {
+    selectedModules: [...new Set(selected)],
+    autoAddedModules: autoAdded
+  };
+}
+function registerCreateCommand(program2) {
+  program2.command("create").description("Create a new outsource-ready Next.js app").argument("<project-name>", "Target project name").option("--package-manager <manager>", "Package manager: npm|pnpm|yarn|bun").option("--module <module...>", "Preselect modules (chat,supabase,supabase-realtime,seo)").option("--install", "Install dependencies after generation").option("--no-install", "Skip dependency installation").option("--yes", "Skip prompts and use defaults").action(async (projectName, options) => {
+    startPrompt("NexTCLI project creation");
+    const packageManager = options.packageManager ?? (options.yes ? "npm" : await askSelect(
+      "Which package manager do you want to use?",
+      [
+        { value: "npm", label: "npm", hint: "Default and stable" },
+        { value: "pnpm", label: "pnpm", hint: "Fast and disk-efficient" },
+        { value: "yarn", label: "yarn", hint: "Classic workspace choice" },
+        { value: "bun", label: "bun", hint: "Fast runtime and package manager" }
+      ],
+      "npm"
+    ));
+    const allowedManagers = /* @__PURE__ */ new Set(["npm", "pnpm", "yarn", "bun"]);
+    if (!allowedManagers.has(packageManager)) {
+      log.error("Invalid --package-manager value. Use npm, pnpm, yarn, or bun.");
+      process.exitCode = 1;
+      return;
+    }
+    const targetPath = path5.resolve(process.cwd(), projectName);
+    if (await pathExists(targetPath)) {
+      log.error(`Target directory already exists: ${targetPath}`);
+      process.exitCode = 1;
+      return;
+    }
+    const projectDirectoryName = path5.basename(targetPath);
+    const projectSlug = toProjectSlug(projectDirectoryName);
+    if (!projectSlug) {
+      log.error("Invalid project name. Use letters, numbers, dots, underscores, or dashes.");
+      process.exitCode = 1;
+      return;
+    }
+    const rawModules = options.module && options.module.length > 0 ? parseModuleIds(options.module) : options.yes ? [] : await askMultiSelect(
+      "Select optional modules to include:",
+      optionalModules.map((module) => ({
+        value: module.id,
+        label: module.label,
+        hint: module.description
+      })),
+      []
+    );
+    const { selectedModules, autoAddedModules } = normalizeModuleSelection2(rawModules);
+    const installFlagProvided = process.argv.includes("--install") || process.argv.includes("--no-install");
+    const shouldInstall = installFlagProvided ? Boolean(options.install) : options.yes ? false : await askConfirm("Install dependencies now?", true);
+    await copyDirectory(templatePaths.base, targetPath);
+    for (const moduleId of selectedModules) {
+      const moduleDefinition = getModuleById(moduleId);
+      await copyDirectory(moduleDefinition.templatePath, targetPath);
+    }
+    let chatSchemaStatus;
+    if (selectedModules.includes("chat")) {
+      chatSchemaStatus = await ensureChatSchemaInProject(targetPath);
+    }
+    const moduleEnvEntries = selectedModules.reduce((acc, moduleId) => {
+      const module = getModuleById(moduleId);
+      return {
+        ...acc,
+        ...module.env
+      };
+    }, {});
+    if (Object.keys(moduleEnvEntries).length > 0) {
+      const envTargets = [
+        ".env",
+        ".env.example",
+        ".env.development"
+      ];
+      for (const envFile of envTargets) {
+        const envPath = path5.join(targetPath, envFile);
+        if (await pathExists(envPath)) {
+          await mergeEnvFile(envPath, moduleEnvEntries);
+        }
+      }
+    }
+    const dependencyEntries = selectedModules.reduce((acc, moduleId) => {
+      const module = getModuleById(moduleId);
+      return {
+        ...acc,
+        ...module.dependencies ?? {}
+      };
+    }, {});
+    if (Object.keys(dependencyEntries).length > 0) {
+      await addDependencies(path5.join(targetPath, "package.json"), dependencyEntries);
+    }
+    const betterAuthSecret = randomBytes(32).toString("base64url");
+    await replaceTokensInDirectory(targetPath, {
+      "__PROJECT_NAME__": projectSlug,
+      "__ENABLE_CHAT__": selectedModules.includes("chat") ? "true" : "false",
+      "__BETTER_AUTH_SECRET__": betterAuthSecret
+    });
+    if (shouldInstall) {
+      log.step(`Installing dependencies with ${packageManager}...`);
+      await runInstall(packageManager, targetPath);
+    }
+    finishPrompt("Project created successfully.");
+    log.detail("Path", targetPath);
+    if (projectSlug !== projectDirectoryName) {
+      log.detail("Normalized project id", projectSlug);
+    }
+    log.detail(
+      "Modules",
+      selectedModules.length > 0 ? selectedModules.join(", ") : "none"
+    );
+    if (autoAddedModules.length > 0) {
+      log.detail("Auto-added", autoAddedModules.join(", "));
+    }
+    if (chatSchemaStatus === "added") {
+      log.info("Optional chat schema block was appended to prisma/schema.prisma.");
+    }
+    log.step(`Next: cd ${projectName} && ${packageManager} run dev`);
+  });
+}
+
+// src/commands/migrate.ts
+import { spawn as spawn3 } from "child_process";
+import path6 from "path";
+function createDefaultMigrationName() {
+  const now = /* @__PURE__ */ new Date();
+  const y = now.getFullYear();
+  const m = String(now.getMonth() + 1).padStart(2, "0");
+  const d = String(now.getDate()).padStart(2, "0");
+  const hh = String(now.getHours()).padStart(2, "0");
+  const mm = String(now.getMinutes()).padStart(2, "0");
+  const ss = String(now.getSeconds()).padStart(2, "0");
+  return `auto_${y}${m}${d}${hh}${mm}${ss}`;
+}
+async function detectPackageManager(cwd) {
+  if (await pathExists(path6.join(cwd, "bun.lockb"))) {
+    return "bun";
+  }
+  if (await pathExists(path6.join(cwd, "bun.lock"))) {
+    return "bun";
+  }
+  if (await pathExists(path6.join(cwd, "pnpm-lock.yaml"))) {
+    return "pnpm";
+  }
+  if (await pathExists(path6.join(cwd, "yarn.lock"))) {
+    return "yarn";
+  }
+  return "npm";
+}
+function buildScriptArgs(manager, migrationName, skipGenerate) {
+  const prismaArgs = ["--name", migrationName];
+  if (skipGenerate) {
+    prismaArgs.push("--skip-generate");
+  }
+  if (manager === "yarn") {
+    return ["db:migrate", ...prismaArgs];
+  }
+  return ["run", "db:migrate", "--", ...prismaArgs];
+}
+async function runCommand2(command, args, cwd) {
+  await new Promise((resolve, reject) => {
+    const child = spawn3(command, args, {
+      cwd,
+      stdio: "inherit",
+      shell: process.platform === "win32"
+    });
+    child.on("error", reject);
+    child.on("close", (code) => {
+      if (code === 0) {
+        resolve();
+        return;
+      }
+      reject(new Error(`Migration command failed with code ${code ?? "unknown"}`));
+    });
+  });
+}
+function registerMigrateCommand(program2) {
+  program2.command("migrate").description("Run Prisma migration script in current project").option("--name <migration-name>", "Migration name (defaults to auto timestamp)").option("--skip-generate", "Pass --skip-generate to prisma migrate dev").action(async (options) => {
+    const cwd = process.cwd();
+    const hasPackageJson = await pathExists(path6.join(cwd, "package.json"));
+    const hasPrismaSchema = await pathExists(path6.join(cwd, "prisma", "schema.prisma"));
+    if (!hasPackageJson || !hasPrismaSchema) {
+      log.error(
+        "Run this command from a generated project root (requires package.json + prisma/schema.prisma)."
+      );
+      process.exitCode = 1;
+      return;
+    }
+    const packageManager = await detectPackageManager(cwd);
+    const migrationName = options.name?.trim() || createDefaultMigrationName();
+    const args = buildScriptArgs(packageManager, migrationName, Boolean(options.skipGenerate));
+    log.step(`Running migration via ${packageManager}: db:migrate --name ${migrationName}`);
+    await runCommand2(packageManager, args, cwd);
+    log.success("Migration completed successfully.");
+  });
+}
+
+// src/core/banner.ts
+var banner = String.raw`
+ _   _            _____ _____ _      ___ 
+| \ | | _____  __|_   _/ ____| |    |_ _|
+|  \| |/ _ \ \/ /  | || |    | |     | | 
+| |\  |  __/>  <   | || |____| |___  | | 
+|_| \_|\___/_/\_\  |_| \_____|_____||___|
+`;
+function printBanner(_argv) {
+  const reset2 = "\x1B[0m";
+  const colored = banner.trim().split("\n").map((line, index) => `${bannerGradient[index % bannerGradient.length]}${line}${reset2}`).join("\n");
+  console.log(colored);
+  console.log(theme.dim("  Outsource-ready Next.js scaffolding CLI"));
+}
+
+// src/core/cli-command.ts
+import { Command } from "commander";
+
+// src/core/colored-help.ts
+import { Help } from "commander";
+function colorizeUsageLine(line) {
+  if (!line.startsWith("Usage: ")) {
+    return line;
+  }
+  const usage = line.slice("Usage: ".length);
+  return `${theme.bold(theme.cyan("Usage:"))} ${theme.green(usage)}`;
+}
+function colorizeSectionHeader(line) {
+  switch (line.trim()) {
+    case "Options:":
+      return theme.bold(theme.yellow("Options:"));
+    case "Commands:":
+      return theme.bold(theme.magenta("Commands:"));
+    case "Arguments:":
+      return theme.bold(theme.blue("Arguments:"));
+    case "Global Options:":
+      return theme.bold(theme.yellow("Global Options:"));
+    default:
+      return line;
+  }
+}
+function colorizeHelpItemLine(line, termWidth, colorTerm) {
+  if (line.trim().length === 0) {
+    return line;
+  }
+  const leadingSpaces = line.length - line.trimStart().length;
+  if (leadingSpaces >= termWidth) {
+    return theme.dim(line);
+  }
+  const termPart = line.slice(0, termWidth).trimEnd();
+  const description = line.slice(termWidth).trimStart();
+  if (!description) {
+    return colorTerm(termPart);
+  }
+  const gap = " ".repeat(Math.max(1, termWidth - termPart.length));
+  return `${colorTerm(termPart)}${gap}${theme.dim(description)}`;
+}
+var ColoredHelp = class extends Help {
+  formatHelp(cmd, helper) {
+    const termWidth = helper.padWidth(cmd, helper);
+    const helpWidth = helper.helpWidth || 80;
+    const itemIndentWidth = 2;
+    const itemSeparatorWidth = 2;
+    const formatItem = (term, description, colorTerm) => {
+      if (description) {
+        const fullText = `${term.padEnd(termWidth + itemSeparatorWidth)}${description}`;
+        const wrapped = helper.wrap(
+          fullText,
+          helpWidth - itemIndentWidth,
+          termWidth + itemSeparatorWidth
+        );
+        return wrapped.split("\n").map((line) => colorizeHelpItemLine(line, termWidth, colorTerm)).join("\n");
+      }
+      return colorTerm(term);
+    };
+    const formatList = (textArray) => textArray.join("\n").replace(/^/gm, " ".repeat(itemIndentWidth));
+    let output = [colorizeUsageLine(`Usage: ${helper.commandUsage(cmd)}`), ""];
+    const commandDescription = helper.commandDescription(cmd);
+    if (commandDescription.length > 0) {
+      output = output.concat([helper.wrap(theme.dim(commandDescription), helpWidth, 0), ""]);
+    }
+    const argumentList = helper.visibleArguments(cmd).map(
+      (argument) => formatItem(
+        helper.argumentTerm(argument),
+        helper.argumentDescription(argument),
+        theme.blue
+      )
+    );
+    if (argumentList.length > 0) {
+      output = output.concat([colorizeSectionHeader("Arguments:"), formatList(argumentList), ""]);
+    }
+    const optionList = helper.visibleOptions(cmd).map(
+      (option) => formatItem(helper.optionTerm(option), helper.optionDescription(option), theme.yellow)
+    );
+    if (optionList.length > 0) {
+      output = output.concat([colorizeSectionHeader("Options:"), formatList(optionList), ""]);
+    }
+    if (this.showGlobalOptions) {
+      const globalOptionList = helper.visibleGlobalOptions(cmd).map(
+        (option) => formatItem(helper.optionTerm(option), helper.optionDescription(option), theme.yellow)
+      );
+      if (globalOptionList.length > 0) {
+        output = output.concat([
+          colorizeSectionHeader("Global Options:"),
+          formatList(globalOptionList),
+          ""
+        ]);
+      }
+    }
+    const commandList = helper.visibleCommands(cmd).map(
+      (subcommand) => formatItem(
+        helper.subcommandTerm(subcommand),
+        helper.subcommandDescription(subcommand),
+        theme.cyan
+      )
+    );
+    if (commandList.length > 0) {
+      output = output.concat([colorizeSectionHeader("Commands:"), formatList(commandList), ""]);
+    }
+    return output.join("\n");
+  }
+};
+
+// src/core/cli-command.ts
+var NexTCLICommand = class _NexTCLICommand extends Command {
+  createHelp() {
+    return Object.assign(new ColoredHelp(), this.configureHelp());
+  }
+  createCommand(name) {
+    return new _NexTCLICommand(name);
+  }
+};
+
+// src/cli.ts
+var program = new NexTCLICommand();
+program.name("nextcli").description("Scaffold outsource-ready Next.js projects").version("0.1.0");
+registerCreateCommand(program);
+registerAddCommand(program);
+registerMigrateCommand(program);
+printBanner(process.argv.slice(2));
+program.parse(process.argv);