@yousxlfs/next-arch 0.1.0 → 0.2.0

package/dist/index.js

@@ -2,14 +2,19 @@
 
 // src/index.ts
 import { program } from "commander";
-import { cancel, log as log3, outro as outro2 } from "@clack/prompts";
+import { cancel as cancel3, log as log4, outro as outro2 } from "@clack/prompts";
 import chalk from "chalk";
-import path5 from "path";
+import path8 from "path";
 
 // src/commands/generate.ts
+import { log as log2 } from "@clack/prompts";
+import fs4 from "fs-extra";
+import path4 from "path";
+
+// src/commands/page.ts
 import { log } from "@clack/prompts";
-import fs2 from "fs-extra";
-import path2 from "path";
+import fs3 from "fs-extra";
+import path3 from "path";
 
 // src/lib/naming.ts
 function toPascalCase(value) {
@@ -26,17 +31,73 @@ function assertValidSliceName(name) {
   }
 }
 
+// src/lib/page-prompts.ts
+import { cancel, isCancel, select } from "@clack/prompts";
+
+// src/lib/page-presets.ts
+var PAGE_PRESETS = [
+  "auth",
+  "dashboard",
+  "crud",
+  "profile",
+  "settings",
+  "blank"
+];
+var DEFAULT_PAGE_PRESET = "blank";
+var PAGE_PRESET_LABELS = {
+  auth: "auth \u2014 login/register/logout flow",
+  dashboard: "dashboard \u2014 layout with sidebar + analytics",
+  crud: "crud \u2014 list + create/edit/delete",
+  profile: "profile \u2014 user profile page",
+  settings: "settings \u2014 tabbed settings page",
+  blank: "blank \u2014 minimal page structure"
+};
+
+// src/lib/page-prompts.ts
+function exitOnCancel(value) {
+  if (isCancel(value)) {
+    cancel("Cancelled");
+    process.exit(0);
+  }
+  return value;
+}
+async function promptPagePreset(options) {
+  if (options.preset) {
+    if (!PAGE_PRESETS.includes(options.preset)) {
+      throw new Error(`Unknown preset "${options.preset}". Use: ${PAGE_PRESETS.join(", ")}`);
+    }
+    return options.preset;
+  }
+  if (options.yes) {
+    return DEFAULT_PAGE_PRESET;
+  }
+  return exitOnCancel(
+    await select({
+      message: "What page template do you want?",
+      options: PAGE_PRESETS.map((preset) => ({
+        value: preset,
+        label: PAGE_PRESET_LABELS[preset]
+      })),
+      initialValue: "blank"
+    })
+  );
+}
+
 // src/lib/paths.ts
 import path from "path";
 import { fileURLToPath } from "url";
 import fs from "fs-extra";
+var PACKAGE_NAMES = /* @__PURE__ */ new Set(["next-arch", "@yousxlfs/next-arch"]);
+function isNextArchPackage(pkg) {
+  return typeof pkg.name === "string" && PACKAGE_NAMES.has(pkg.name);
+}
 function findPackageRoot(startDir) {
   let current = startDir;
   while (current !== path.dirname(current)) {
     const packageJsonPath = path.join(current, "package.json");
     if (fs.existsSync(packageJsonPath)) {
       const pkg = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
-      if (pkg.name === "next-arch") {
+      if (isNextArchPackage(pkg)) {
         return current;
       }
     }
@@ -62,24 +123,9 @@ function resolveAppTemplateDir() {
   return appTemplate;
 }
 
-// src/commands/generate.ts
-var SLICE_TYPES = ["feature", "view", "widget", "entity"];
-var TARGET_DIRS = {
-  feature: "features",
-  view: "views",
-  widget: "widgets",
-  entity: "entities"
-};
-function isSliceType(value) {
-  return SLICE_TYPES.includes(value);
-}
-function assertNextProject(cwd) {
-  const packageJson = path2.join(cwd, "package.json");
-  const srcDir = path2.join(cwd, "src");
-  if (!fs2.existsSync(packageJson) || !fs2.existsSync(srcDir)) {
-    throw new Error("Run this command from the root of a Next Architecture project.");
-  }
-}
+// src/lib/template.ts
+import fs2 from "fs-extra";
+import path2 from "path";
 async function renderTemplateDir(templateDir, targetDir, replacements) {
   const created = [];
   if (!await fs2.pathExists(templateDir)) {
@@ -104,44 +150,168 @@ async function renderTemplateDir(templateDir, targetDir, replacements) {
       content = content.replaceAll(from, to);
     }
     await fs2.writeFile(targetPath, content);
-    created.push(path2.relative(process.cwd(), targetPath));
+    created.push(targetPath);
   }
   return created;
 }
-async function generateCommand(type, name, projectRoot = process.cwd(), options = {}) {
-  const root = path2.resolve(projectRoot);
+async function copyTemplateTree(sourceDir, targetDir) {
+  const created = [];
+  if (!await fs2.pathExists(sourceDir)) {
+    return created;
+  }
+  const entries = await fs2.readdir(sourceDir, { withFileTypes: true });
+  for (const entry of entries) {
+    const sourcePath = path2.join(sourceDir, entry.name);
+    const targetPath = path2.join(targetDir, entry.name);
+    if (entry.isDirectory()) {
+      await fs2.ensureDir(targetPath);
+      created.push(...await copyTemplateTree(sourcePath, targetPath));
+      continue;
+    }
+    await fs2.ensureDir(path2.dirname(targetPath));
+    await fs2.copy(sourcePath, targetPath);
+    created.push(targetPath);
+  }
+  return created;
+}
+function buildReplacements(name, pascalName, kebabName) {
+  return {
+    "{{Name}}": pascalName,
+    "{{name}}": kebabName,
+    "{{NAME}}": name.toUpperCase()
+  };
+}
+
+// src/commands/page.ts
+function assertNextProject(cwd) {
+  const packageJson = path3.join(cwd, "package.json");
+  const srcDir = path3.join(cwd, "src");
+  if (!fs3.existsSync(packageJson) || !fs3.existsSync(srcDir)) {
+    throw new Error("Run this command from the root of a Next Architecture project.");
+  }
+}
+async function pathExistsAny(paths) {
+  for (const candidate of paths) {
+    if (await fs3.pathExists(candidate)) {
+      return true;
+    }
+  }
+  return false;
+}
+async function pageCommand(name, projectRoot = process.cwd(), options = {}) {
+  const root = path3.resolve(projectRoot);
   assertNextProject(root);
   assertValidSliceName(name);
+  const preset = await promptPagePreset({ yes: options.yes, preset: options.preset });
+  const pascalName = toPascalCase(name);
+  const kebabName = toKebabCase(name);
+  const templatesDir = resolveTemplatesDir();
+  const templateDir = path3.join(templatesDir, "pages", preset);
+  if (!await fs3.pathExists(templateDir)) {
+    throw new Error(`Page preset "${preset}" template not found.`);
+  }
+  const targetDir = path3.join(root, "src");
+  const replacements = buildReplacements(name, pascalName, kebabName);
+  const conflictPaths = [
+    path3.join(targetDir, "app", kebabName),
+    path3.join(targetDir, "app", `(${kebabName})`),
+    path3.join(targetDir, "views", kebabName),
+    path3.join(targetDir, "features", kebabName),
+    path3.join(targetDir, "entities", kebabName)
+  ];
+  if (!options.force && await pathExistsAny(conflictPaths)) {
+    throw new Error(
+      `Page "${kebabName}" already exists. Use --force to overwrite conflicting paths.`
+    );
+  }
+  const previousCwd = process.cwd();
+  process.chdir(root);
+  try {
+    if (options.force) {
+      for (const conflictPath of conflictPaths) {
+        if (await fs3.pathExists(conflictPath)) {
+          await fs3.remove(conflictPath);
+        }
+      }
+    }
+    const created = await renderTemplateDir(templateDir, root, replacements);
+    const relativeFiles = created.map((file) => path3.relative(root, file));
+    log.success(`Created ${preset} page "${kebabName}"`);
+    for (const file of relativeFiles) {
+      log.info(`  ${file}`);
+    }
+    if (preset === "blank") {
+      log.info(`Route: src/app/${kebabName}/page.tsx`);
+    }
+    if (preset === "auth") {
+      log.info(`Routes: src/app/(${kebabName})/login and register`);
+    }
+    if (preset === "crud") {
+      log.info(`Routes: src/app/${kebabName}, ${kebabName}/[id], ${kebabName}/new`);
+    }
+  } finally {
+    process.chdir(previousCwd);
+  }
+}
+
+// src/commands/generate.ts
+var SLICE_TYPES = ["feature", "view", "widget", "entity"];
+var TARGET_DIRS = {
+  feature: "features",
+  view: "views",
+  widget: "widgets",
+  entity: "entities"
+};
+function isSliceType(value) {
+  return SLICE_TYPES.includes(value);
+}
+function assertNextProject2(cwd) {
+  const packageJson = path4.join(cwd, "package.json");
+  const srcDir = path4.join(cwd, "src");
+  if (!fs4.existsSync(packageJson) || !fs4.existsSync(srcDir)) {
+    throw new Error("Run this command from the root of a Next Architecture project.");
+  }
+}
+async function generateCommand(type, name, projectRoot = process.cwd(), options = {}) {
+  if (type === "page") {
+    await pageCommand(name, projectRoot, {
+      force: options.force,
+      yes: options.yes,
+      preset: options.preset
+    });
+    return;
+  }
+  const root = path4.resolve(projectRoot);
+  assertNextProject2(root);
+  assertValidSliceName(name);
   if (!isSliceType(type)) {
-    throw new Error(`Unknown type "${type}". Use: ${SLICE_TYPES.join(", ")}`);
+    throw new Error(`Unknown type "${type}". Use: page, ${SLICE_TYPES.join(", ")}`);
   }
   const pascalName = toPascalCase(name);
   const kebabName = toKebabCase(name);
   const templatesDir = resolveTemplatesDir();
-  const templateDir = path2.join(templatesDir, type);
-  const targetDir = path2.join(root, "src", TARGET_DIRS[type], kebabName);
+  const templateDir = path4.join(templatesDir, type);
+  const targetDir = path4.join(root, "src", TARGET_DIRS[type], kebabName);
   const previousCwd = process.cwd();
   process.chdir(root);
   try {
-    if (await fs2.pathExists(targetDir)) {
+    if (await fs4.pathExists(targetDir)) {
       if (!options.force) {
         throw new Error(
           `"${type}" "${kebabName}" already exists at ${targetDir}. Use --force to overwrite.`
         );
       }
-      await fs2.remove(targetDir);
+      await fs4.remove(targetDir);
     }
-    const replacements = {
-      "{{Name}}": pascalName,
-      "{{name}}": kebabName
-    };
+    const replacements = buildReplacements(name, pascalName, kebabName);
     const created = await renderTemplateDir(templateDir, targetDir, replacements);
-    log.success(`Created ${type} "${kebabName}" in ${root}`);
-    for (const file of created) {
-      log.info(`  ${file}`);
+    const relativeFiles = created.map((file) => path4.relative(root, file));
+    log2.success(`Created ${type} "${kebabName}" in ${root}`);
+    for (const file of relativeFiles) {
+      log2.info(`  ${file}`);
     }
     if (type === "view") {
-      log.info(`Add to a route: import { ${pascalName} } from '@/views/${kebabName}';`);
+      log2.info(`Add to a route: import { ${pascalName} } from '@/views/${kebabName}';`);
     }
   } finally {
     process.chdir(previousCwd);
@@ -149,33 +319,324 @@ async function generateCommand(type, name, projectRoot = process.cwd(), options
 }
 
 // src/commands/init.ts
-import { confirm, intro, log as log2, outro } from "@clack/prompts";
-import fs4 from "fs-extra";
-import path4 from "path";
+import { confirm as confirm2, intro, log as log3, outro } from "@clack/prompts";
+import fs7 from "fs-extra";
+import path7 from "path";
+
+// src/lib/apply-packages.ts
+import fs5 from "fs-extra";
+import path5 from "path";
+
+// src/lib/packages.ts
+var DEFAULT_INIT_SELECTIONS = {
+  stateManager: "zustand",
+  formLibrary: "tanstack-form",
+  optionalPackages: ["tanstack-table"],
+  withExamples: true
+};
+var PACKAGE_VERSIONS = {
+  zustand: "^5.0.14",
+  "@reduxjs/toolkit": "^2.8.2",
+  "react-redux": "^9.2.0",
+  jotai: "^2.12.5",
+  "@tanstack/react-form": "^1.0.0",
+  zod: "^4.4.3",
+  "react-hook-form": "^7.56.4",
+  "@hookform/resolvers": "^5.0.1",
+  "@tanstack/react-query": "^5.101.2",
+  "@tanstack/react-query-devtools": "^5.101.2",
+  "@tanstack/react-table": "^8.21.3",
+  motion: "^12.19.1",
+  nuqs: "^2.4.3",
+  "@trpc/client": "^11.1.2",
+  "@trpc/server": "^11.1.2",
+  "@trpc/react-query": "^11.1.2",
+  "better-auth": "^1.2.8",
+  uploadthing: "^7.7.2",
+  "@uploadthing/react": "^7.3.1",
+  sonner: "^2.0.3",
+  "next-intl": "^4.1.0",
+  "@sentry/nextjs": "^9.22.0"
+};
+function resolveDependencies(selections) {
+  const dependencies = {};
+  const devDependencies = {};
+  dependencies["@tanstack/react-query"] = PACKAGE_VERSIONS["@tanstack/react-query"];
+  devDependencies["@tanstack/react-query-devtools"] = PACKAGE_VERSIONS["@tanstack/react-query-devtools"];
+  dependencies.zod = PACKAGE_VERSIONS.zod;
+  switch (selections.stateManager) {
+    case "zustand":
+      dependencies.zustand = PACKAGE_VERSIONS.zustand;
+      break;
+    case "redux":
+      dependencies["@reduxjs/toolkit"] = PACKAGE_VERSIONS["@reduxjs/toolkit"];
+      dependencies["react-redux"] = PACKAGE_VERSIONS["react-redux"];
+      break;
+    case "jotai":
+      dependencies.jotai = PACKAGE_VERSIONS.jotai;
+      break;
+    case "none":
+      break;
+  }
+  switch (selections.formLibrary) {
+    case "tanstack-form":
+      dependencies["@tanstack/react-form"] = PACKAGE_VERSIONS["@tanstack/react-form"];
+      break;
+    case "react-hook-form":
+      dependencies["react-hook-form"] = PACKAGE_VERSIONS["react-hook-form"];
+      dependencies["@hookform/resolvers"] = PACKAGE_VERSIONS["@hookform/resolvers"];
+      break;
+    case "none":
+      break;
+  }
+  for (const pkg of selections.optionalPackages) {
+    switch (pkg) {
+      case "tanstack-table":
+        dependencies["@tanstack/react-table"] = PACKAGE_VERSIONS["@tanstack/react-table"];
+        break;
+      case "motion":
+        dependencies.motion = PACKAGE_VERSIONS.motion;
+        break;
+      case "nuqs":
+        dependencies.nuqs = PACKAGE_VERSIONS.nuqs;
+        break;
+      case "trpc":
+        dependencies["@trpc/client"] = PACKAGE_VERSIONS["@trpc/client"];
+        dependencies["@trpc/server"] = PACKAGE_VERSIONS["@trpc/server"];
+        dependencies["@trpc/react-query"] = PACKAGE_VERSIONS["@trpc/react-query"];
+        break;
+      case "better-auth":
+        dependencies["better-auth"] = PACKAGE_VERSIONS["better-auth"];
+        break;
+      case "uploadthing":
+        dependencies.uploadthing = PACKAGE_VERSIONS.uploadthing;
+        dependencies["@uploadthing/react"] = PACKAGE_VERSIONS["@uploadthing/react"];
+        break;
+      case "sonner":
+        dependencies.sonner = PACKAGE_VERSIONS.sonner;
+        break;
+      case "next-intl":
+        dependencies["next-intl"] = PACKAGE_VERSIONS["next-intl"];
+        break;
+      case "sentry":
+        dependencies["@sentry/nextjs"] = PACKAGE_VERSIONS["@sentry/nextjs"];
+        break;
+    }
+  }
+  return { dependencies, devDependencies };
+}
+function getPackageTemplates(selections) {
+  const templates = /* @__PURE__ */ new Set(["tanstack-query", "env"]);
+  switch (selections.stateManager) {
+    case "zustand":
+      templates.add("zustand");
+      break;
+    case "redux":
+      templates.add("redux");
+      break;
+    case "jotai":
+      templates.add("jotai");
+      break;
+    case "none":
+      break;
+  }
+  switch (selections.formLibrary) {
+    case "tanstack-form":
+      templates.add("tanstack-form");
+      break;
+    case "react-hook-form":
+      templates.add("react-hook-form");
+      break;
+    case "none":
+      break;
+  }
+  for (const pkg of selections.optionalPackages) {
+    templates.add(pkg);
+  }
+  if (selections.optionalPackages.includes("sonner")) {
+    templates.add("sonner-provider");
+  }
+  return [...templates];
+}
+function formatSelectionsSummary(selections) {
+  const lines = [];
+  const stateLabels = {
+    zustand: "Zustand",
+    redux: "Redux Toolkit",
+    jotai: "Jotai",
+    none: "None"
+  };
+  const formLabels = {
+    "tanstack-form": "TanStack Form + zod",
+    "react-hook-form": "React Hook Form + zod",
+    none: "None"
+  };
+  lines.push(`State: ${stateLabels[selections.stateManager]}`);
+  lines.push(`Forms: ${formLabels[selections.formLibrary]}`);
+  lines.push("Always: TanStack Query + Devtools");
+  const optionalLabels = {
+    "tanstack-table": "TanStack Table",
+    motion: "Motion",
+    nuqs: "nuqs",
+    trpc: "tRPC",
+    "better-auth": "Better Auth",
+    uploadthing: "Uploadthing",
+    sonner: "Sonner",
+    "next-intl": "next-intl",
+    "sentry": "Sentry"
+  };
+  if (selections.optionalPackages.length > 0) {
+    lines.push(
+      `Optional: ${selections.optionalPackages.map((p) => optionalLabels[p]).join(", ")}`
+    );
+  } else {
+    lines.push("Optional: none");
+  }
+  lines.push(`Examples: ${selections.withExamples ? "yes" : "no"}`);
+  return lines;
+}
+
+// src/lib/apply-packages.ts
+async function mergePackageJson(targetDir, selections) {
+  const packageJsonPath = path5.join(targetDir, "package.json");
+  const pkg = JSON.parse(await fs5.readFile(packageJsonPath, "utf8"));
+  const { dependencies, devDependencies } = resolveDependencies(selections);
+  pkg.dependencies = { ...pkg.dependencies, ...dependencies };
+  pkg.devDependencies = { ...pkg.devDependencies, ...devDependencies };
+  await fs5.writeFile(packageJsonPath, `${JSON.stringify(pkg, null, 2)}
+`);
+}
+async function applyPackageSelections(targetDir, selections) {
+  const packagesDir = path5.join(resolveTemplatesDir(), "packages");
+  const created = [];
+  await mergePackageJson(targetDir, selections);
+  for (const templateId of getPackageTemplates(selections)) {
+    const templateRoot = path5.join(packagesDir, templateId);
+    const coreSrc = path5.join(templateRoot, "core", "src");
+    const examplesSrc = path5.join(templateRoot, "examples", "src");
+    if (await fs5.pathExists(coreSrc)) {
+      const files = await copyTemplateTree(coreSrc, path5.join(targetDir, "src"));
+      created.push(...files);
+    }
+    if (selections.withExamples && await fs5.pathExists(examplesSrc)) {
+      const files = await copyTemplateTree(examplesSrc, path5.join(targetDir, "src"));
+      created.push(...files);
+    }
+  }
+  return created;
+}
 
 // src/lib/copy.ts
-import fs3 from "fs-extra";
-import path3 from "path";
+import fs6 from "fs-extra";
+import path6 from "path";
 var EXCLUDED_DIRS = /* @__PURE__ */ new Set(["node_modules", ".next", ".turbo", "dist"]);
 async function copyProjectTemplate(sourceDir, targetDir) {
-  await fs3.copy(sourceDir, targetDir, {
+  await fs6.copy(sourceDir, targetDir, {
     filter(src) {
-      const relative = path3.relative(sourceDir, src);
+      const relative = path6.relative(sourceDir, src);
       if (!relative) return true;
-      return !relative.split(path3.sep).some((part) => EXCLUDED_DIRS.has(part));
+      return !relative.split(path6.sep).some((part) => EXCLUDED_DIRS.has(part));
     }
   });
 }
 
+// src/lib/init-prompts.ts
+import { cancel as cancel2, confirm, isCancel as isCancel2, multiselect, select as select2 } from "@clack/prompts";
+function exitOnCancel2(value) {
+  if (isCancel2(value)) {
+    cancel2("Cancelled");
+    process.exit(0);
+  }
+  return value;
+}
+async function promptInitSelections(options = {}) {
+  if (options.yes) {
+    return {
+      ...DEFAULT_INIT_SELECTIONS,
+      withExamples: options.noExamples ? false : DEFAULT_INIT_SELECTIONS.withExamples
+    };
+  }
+  const stateManager = exitOnCancel2(
+    await select2({
+      message: "Which state manager do you want?",
+      options: [
+        { value: "zustand", label: "Zustand (recommended)" },
+        { value: "redux", label: "Redux Toolkit" },
+        { value: "jotai", label: "Jotai" },
+        { value: "none", label: "None" }
+      ],
+      initialValue: "zustand"
+    })
+  );
+  const formLibrary = exitOnCancel2(
+    await select2({
+      message: "Which form library do you want?",
+      options: [
+        { value: "tanstack-form", label: "TanStack Form (recommended)" },
+        { value: "react-hook-form", label: "React Hook Form" },
+        { value: "none", label: "None" }
+      ],
+      initialValue: "tanstack-form"
+    })
+  );
+  const optionalPackages = exitOnCancel2(
+    await multiselect({
+      message: "Select additional packages (multi-select)",
+      options: [
+        { value: "tanstack-table", label: "TanStack Table (headless tables)" },
+        { value: "motion", label: "Motion / Framer Motion (animations)" },
+        { value: "nuqs", label: "nuqs (URL state management)" },
+        { value: "trpc", label: "tRPC (end-to-end type safety, if using separate backend)" },
+        { value: "better-auth", label: "Better Auth (alternative to NextAuth)" },
+        { value: "uploadthing", label: "Uploadthing (file uploads)" },
+        { value: "sonner", label: "Sonner (toast notifications)" },
+        { value: "next-intl", label: "next-intl (i18n)" },
+        { value: "sentry", label: "Sentry (error tracking)" }
+      ],
+      initialValues: ["tanstack-table"],
+      required: false
+    })
+  );
+  let withExamples = true;
+  if (!options.noExamples) {
+    withExamples = exitOnCancel2(
+      await confirm({
+        message: "Generate example files with comments (Russian)?",
+        initialValue: true
+      })
+    );
+  } else {
+    withExamples = false;
+  }
+  const selections = {
+    stateManager,
+    formLibrary,
+    optionalPackages,
+    withExamples
+  };
+  const proceed = exitOnCancel2(
+    await confirm({
+      message: `Proceed with this setup?
+${formatSelectionsSummary(selections).map((l) => `  \u2022 ${l}`).join("\n")}`,
+      initialValue: true
+    })
+  );
+  if (!proceed) {
+    cancel2("Cancelled");
+    process.exit(0);
+  }
+  return selections;
+}
+
 // src/commands/init.ts
 async function resolveEslintPluginSource() {
   const packageRoot = getPackageRoot();
   const candidates = [
-    path4.join(packageRoot, "vendor", "eslint-plugin-next-arch"),
-    path4.resolve(packageRoot, "..", "..", "packages", "eslint-plugin-next-arch")
+    path7.join(packageRoot, "vendor", "eslint-plugin-next-arch"),
+    path7.resolve(packageRoot, "..", "..", "packages", "eslint-plugin-next-arch")
   ];
   for (const candidate of candidates) {
-    if (await fs4.pathExists(path4.join(candidate, "dist", "index.js"))) {
+    if (await fs7.pathExists(path7.join(candidate, "dist", "index.js"))) {
       return candidate;
     }
   }
@@ -185,29 +646,33 @@ async function resolveEslintPluginSource() {
 }
 async function bundleEslintPlugin(targetDir) {
   const pluginSource = await resolveEslintPluginSource();
-  const pluginTarget = path4.join(targetDir, "vendor", "eslint-plugin-next-arch");
-  await fs4.ensureDir(pluginTarget);
-  await fs4.copy(path4.join(pluginSource, "dist"), path4.join(pluginTarget, "dist"));
-  await fs4.copy(path4.join(pluginSource, "package.json"), path4.join(pluginTarget, "package.json"));
+  const pluginTarget = path7.join(targetDir, "vendor", "eslint-plugin-next-arch");
+  await fs7.ensureDir(pluginTarget);
+  await fs7.copy(path7.join(pluginSource, "dist"), path7.join(pluginTarget, "dist"));
+  await fs7.copy(path7.join(pluginSource, "package.json"), path7.join(pluginTarget, "package.json"));
 }
 async function patchPackageJson(targetDir, projectName) {
-  const packageJsonPath = path4.join(targetDir, "package.json");
-  const pkg = JSON.parse(await fs4.readFile(packageJsonPath, "utf8"));
+  const packageJsonPath = path7.join(targetDir, "package.json");
+  const pkg = JSON.parse(await fs7.readFile(packageJsonPath, "utf8"));
   pkg.name = projectName;
   delete pkg.scripts?.arch;
   if (pkg.devDependencies) {
     pkg.devDependencies["eslint-plugin-next-arch"] = "file:./vendor/eslint-plugin-next-arch";
   }
-  await fs4.writeFile(packageJsonPath, `${JSON.stringify(pkg, null, 2)}
+  await fs7.writeFile(packageJsonPath, `${JSON.stringify(pkg, null, 2)}
 `);
 }
 async function initCommand(projectName, options = {}) {
-  const baseDir = path4.resolve(options.cwd ?? process.cwd());
+  const baseDir = path7.resolve(options.cwd ?? process.cwd());
   intro("Creating new Next Architecture project...");
-  const targetDir = path4.join(baseDir, projectName);
+  const selections = await promptInitSelections({
+    yes: options.yes,
+    noExamples: options.noExamples
+  });
+  const targetDir = path7.join(baseDir, projectName);
   const templateDir = resolveAppTemplateDir();
-  if (await fs4.pathExists(targetDir)) {
-    const shouldContinue = await confirm({
+  if (await fs7.pathExists(targetDir)) {
+    const shouldContinue = await confirm2({
       message: "Directory already exists. Continue and merge files?"
     });
     if (!shouldContinue) {
@@ -215,41 +680,77 @@ async function initCommand(projectName, options = {}) {
       return;
     }
   }
-  log2.info(`Copying template from ${path4.basename(templateDir)}...`);
+  log3.info("Package setup:");
+  for (const line of formatSelectionsSummary(selections)) {
+    log3.info(`  ${line}`);
+  }
+  log3.info(`Copying template from ${path7.basename(templateDir)}...`);
   await copyProjectTemplate(templateDir, targetDir);
   await bundleEslintPlugin(targetDir);
   await patchPackageJson(targetDir, projectName);
-  await fs4.writeFile(path4.join(targetDir, ".npmrc"), "ignore-workspace=true\n");
-  log2.success(`Project "${projectName}" created`);
-  log2.info(`  cd ${projectName}`);
-  log2.info("  pnpm install");
-  log2.info("  pnpm dev");
+  await applyPackageSelections(targetDir, selections);
+  await fs7.writeFile(path7.join(targetDir, ".npmrc"), "ignore-workspace=true\n");
+  log3.success(`Project "${projectName}" created`);
+  log3.info(`  cd ${projectName}`);
+  log3.info("  npm install");
+  log3.info("  npm run dev");
+  if (selections.withExamples) {
+    log3.info("  See src/features/_examples/ for commented package examples");
+  }
   outro("Done!");
 }
 
 // src/index.ts
 console.log(chalk.blue("Next Architecture CLI"));
-program.name("next-arch").description("CLI for Next.js Feature-Sliced Architecture").version("0.1.0");
-program.command("init <projectName>").description("Create a new project with Next Architecture").option("-C, --cwd <path>", "directory where the project folder will be created").action(async (projectName, options) => {
-  try {
-    await initCommand(projectName, { cwd: options.cwd });
-  } catch (error) {
-    cancel(error instanceof Error ? error.message : "Init failed");
-    process.exit(1);
+program.name("next-arch").description("CLI for Next.js Feature-Sliced Architecture").version("0.2.0");
+program.command("init <projectName>").description("Create a new project with Next Architecture").option("-C, --cwd <path>", "directory where the project folder will be created").option("-y, --yes", "use default package selections without prompts").option("--no-examples", "skip generating example files").action(
+  async (projectName, options) => {
+    try {
+      await initCommand(projectName, {
+        cwd: options.cwd,
+        yes: options.yes,
+        noExamples: options.examples === false
+      });
+    } catch (error) {
+      cancel3(error instanceof Error ? error.message : "Init failed");
+      process.exit(1);
+    }
   }
-});
-program.command("generate <type> <name>").alias("g").description("Generate feature, widget, entity, or view").option("-C, --cwd <path>", "path to Next.js project root (default: current directory)").option("-f, --force", "overwrite existing slice").action(async (type, name, options) => {
-  try {
-    const projectRoot = options.cwd ? path5.resolve(options.cwd) : process.cwd();
-    await generateCommand(type, name, projectRoot, { force: options.force });
-    outro2("Done!");
-  } catch (error) {
-    cancel(error instanceof Error ? error.message : "Generate failed");
-    process.exit(1);
+);
+program.command("page <name>").description("Generate a full FSD page (view + feature + routes)").option("-C, --cwd <path>", "path to Next.js project root (default: current directory)").option("-f, --force", "overwrite existing page paths").option("-y, --yes", "use blank preset without prompts").option("--preset <preset>", "page preset: auth, dashboard, crud, profile, settings, blank").action(
+  async (name, options) => {
+    try {
+      const projectRoot = options.cwd ? path8.resolve(options.cwd) : process.cwd();
+      await pageCommand(name, projectRoot, {
+        force: options.force,
+        yes: options.yes,
+        preset: options.preset
+      });
+      outro2("Done!");
+    } catch (error) {
+      cancel3(error instanceof Error ? error.message : "Page generation failed");
+      process.exit(1);
+    }
   }
-});
+);
+program.command("generate <type> <name>").alias("g").description("Generate page, feature, widget, entity, or view").option("-C, --cwd <path>", "path to Next.js project root (default: current directory)").option("-f, --force", "overwrite existing slice").option("-y, --yes", "skip interactive page preset selection").option("--preset <preset>", "page preset when type is page").action(
+  async (type, name, options) => {
+    try {
+      const projectRoot = options.cwd ? path8.resolve(options.cwd) : process.cwd();
+      await generateCommand(type, name, projectRoot, {
+        force: options.force,
+        yes: options.yes,
+        preset: options.preset
+      });
+      outro2("Done!");
+    } catch (error) {
+      cancel3(error instanceof Error ? error.message : "Generate failed");
+      process.exit(1);
+    }
+  }
+);
 program.parseAsync(process.argv).catch((error) => {
-  log3.error(error instanceof Error ? error.message : "Unexpected error");
+  log4.error(error instanceof Error ? error.message : "Unexpected error");
   process.exit(1);
 });
 //# sourceMappingURL=index.js.map