@appswave/rq-codegen 0.1.0

package/dist/bin/cli.js

@@ -0,0 +1,1788 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { Command } from "commander";
+
+// src/commands/generate.ts
+import chalk from "chalk";
+import inquirer from "inquirer";
+
+// src/config/loader.ts
+import fs from "fs";
+import path from "path";
+import { pathToFileURL } from "url";
+
+// src/config/defaults.ts
+var DEFAULT_CONFIG = {
+  srcDir: "./src",
+  aliases: {
+    api: "@api",
+    components: "@components",
+    hooks: "@hooks",
+    types: "@app-types",
+    utils: "@utils",
+    contexts: "@contexts",
+    constants: "@constants",
+    views: "@views",
+    pages: "@pages",
+    validations: "@validations",
+    assets: "@assets",
+    routes: "@routes",
+    hoc: "@hoc",
+    appConfig: "@app-config"
+  },
+  features: {
+    i18n: true,
+    toast: true,
+    barrel: true,
+    routeRegistration: false
+  },
+  naming: {
+    dtoSuffixes: {
+      read: "ForReadDto",
+      create: "ForCreateDto",
+      update: "ForUpdateDto",
+      list: "ListDto",
+      listResponse: "ListResponseDto",
+      params: "ParamsDto"
+    },
+    validationSuffix: ".schema.ts",
+    pageSuffix: "Page",
+    hookPrefix: "use"
+  },
+  paths: {
+    handlers: "api/handlers",
+    apiConfig: "api/config",
+    types: "types/api",
+    queries: "lib/hooks/queries",
+    mutations: "lib/hooks/mutations",
+    sharedHooks: "lib/hooks/shared",
+    hookUtils: "lib/hooks/utils",
+    uiComponents: "components/ui",
+    sharedComponents: "components/shared",
+    formComponents: "components/forms",
+    pages: "pages",
+    views: "views",
+    validations: "validations"
+  },
+  router: {
+    routerFile: "routes/router.tsx",
+    routesFile: "routes/routes.ts",
+    layouts: ["MainLayout", "DashboardLayout"]
+  },
+  hooks: {
+    toast: { import: "useToast", from: "@hooks/shared" },
+    translation: { import: "useAppTranslation", from: "@hooks/shared" },
+    paginatedQuery: { import: "usePaginatedDataTableQuery", from: "@hooks/utils" }
+  }
+};
+
+// src/config/schema.ts
+import { z } from "zod";
+var hookImportSchema = z.object({
+  import: z.string(),
+  from: z.string()
+});
+var configSchema = z.object({
+  srcDir: z.string().optional(),
+  aliases: z.object({
+    api: z.string().optional(),
+    components: z.string().optional(),
+    hooks: z.string().optional(),
+    types: z.string().optional(),
+    utils: z.string().optional(),
+    contexts: z.string().optional(),
+    constants: z.string().optional(),
+    views: z.string().optional(),
+    pages: z.string().optional(),
+    validations: z.string().optional(),
+    assets: z.string().optional(),
+    routes: z.string().optional(),
+    hoc: z.string().optional(),
+    appConfig: z.string().optional()
+  }).optional(),
+  features: z.object({
+    i18n: z.boolean().optional(),
+    toast: z.boolean().optional(),
+    barrel: z.boolean().optional(),
+    routeRegistration: z.boolean().optional()
+  }).optional(),
+  naming: z.object({
+    dtoSuffixes: z.object({
+      read: z.string().optional(),
+      create: z.string().optional(),
+      update: z.string().optional(),
+      list: z.string().optional(),
+      listResponse: z.string().optional(),
+      params: z.string().optional()
+    }).optional(),
+    validationSuffix: z.string().optional(),
+    pageSuffix: z.string().optional(),
+    hookPrefix: z.string().optional()
+  }).optional(),
+  paths: z.object({
+    handlers: z.string().optional(),
+    apiConfig: z.string().optional(),
+    types: z.string().optional(),
+    queries: z.string().optional(),
+    mutations: z.string().optional(),
+    sharedHooks: z.string().optional(),
+    hookUtils: z.string().optional(),
+    uiComponents: z.string().optional(),
+    sharedComponents: z.string().optional(),
+    formComponents: z.string().optional(),
+    pages: z.string().optional(),
+    views: z.string().optional(),
+    validations: z.string().optional()
+  }).optional(),
+  router: z.object({
+    routerFile: z.string().optional(),
+    routesFile: z.string().optional(),
+    layouts: z.array(z.string()).optional()
+  }).optional(),
+  hooks: z.object({
+    toast: hookImportSchema.optional(),
+    translation: hookImportSchema.optional(),
+    paginatedQuery: hookImportSchema.optional()
+  }).optional(),
+  templatesDir: z.string().optional()
+});
+
+// src/config/loader.ts
+function deepMerge(target, source) {
+  const result = { ...target };
+  for (const key of Object.keys(source)) {
+    const sourceVal = source[key];
+    const targetVal = target[key];
+    if (sourceVal === void 0) continue;
+    if (sourceVal !== null && typeof sourceVal === "object" && !Array.isArray(sourceVal) && targetVal !== null && typeof targetVal === "object" && !Array.isArray(targetVal)) {
+      result[key] = deepMerge(
+        targetVal,
+        sourceVal
+      );
+    } else {
+      result[key] = sourceVal;
+    }
+  }
+  return result;
+}
+function detectAliasesFromTsConfig(projectRoot) {
+  const configFiles = ["tsconfig.app.json", "tsconfig.json"];
+  for (const configFile of configFiles) {
+    const fullPath = path.resolve(projectRoot, configFile);
+    if (!fs.existsSync(fullPath)) continue;
+    try {
+      const raw = JSON.parse(fs.readFileSync(fullPath, "utf-8"));
+      const paths = raw.compilerOptions?.paths ?? {};
+      return mapTsPathsToAliases(paths);
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+function mapTsPathsToAliases(paths) {
+  const aliases = {};
+  const aliasMap = {
+    "api": "api",
+    "components": "components",
+    "hooks": "hooks",
+    "app-types": "types",
+    "types": "types",
+    "utils": "utils",
+    "contexts": "contexts",
+    "constants": "constants",
+    "views": "views",
+    "pages": "pages",
+    "validations": "validations",
+    "assets": "assets",
+    "routes": "routes",
+    "hoc": "hoc",
+    "app-config": "appConfig"
+  };
+  for (const tsAlias of Object.keys(paths)) {
+    const match = tsAlias.match(/^@([\w-]+)/);
+    if (!match) continue;
+    const aliasName = match[1];
+    const configKey = aliasMap[aliasName];
+    if (configKey) {
+      aliases[configKey] = tsAlias.replace("/*", "");
+    }
+  }
+  return aliases;
+}
+async function findConfigFile(projectRoot) {
+  const candidates = [
+    "rqgen.config.ts",
+    "rqgen.config.mts",
+    "rqgen.config.js",
+    "rqgen.config.mjs"
+  ];
+  for (const candidate of candidates) {
+    const fullPath = path.resolve(projectRoot, candidate);
+    if (fs.existsSync(fullPath)) return fullPath;
+  }
+  const pkgPath = path.resolve(projectRoot, "package.json");
+  if (fs.existsSync(pkgPath)) {
+    try {
+      const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+      if (pkg.rqgen) return pkgPath;
+    } catch {
+    }
+  }
+  return null;
+}
+async function loadConfigFromFile(configPath) {
+  const ext = path.extname(configPath);
+  const basename = path.basename(configPath);
+  if (basename === "package.json") {
+    const pkg = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+    return pkg.rqgen ?? {};
+  }
+  if (ext === ".ts" || ext === ".mts") {
+    try {
+      const fileUrl2 = pathToFileURL(configPath).href;
+      const mod2 = await import(fileUrl2);
+      return mod2.default ?? mod2;
+    } catch {
+      throw new Error(
+        `Failed to load TypeScript config: ${configPath}
+Make sure you have "tsx" installed: npm i -D tsx
+And run with: NODE_OPTIONS="--import tsx" rq-codegen`
+      );
+    }
+  }
+  const fileUrl = pathToFileURL(configPath).href;
+  const mod = await import(fileUrl);
+  return mod.default ?? mod;
+}
+async function loadConfig(projectRoot) {
+  const root = projectRoot ?? process.cwd();
+  const configPath = await findConfigFile(root);
+  let userConfig = {};
+  if (configPath) {
+    const rawConfig = await loadConfigFromFile(configPath);
+    const parsed = configSchema.safeParse(rawConfig);
+    if (!parsed.success) {
+      const errors = parsed.error.issues.map((i) => `  - ${i.path.join(".")}: ${i.message}`);
+      throw new Error(`Invalid rqgen config:
+${errors.join("\n")}`);
+    }
+    userConfig = parsed.data;
+  }
+  if (!userConfig.aliases) {
+    const detected = detectAliasesFromTsConfig(root);
+    if (detected) {
+      userConfig.aliases = detected;
+    }
+  }
+  const config = deepMerge(DEFAULT_CONFIG, userConfig);
+  return config;
+}
+
+// src/core/engine.ts
+import fs5 from "fs";
+import path5 from "path";
+import Handlebars2 from "handlebars";
+
+// src/core/helpers.ts
+function registerHelpers(handlebars, config) {
+  handlebars.registerHelper("constantCase", (text) => {
+    return text.replace(/([a-z])([A-Z])/g, "$1_$2").replace(/[\s-]+/g, "_").toUpperCase();
+  });
+  handlebars.registerHelper("eq", (a, b) => a === b);
+  handlebars.registerHelper("neq", (a, b) => a !== b);
+  handlebars.registerHelper("plural", (text) => {
+    if (text.endsWith("s")) return text;
+    if (text.endsWith("y") && !/[aeiou]y$/i.test(text)) return text.slice(0, -1) + "ies";
+    return text + "s";
+  });
+  handlebars.registerHelper("includes", (arr, val) => {
+    return Array.isArray(arr) && arr.includes(val);
+  });
+  handlebars.registerHelper("join", (arr, separator) => {
+    return Array.isArray(arr) ? arr.join(separator) : "";
+  });
+  handlebars.registerHelper("configAlias", (key) => {
+    return config.aliases[key] ?? `@${key}`;
+  });
+  handlebars.registerHelper("configPath", (key) => {
+    return config.paths[key] ?? key;
+  });
+  handlebars.registerHelper("dtoSuffix", (key) => {
+    return config.naming.dtoSuffixes[key] ?? "";
+  });
+  handlebars.registerHelper("ifFeature", function(feature, options) {
+    const isEnabled = config.features[feature];
+    return isEnabled ? options.fn(this) : options.inverse(this);
+  });
+  handlebars.registerHelper("pascalCase", (text) => {
+    return text.replace(/[-_\s]+(.)?/g, (_, c) => c ? c.toUpperCase() : "").replace(/^(.)/, (_, c) => c.toUpperCase());
+  });
+  handlebars.registerHelper("camelCase", (text) => {
+    return text.replace(/[-_\s]+(.)?/g, (_, c) => c ? c.toUpperCase() : "").replace(/^(.)/, (_, c) => c.toLowerCase());
+  });
+  handlebars.registerHelper("kebabCase", (text) => {
+    return text.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[\s_]+/g, "-").toLowerCase();
+  });
+}
+
+// src/core/actions.ts
+import fs3 from "fs";
+import path3 from "path";
+import Handlebars from "handlebars";
+
+// src/utils/string.ts
+function toPascalCase(str) {
+  return str.replace(/[-_\s]+(.)?/g, (_, c) => c ? c.toUpperCase() : "").replace(/^(.)/, (_, c) => c.toUpperCase());
+}
+function toKebabCase(str) {
+  return str.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[\s_]+/g, "-").toLowerCase();
+}
+function toConstantCase(str) {
+  return str.replace(/([a-z])([A-Z])/g, "$1_$2").replace(/[\s-]+/g, "_").toUpperCase();
+}
+
+// src/utils/fs.ts
+import fs2 from "fs";
+import path2 from "path";
+function dirExists(dirPath) {
+  const resolved = path2.resolve(process.cwd(), dirPath);
+  return fs2.existsSync(resolved) && fs2.statSync(resolved).isDirectory();
+}
+function getDirectories(dirPath) {
+  const resolved = path2.resolve(process.cwd(), dirPath);
+  if (!fs2.existsSync(resolved)) return [];
+  return fs2.readdirSync(resolved, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
+}
+function ensureDirectoryExists(filePath) {
+  const dir = path2.dirname(filePath);
+  if (!fs2.existsSync(dir)) {
+    fs2.mkdirSync(dir, { recursive: true });
+  }
+}
+
+// src/core/actions.ts
+function barrelAppend(barrelRelativePath, exportLine, config, data) {
+  if (!config.features.barrel) {
+    return { type: "skipped", path: barrelRelativePath, message: "Barrel updates disabled" };
+  }
+  const handlebars = Handlebars.create();
+  handlebars.registerHelper(
+    "kebabCase",
+    (text) => text.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[\s_]+/g, "-").toLowerCase()
+  );
+  handlebars.registerHelper(
+    "pascalCase",
+    (text) => text.replace(/[-_\s]+(.)?/g, (_, c) => c ? c.toUpperCase() : "").replace(/^(.)/, (_, c) => c.toUpperCase())
+  );
+  handlebars.registerHelper(
+    "camelCase",
+    (text) => text.replace(/[-_\s]+(.)?/g, (_, c) => c ? c.toUpperCase() : "").replace(/^(.)/, (_, c) => c.toLowerCase())
+  );
+  const renderedPath = handlebars.compile(barrelRelativePath)(data);
+  const barrelPath = path3.resolve(process.cwd(), config.srcDir, renderedPath);
+  const renderedExport = handlebars.compile(exportLine)(data);
+  ensureDirectoryExists(barrelPath);
+  let content = "";
+  if (fs3.existsSync(barrelPath)) {
+    content = fs3.readFileSync(barrelPath, "utf-8");
+  }
+  if (content.includes(renderedExport)) {
+    return { type: "skipped", path: barrelPath, message: "Export already exists" };
+  }
+  const trimmedContent = content.trimEnd();
+  const newContent = trimmedContent ? `${trimmedContent}
+${renderedExport}
+` : `${renderedExport}
+`;
+  fs3.writeFileSync(barrelPath, newContent, "utf-8");
+  return { type: "updated", path: barrelPath, message: `Updated barrel: ${renderedPath}` };
+}
+function routeRegister(config, data) {
+  const results = [];
+  const routerFilePath = path3.resolve(process.cwd(), config.srcDir, config.router.routerFile);
+  const routesFilePath = path3.resolve(process.cwd(), config.srcDir, config.router.routesFile);
+  if (!fs3.existsSync(routerFilePath)) {
+    return [{ type: "failed", path: routerFilePath, message: "Router file not found" }];
+  }
+  if (!fs3.existsSync(routesFilePath)) {
+    return [{ type: "failed", path: routesFilePath, message: "Routes file not found" }];
+  }
+  const pascalName = toPascalCase(data.pageName);
+  const kebabCategory = toKebabCase(data.category);
+  const constantCategory = toConstantCase(data.category);
+  const constantPage = toConstantCase(data.pageName);
+  const pageSuffix = config.naming.pageSuffix;
+  const pagesAlias = config.aliases.pages;
+  let routerContent = fs3.readFileSync(routerFilePath, "utf-8");
+  const lazyImportLine = `const ${pascalName}${pageSuffix} = lazy(() => import('${pagesAlias}/${kebabCategory}/${pascalName}${pageSuffix}'));`;
+  if (!routerContent.includes(lazyImportLine)) {
+    const lazyImportRegex = /^const \w+ = lazy\(\(\) => import\([^)]+\)\);$/gm;
+    let lastMatch = null;
+    let match;
+    while ((match = lazyImportRegex.exec(routerContent)) !== null) {
+      lastMatch = match;
+    }
+    if (lastMatch) {
+      const insertPos = lastMatch.index + lastMatch[0].length;
+      routerContent = routerContent.slice(0, insertPos) + "\n" + lazyImportLine + routerContent.slice(insertPos);
+      fs3.writeFileSync(routerFilePath, routerContent, "utf-8");
+      results.push({ type: "updated", path: routerFilePath, message: `Added lazy import for ${pascalName}${pageSuffix}` });
+    } else {
+      results.push({
+        type: "failed",
+        path: routerFilePath,
+        message: `Could not find lazy import insertion point. Add manually:
+  ${lazyImportLine}`
+      });
+    }
+  } else {
+    results.push({ type: "skipped", path: routerFilePath, message: "Lazy import already exists" });
+  }
+  let routesContent = fs3.readFileSync(routesFilePath, "utf-8");
+  const routeConstant = `    ${constantPage}: '${data.routePath}',`;
+  const categoryRegex = new RegExp(`${constantCategory}:\\s*\\{([^}]*)\\}`, "s");
+  const categoryMatch = categoryRegex.exec(routesContent);
+  if (categoryMatch) {
+    if (!routesContent.includes(routeConstant)) {
+      const closingBrace = routesContent.indexOf("}", categoryMatch.index + categoryMatch[0].indexOf("{"));
+      routesContent = routesContent.slice(0, closingBrace) + routeConstant + "\n  " + routesContent.slice(closingBrace);
+      fs3.writeFileSync(routesFilePath, routesContent, "utf-8");
+      results.push({ type: "updated", path: routesFilePath, message: `Added route constant ${constantCategory}.${constantPage}` });
+    } else {
+      results.push({ type: "skipped", path: routesFilePath, message: "Route constant already exists" });
+    }
+  } else {
+    const newSection = `  ${constantCategory}: {
+  ${routeConstant}
+  },`;
+    const fullRoutesEnd = routesContent.lastIndexOf("} as const");
+    if (fullRoutesEnd !== -1) {
+      routesContent = routesContent.slice(0, fullRoutesEnd) + newSection + "\n" + routesContent.slice(fullRoutesEnd);
+      fs3.writeFileSync(routesFilePath, routesContent, "utf-8");
+      results.push({ type: "updated", path: routesFilePath, message: `Added new route category ${constantCategory}` });
+    } else {
+      results.push({
+        type: "failed",
+        path: routesFilePath,
+        message: `Could not find FULL_ROUTES_PATH. Add manually:
+  ${constantCategory}: { ${constantPage}: '${data.routePath}' }`
+      });
+    }
+  }
+  return results;
+}
+
+// src/core/template-resolver.ts
+import fs4 from "fs";
+import path4 from "path";
+import { fileURLToPath } from "url";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path4.dirname(__filename);
+var BUNDLED_TEMPLATES_DIR = path4.resolve(__dirname, "../../templates");
+function resolveTemplatePath(templateRelative, config) {
+  if (config.templatesDir) {
+    const localPath = path4.resolve(process.cwd(), config.templatesDir, templateRelative);
+    if (fs4.existsSync(localPath)) return localPath;
+  }
+  const bundledPath = path4.resolve(BUNDLED_TEMPLATES_DIR, templateRelative);
+  if (fs4.existsSync(bundledPath)) return bundledPath;
+  throw new Error(
+    `Template not found: ${templateRelative}
+Searched:
+` + (config.templatesDir ? `  - ${path4.resolve(process.cwd(), config.templatesDir, templateRelative)}
+` : "") + `  - ${bundledPath}`
+  );
+}
+
+// src/core/engine.ts
+var handlebarsInstance = null;
+function getHandlebars(config) {
+  if (!handlebarsInstance) {
+    handlebarsInstance = Handlebars2.create();
+    registerHelpers(handlebarsInstance, config);
+  }
+  return handlebarsInstance;
+}
+function resetHandlebars() {
+  handlebarsInstance = null;
+}
+function renderString(template, data, config) {
+  const hbs = getHandlebars(config);
+  return hbs.compile(template)(data);
+}
+async function executeActions(actions, answers, config) {
+  const results = [];
+  const hbs = getHandlebars(config);
+  for (const action of actions) {
+    switch (action.type) {
+      case "add": {
+        try {
+          const mergedData = { ...answers, ...action.data ?? {}, config };
+          const resolvedPath = renderString(action.path, mergedData, config);
+          const outputPath = path5.resolve(process.cwd(), config.srcDir, resolvedPath);
+          const templatePath = resolveTemplatePath(action.templateFile, config);
+          const templateContent = fs5.readFileSync(templatePath, "utf-8");
+          const compiled = hbs.compile(templateContent);
+          const rendered = compiled(mergedData);
+          ensureDirectoryExists(outputPath);
+          if (fs5.existsSync(outputPath)) {
+            results.push({
+              type: "skipped",
+              path: outputPath,
+              message: "File already exists"
+            });
+          } else {
+            fs5.writeFileSync(outputPath, rendered, "utf-8");
+            results.push({
+              type: "created",
+              path: outputPath,
+              message: `Created ${resolvedPath}`
+            });
+          }
+        } catch (error) {
+          results.push({
+            type: "failed",
+            path: action.path,
+            message: error instanceof Error ? error.message : String(error)
+          });
+        }
+        break;
+      }
+      case "barrel-append": {
+        const mergedData = { ...answers, config };
+        const result = barrelAppend(action.path, action.exportLine, config, mergedData);
+        results.push(result);
+        break;
+      }
+      case "route-register": {
+        const routeResults = routeRegister(config, action.data);
+        results.push(...routeResults);
+        break;
+      }
+    }
+  }
+  return results;
+}
+
+// src/utils/validation.ts
+function validateName(value) {
+  if (!value || value.trim() === "") return "Name is required";
+  if (/[^a-zA-Z0-9-]/.test(value)) return "Name must be alphanumeric (hyphens allowed)";
+  return true;
+}
+
+// src/generators/component-ui.ts
+function componentUiPrompts() {
+  return [
+    {
+      type: "input",
+      name: "name",
+      message: "Component name (e.g., StatusIndicator):",
+      validate: validateName
+    }
+  ];
+}
+function componentUiActions(_answers, config) {
+  const basePath = config.paths.uiComponents;
+  return [
+    {
+      type: "add",
+      path: `${basePath}/{{kebabCase name}}/{{pascalCase name}}.tsx`,
+      templateFile: "component-ui/Component.tsx.hbs"
+    },
+    {
+      type: "add",
+      path: `${basePath}/{{kebabCase name}}/index.ts`,
+      templateFile: "component-ui/index.ts.hbs"
+    },
+    {
+      type: "barrel-append",
+      path: `${basePath}/index.ts`,
+      exportLine: "export * from './{{kebabCase name}}';"
+    }
+  ];
+}
+
+// src/generators/component-shared.ts
+function componentSharedPrompts() {
+  return [
+    {
+      type: "input",
+      name: "name",
+      message: "Component name (e.g., InfoCard):",
+      validate: validateName
+    },
+    {
+      type: "input",
+      name: "subComponentsRaw",
+      message: "Sub-component names (comma-separated, e.g., Header,Body,Footer):",
+      default: "Header,Body,Footer"
+    }
+  ];
+}
+function preprocessComponentSharedAnswers(answers) {
+  return {
+    ...answers,
+    subComponents: answers.subComponentsRaw.split(",").map((s) => s.trim()).filter(Boolean)
+  };
+}
+function componentSharedActions(_answers, config) {
+  const basePath = config.paths.sharedComponents;
+  return [
+    {
+      type: "add",
+      path: `${basePath}/{{kebabCase name}}/{{pascalCase name}}.tsx`,
+      templateFile: "component-shared/Component.tsx.hbs"
+    },
+    {
+      type: "add",
+      path: `${basePath}/{{kebabCase name}}/index.ts`,
+      templateFile: "component-shared/index.ts.hbs"
+    },
+    {
+      type: "barrel-append",
+      path: `${basePath}/index.ts`,
+      exportLine: "export * from './{{kebabCase name}}';"
+    }
+  ];
+}
+
+// src/generators/component-form.ts
+function componentFormPrompts() {
+  return [
+    {
+      type: "input",
+      name: "name",
+      message: "Field name (e.g., DateRange, Slider):",
+      validate: validateName
+    }
+  ];
+}
+function componentFormActions(_answers, config) {
+  const basePath = config.paths.formComponents;
+  return [
+    {
+      type: "add",
+      path: `${basePath}/form-{{kebabCase name}}/Form{{pascalCase name}}.tsx`,
+      templateFile: "component-form/FormComponent.tsx.hbs"
+    },
+    {
+      type: "add",
+      path: `${basePath}/form-{{kebabCase name}}/index.ts`,
+      templateFile: "component-form/index.ts.hbs"
+    },
+    {
+      type: "barrel-append",
+      path: `${basePath}/index.ts`,
+      exportLine: "export * from './form-{{kebabCase name}}';"
+    }
+  ];
+}
+
+// src/generators/page.ts
+function pagePrompts(config) {
+  const prompts = [
+    {
+      type: "input",
+      name: "name",
+      message: "Page name (e.g., Communities, EventDetails):",
+      validate: validateName
+    },
+    {
+      type: "list",
+      name: "category",
+      message: "Page category (folder):",
+      choices: () => {
+        const dirs = getDirectories(`${config.srcDir}/${config.paths.pages}`);
+        return [...dirs, "\u2500\u2500 Create new category \u2500\u2500"];
+      }
+    },
+    {
+      type: "input",
+      name: "newCategory",
+      message: "New category name (kebab-case):",
+      when: (answers) => answers.category === "\u2500\u2500 Create new category \u2500\u2500",
+      validate: validateName
+    }
+  ];
+  if (config.features.routeRegistration) {
+    prompts.push(
+      {
+        type: "confirm",
+        name: "registerRoute",
+        message: "Auto-register route in router?",
+        default: true
+      },
+      {
+        type: "list",
+        name: "layout",
+        message: "Which layout?",
+        choices: () => config.router.layouts,
+        when: (answers) => !!answers.registerRoute
+      },
+      {
+        type: "confirm",
+        name: "isProtected",
+        message: "Is this a protected route (requires auth)?",
+        default: true,
+        when: (answers) => !!answers.registerRoute
+      },
+      {
+        type: "input",
+        name: "routePath",
+        message: "Route path (e.g., communities, events/details):",
+        when: (answers) => !!answers.registerRoute,
+        validate: validateName
+      }
+    );
+  }
+  return prompts;
+}
+function preprocessPageAnswers(answers) {
+  if (answers.newCategory) {
+    return { ...answers, category: answers.newCategory };
+  }
+  return answers;
+}
+function pageActions(answers, config) {
+  const basePath = config.paths.pages;
+  const pageSuffix = config.naming.pageSuffix;
+  const actions = [
+    {
+      type: "add",
+      path: `${basePath}/{{kebabCase category}}/{{pascalCase name}}${pageSuffix}.tsx`,
+      templateFile: "page/Page.tsx.hbs",
+      data: { pageSuffix }
+    }
+  ];
+  if (config.features.routeRegistration && answers.registerRoute) {
+    actions.push({
+      type: "route-register",
+      data: {
+        pageName: answers.name,
+        category: answers.category,
+        layout: answers.layout ?? config.router.layouts[0],
+        isProtected: answers.isProtected ?? true,
+        routePath: answers.routePath ?? answers.name.toLowerCase()
+      }
+    });
+  }
+  return actions;
+}
+
+// src/generators/view.ts
+function viewPrompts(config) {
+  return [
+    {
+      type: "list",
+      name: "feature",
+      message: "Feature (parent folder):",
+      choices: () => {
+        const dirs = getDirectories(`${config.srcDir}/${config.paths.views}`);
+        return [...dirs, "\u2500\u2500 Create new feature \u2500\u2500"];
+      }
+    },
+    {
+      type: "input",
+      name: "newFeature",
+      message: "New feature name (kebab-case):",
+      when: (answers) => answers.feature === "\u2500\u2500 Create new feature \u2500\u2500",
+      validate: validateName
+    },
+    {
+      type: "input",
+      name: "name",
+      message: "View component name (e.g., CommunityCard):",
+      validate: validateName
+    }
+  ];
+}
+function preprocessViewAnswers(answers) {
+  if (answers.newFeature) {
+    return { ...answers, feature: answers.newFeature };
+  }
+  return answers;
+}
+function viewActions(answers, config) {
+  const basePath = config.paths.views;
+  const isNewFeature = !!answers.newFeature;
+  const actions = [
+    {
+      type: "add",
+      path: `${basePath}/{{kebabCase feature}}/{{kebabCase name}}/{{pascalCase name}}.tsx`,
+      templateFile: "view/View.tsx.hbs"
+    },
+    {
+      type: "add",
+      path: `${basePath}/{{kebabCase feature}}/{{kebabCase name}}/index.ts`,
+      templateFile: "view/index.ts.hbs"
+    },
+    {
+      type: "barrel-append",
+      path: `${basePath}/{{kebabCase feature}}/index.ts`,
+      exportLine: "export * from './{{kebabCase name}}';"
+    }
+  ];
+  if (isNewFeature || !dirExists(`${config.srcDir}/${config.paths.views}/${answers.feature}`)) {
+    actions.push({
+      type: "barrel-append",
+      path: `${basePath}/index.ts`,
+      exportLine: "export * from './{{kebabCase feature}}';"
+    });
+  }
+  return actions;
+}
+
+// src/generators/handler.ts
+function handlerPrompts() {
+  return [
+    {
+      type: "input",
+      name: "name",
+      message: "Entity name (e.g., products):",
+      validate: validateName
+    },
+    {
+      type: "input",
+      name: "singularName",
+      message: "Singular entity name for mutations (e.g., product):",
+      validate: validateName
+    },
+    {
+      type: "input",
+      name: "endpointKey",
+      message: "ApiEndpoints key (e.g., PRODUCTS):"
+    },
+    {
+      type: "checkbox",
+      name: "operations",
+      message: "Which operations?",
+      choices: [
+        { name: "list", value: "list", checked: true },
+        { name: "details", value: "details", checked: true },
+        { name: "create", value: "create" },
+        { name: "update", value: "update" },
+        { name: "delete", value: "delete" }
+      ]
+    },
+    {
+      type: "confirm",
+      name: "chainTypes",
+      message: "Also generate DTO types?",
+      default: true
+    },
+    {
+      type: "confirm",
+      name: "chainQueryHook",
+      message: "Also generate query hook(s)?",
+      default: true
+    },
+    {
+      type: "confirm",
+      name: "isPaginated",
+      message: "Is the list endpoint paginated?",
+      default: false,
+      when: (answers) => {
+        const ops = answers.operations;
+        return !!answers.chainQueryHook && ops?.includes("list");
+      }
+    },
+    {
+      type: "confirm",
+      name: "chainMutationHook",
+      message: "Also generate mutation hook(s)?",
+      default: true
+    }
+  ];
+}
+function handlerActions(answers, config) {
+  const operations = answers.operations || [];
+  const entityName = answers.name;
+  const singularName = answers.singularName;
+  const pascalSingular = toPascalCase(singularName);
+  const actions = [
+    {
+      type: "add",
+      path: `${config.paths.handlers}/{{camelCase name}}.ts`,
+      templateFile: "handler/handler.ts.hbs",
+      data: { operations }
+    },
+    {
+      type: "barrel-append",
+      path: `${config.paths.handlers}/index.ts`,
+      exportLine: "export * from './{{camelCase name}}';"
+    }
+  ];
+  if (answers.chainTypes) {
+    actions.push(
+      {
+        type: "add",
+        path: `${config.paths.types}/{{pascalCase name}}Dto.ts`,
+        templateFile: "types-dto/dto.ts.hbs",
+        data: {
+          includeCreateDto: operations.includes("create"),
+          includeUpdateDto: operations.includes("update"),
+          includeParamsDto: true
+        }
+      },
+      {
+        type: "barrel-append",
+        path: `${config.paths.types}/index.ts`,
+        exportLine: "export * from './{{pascalCase name}}Dto';"
+      }
+    );
+  }
+  if (answers.chainQueryHook && operations.includes("list")) {
+    if (answers.isPaginated) {
+      actions.push(
+        {
+          type: "add",
+          path: `${config.paths.queries}/use{{pascalCase name}}PaginatedQuery.ts`,
+          templateFile: "query-hook/hook-paginated.ts.hbs",
+          data: { hookName: `${entityName}Paginated`, handlerName: entityName, handlerKey: "list" }
+        },
+        {
+          type: "barrel-append",
+          path: `${config.paths.queries}/index.ts`,
+          exportLine: "export * from './use{{pascalCase name}}PaginatedQuery';"
+        }
+      );
+    } else {
+      actions.push(
+        {
+          type: "add",
+          path: `${config.paths.queries}/use{{pascalCase name}}ListQuery.ts`,
+          templateFile: "query-hook/hook.ts.hbs",
+          data: { hookName: `${entityName}List`, handlerName: entityName, handlerKey: "list" }
+        },
+        {
+          type: "barrel-append",
+          path: `${config.paths.queries}/index.ts`,
+          exportLine: "export * from './use{{pascalCase name}}ListQuery';"
+        }
+      );
+    }
+  }
+  if (answers.chainQueryHook && operations.includes("details")) {
+    actions.push(
+      {
+        type: "add",
+        path: `${config.paths.queries}/use{{pascalCase name}}DetailsQuery.ts`,
+        templateFile: "query-hook/hook-details.ts.hbs",
+        data: { hookName: `${entityName}Details`, handlerName: entityName, handlerKey: "details" }
+      },
+      {
+        type: "barrel-append",
+        path: `${config.paths.queries}/index.ts`,
+        exportLine: "export * from './use{{pascalCase name}}DetailsQuery';"
+      }
+    );
+  }
+  if (answers.chainMutationHook && operations.includes("create")) {
+    actions.push(
+      {
+        type: "add",
+        path: `${config.paths.mutations}/useCreate${pascalSingular}Mutation.ts`,
+        templateFile: "mutation-hook/hook.ts.hbs",
+        data: { handlerName: entityName, handlerKey: "create", invalidateKey: "list", mutationName: `Create${pascalSingular}` }
+      },
+      {
+        type: "barrel-append",
+        path: `${config.paths.mutations}/index.ts`,
+        exportLine: `export * from './useCreate${pascalSingular}Mutation';`
+      }
+    );
+  }
+  if (answers.chainMutationHook && operations.includes("update")) {
+    actions.push(
+      {
+        type: "add",
+        path: `${config.paths.mutations}/useUpdate${pascalSingular}Mutation.ts`,
+        templateFile: "mutation-hook/hook.ts.hbs",
+        data: { handlerName: entityName, handlerKey: "update", invalidateKey: "list", mutationName: `Update${pascalSingular}` }
+      },
+      {
+        type: "barrel-append",
+        path: `${config.paths.mutations}/index.ts`,
+        exportLine: `export * from './useUpdate${pascalSingular}Mutation';`
+      }
+    );
+  }
+  if (answers.chainMutationHook && operations.includes("delete")) {
+    actions.push(
+      {
+        type: "add",
+        path: `${config.paths.mutations}/useDelete${pascalSingular}Mutation.ts`,
+        templateFile: "mutation-hook/hook.ts.hbs",
+        data: { handlerName: entityName, handlerKey: "remove", invalidateKey: "list", mutationName: `Delete${pascalSingular}` }
+      },
+      {
+        type: "barrel-append",
+        path: `${config.paths.mutations}/index.ts`,
+        exportLine: `export * from './useDelete${pascalSingular}Mutation';`
+      }
+    );
+  }
+  return actions;
+}
+
+// src/generators/query-hook.ts
+function queryHookPrompts() {
+  return [
+    {
+      type: "input",
+      name: "name",
+      message: "Hook name suffix (e.g., CommunityList, ProductDetails):",
+      validate: validateName
+    },
+    {
+      type: "input",
+      name: "handlerName",
+      message: "Handler name to import (e.g., Community):",
+      validate: validateName
+    },
+    {
+      type: "input",
+      name: "handlerKey",
+      message: "Handler key (e.g., list, details):",
+      default: "list"
+    },
+    {
+      type: "confirm",
+      name: "isDetailsQuery",
+      message: "Is this a details/by-id query (takes an id parameter)?",
+      default: false
+    },
+    {
+      type: "confirm",
+      name: "isPaginated",
+      message: "Is this a paginated list query?",
+      default: false,
+      when: (answers) => !answers.isDetailsQuery
+    }
+  ];
+}
+function queryHookActions(answers, config) {
+  let templateFile;
+  if (answers.isDetailsQuery) {
+    templateFile = "query-hook/hook-details.ts.hbs";
+  } else if (answers.isPaginated) {
+    templateFile = "query-hook/hook-paginated.ts.hbs";
+  } else {
+    templateFile = "query-hook/hook.ts.hbs";
+  }
+  return [
+    {
+      type: "add",
+      path: `${config.paths.queries}/use{{pascalCase name}}Query.ts`,
+      templateFile,
+      data: { hookName: answers.name }
+    },
+    {
+      type: "barrel-append",
+      path: `${config.paths.queries}/index.ts`,
+      exportLine: "export * from './use{{pascalCase name}}Query';"
+    }
+  ];
+}
+
+// src/generators/mutation-hook.ts
+function mutationHookPrompts() {
+  return [
+    {
+      type: "input",
+      name: "mutationName",
+      message: "Mutation name (e.g., CreateCommunity, UpdateUser):",
+      validate: validateName
+    },
+    {
+      type: "input",
+      name: "handlerName",
+      message: "Handler name to import (e.g., Community):",
+      validate: validateName
+    },
+    {
+      type: "input",
+      name: "handlerKey",
+      message: "Handler mutation key (e.g., create, update, remove):",
+      default: "create"
+    },
+    {
+      type: "input",
+      name: "invalidateKey",
+      message: "Handler query key to invalidate on success (e.g., list):",
+      default: "list"
+    }
+  ];
+}
+function mutationHookActions(_answers, config) {
+  return [
+    {
+      type: "add",
+      path: `${config.paths.mutations}/use{{pascalCase mutationName}}Mutation.ts`,
+      templateFile: "mutation-hook/hook.ts.hbs"
+    },
+    {
+      type: "barrel-append",
+      path: `${config.paths.mutations}/index.ts`,
+      exportLine: "export * from './use{{pascalCase mutationName}}Mutation';"
+    }
+  ];
+}
+
+// src/generators/types-dto.ts
+function typesDtoPrompts() {
+  return [
+    {
+      type: "input",
+      name: "name",
+      message: "Entity name (e.g., Community, Event):",
+      validate: validateName
+    },
+    {
+      type: "confirm",
+      name: "includeCreateDto",
+      message: "Include ForCreateDto?",
+      default: true
+    },
+    {
+      type: "confirm",
+      name: "includeUpdateDto",
+      message: "Include ForUpdateDto?",
+      default: true
+    },
+    {
+      type: "confirm",
+      name: "includeParamsDto",
+      message: "Include ParamsDto?",
+      default: true
+    }
+  ];
+}
+function typesDtoActions(_answers, config) {
+  return [
+    {
+      type: "add",
+      path: `${config.paths.types}/{{pascalCase name}}Dto.ts`,
+      templateFile: "types-dto/dto.ts.hbs"
+    },
+    {
+      type: "barrel-append",
+      path: `${config.paths.types}/index.ts`,
+      exportLine: "export * from './{{pascalCase name}}Dto';"
+    }
+  ];
+}
+
+// src/generators/shared-hook.ts
+function sharedHookPrompts() {
+  return [
+    {
+      type: "input",
+      name: "name",
+      message: "Hook name (e.g., WindowSize, Clipboard):",
+      validate: validateName
+    },
+    {
+      type: "checkbox",
+      name: "reactImports",
+      message: "Which React imports?",
+      choices: [
+        { name: "useState", value: "useState", checked: true },
+        { name: "useEffect", value: "useEffect", checked: true },
+        { name: "useCallback", value: "useCallback" },
+        { name: "useMemo", value: "useMemo" },
+        { name: "useRef", value: "useRef" }
+      ]
+    }
+  ];
+}
+function sharedHookActions(_answers, config) {
+  return [
+    {
+      type: "add",
+      path: `${config.paths.sharedHooks}/use{{pascalCase name}}.ts`,
+      templateFile: "shared-hook/hook.ts.hbs"
+    },
+    {
+      type: "barrel-append",
+      path: `${config.paths.sharedHooks}/index.ts`,
+      exportLine: "export * from './use{{pascalCase name}}';"
+    }
+  ];
+}
+
+// src/generators/validation.ts
+function validationPrompts() {
+  return [
+    {
+      type: "input",
+      name: "name",
+      message: "Schema name (e.g., communitySettings, eventCreate):",
+      validate: validateName
+    }
+  ];
+}
+function validationActions(_answers, config) {
+  const suffix = config.naming.validationSuffix;
+  const fileExt = suffix;
+  const barrelExt = suffix.replace(/\.ts$/, "");
+  return [
+    {
+      type: "add",
+      path: `${config.paths.validations}/{{camelCase name}}${fileExt}`,
+      templateFile: "validation/validation.ts.hbs"
+    },
+    {
+      type: "barrel-append",
+      path: `${config.paths.validations}/index.ts`,
+      exportLine: `export * from './{{camelCase name}}${barrelExt}';`
+    }
+  ];
+}
+
+// src/generators/feature.ts
+function featurePrompts() {
+  return [
+    {
+      type: "input",
+      name: "name",
+      message: "Feature/entity name (e.g., products):",
+      validate: validateName
+    },
+    {
+      type: "input",
+      name: "singularName",
+      message: "Singular entity name for mutations (e.g., product):",
+      validate: validateName
+    },
+    {
+      type: "input",
+      name: "endpointKey",
+      message: "ApiEndpoints key (e.g., PRODUCTS):"
+    },
+    {
+      type: "checkbox",
+      name: "artifacts",
+      message: "Which artifacts to generate?",
+      choices: [
+        { name: "API Handler", value: "handler", checked: true },
+        { name: "DTO Types", value: "types", checked: true },
+        { name: "Query Hook (list)", value: "queryList", checked: true },
+        { name: "Query Hook (details)", value: "queryDetails", checked: true },
+        { name: "Mutation Hook (create)", value: "mutationCreate" },
+        { name: "Mutation Hook (update)", value: "mutationUpdate" },
+        { name: "Mutation Hook (delete)", value: "mutationDelete" },
+        { name: "View Component", value: "view" },
+        { name: "Page Component", value: "page" },
+        { name: "Validation Schema", value: "validation" }
+      ]
+    },
+    {
+      type: "confirm",
+      name: "isPaginated",
+      message: "Is the list endpoint paginated?",
+      default: false,
+      when: (answers) => {
+        return answers.artifacts?.includes("queryList");
+      }
+    }
+  ];
+}
+function featureActions(answers, config) {
+  const artifacts = answers.artifacts || [];
+  const actions = [];
+  const entityName = answers.name;
+  const singularName = answers.singularName;
+  const pascalSingular = toPascalCase(singularName);
+  const validationSuffix = config.naming.validationSuffix;
+  const validationBarrelExt = validationSuffix.replace(/\.ts$/, "");
+  if (artifacts.includes("types")) {
+    actions.push(
+      {
+        type: "add",
+        path: `${config.paths.types}/{{pascalCase name}}Dto.ts`,
+        templateFile: "types-dto/dto.ts.hbs",
+        data: {
+          includeCreateDto: artifacts.includes("mutationCreate"),
+          includeUpdateDto: artifacts.includes("mutationUpdate"),
+          includeParamsDto: true
+        }
+      },
+      {
+        type: "barrel-append",
+        path: `${config.paths.types}/index.ts`,
+        exportLine: "export * from './{{pascalCase name}}Dto';"
+      }
+    );
+  }
+  if (artifacts.includes("handler")) {
+    const operations = ["list", "details"];
+    if (artifacts.includes("mutationCreate")) operations.push("create");
+    if (artifacts.includes("mutationUpdate")) operations.push("update");
+    if (artifacts.includes("mutationDelete")) operations.push("delete");
+    actions.push(
+      {
+        type: "add",
+        path: `${config.paths.handlers}/{{camelCase name}}.ts`,
+        templateFile: "handler/handler.ts.hbs",
+        data: { operations, endpointKey: answers.endpointKey }
+      },
+      {
+        type: "barrel-append",
+        path: `${config.paths.handlers}/index.ts`,
+        exportLine: "export * from './{{camelCase name}}';"
+      }
+    );
+  }
+  if (artifacts.includes("queryList")) {
+    if (answers.isPaginated) {
+      actions.push(
+        {
+          type: "add",
+          path: `${config.paths.queries}/use{{pascalCase name}}PaginatedQuery.ts`,
+          templateFile: "query-hook/hook-paginated.ts.hbs",
+          data: { hookName: `${entityName}Paginated`, handlerName: entityName, handlerKey: "list" }
+        },
+        {
+          type: "barrel-append",
+          path: `${config.paths.queries}/index.ts`,
+          exportLine: "export * from './use{{pascalCase name}}PaginatedQuery';"
+        }
+      );
+    } else {
+      actions.push(
+        {
+          type: "add",
+          path: `${config.paths.queries}/use{{pascalCase name}}ListQuery.ts`,
+          templateFile: "query-hook/hook.ts.hbs",
+          data: { hookName: `${entityName}List`, handlerName: entityName, handlerKey: "list" }
+        },
+        {
+          type: "barrel-append",
+          path: `${config.paths.queries}/index.ts`,
+          exportLine: "export * from './use{{pascalCase name}}ListQuery';"
+        }
+      );
+    }
+  }
+  if (artifacts.includes("queryDetails")) {
+    actions.push(
+      {
+        type: "add",
+        path: `${config.paths.queries}/use{{pascalCase name}}DetailsQuery.ts`,
+        templateFile: "query-hook/hook-details.ts.hbs",
+        data: { hookName: `${entityName}Details`, handlerName: entityName, handlerKey: "details" }
+      },
+      {
+        type: "barrel-append",
+        path: `${config.paths.queries}/index.ts`,
+        exportLine: "export * from './use{{pascalCase name}}DetailsQuery';"
+      }
+    );
+  }
+  if (artifacts.includes("mutationCreate")) {
+    actions.push(
+      {
+        type: "add",
+        path: `${config.paths.mutations}/useCreate${pascalSingular}Mutation.ts`,
+        templateFile: "mutation-hook/hook.ts.hbs",
+        data: { handlerName: entityName, handlerKey: "create", invalidateKey: "list", mutationName: `Create${pascalSingular}` }
+      },
+      {
+        type: "barrel-append",
+        path: `${config.paths.mutations}/index.ts`,
+        exportLine: `export * from './useCreate${pascalSingular}Mutation';`
+      }
+    );
+  }
+  if (artifacts.includes("mutationUpdate")) {
+    actions.push(
+      {
+        type: "add",
+        path: `${config.paths.mutations}/useUpdate${pascalSingular}Mutation.ts`,
+        templateFile: "mutation-hook/hook.ts.hbs",
+        data: { handlerName: entityName, handlerKey: "update", invalidateKey: "list", mutationName: `Update${pascalSingular}` }
+      },
+      {
+        type: "barrel-append",
+        path: `${config.paths.mutations}/index.ts`,
+        exportLine: `export * from './useUpdate${pascalSingular}Mutation';`
+      }
+    );
+  }
+  if (artifacts.includes("mutationDelete")) {
+    actions.push(
+      {
+        type: "add",
+        path: `${config.paths.mutations}/useDelete${pascalSingular}Mutation.ts`,
+        templateFile: "mutation-hook/hook.ts.hbs",
+        data: { handlerName: entityName, handlerKey: "remove", invalidateKey: "list", mutationName: `Delete${pascalSingular}` }
+      },
+      {
+        type: "barrel-append",
+        path: `${config.paths.mutations}/index.ts`,
+        exportLine: `export * from './useDelete${pascalSingular}Mutation';`
+      }
+    );
+  }
+  if (artifacts.includes("view")) {
+    actions.push(
+      {
+        type: "add",
+        path: `${config.paths.views}/{{kebabCase name}}/{{kebabCase name}}-list/{{pascalCase name}}List.tsx`,
+        templateFile: "view/View.tsx.hbs",
+        data: { name: `${entityName}List` }
+      },
+      {
+        type: "add",
+        path: `${config.paths.views}/{{kebabCase name}}/{{kebabCase name}}-list/index.ts`,
+        templateFile: "view/index.ts.hbs",
+        data: { name: `${entityName}List` }
+      },
+      {
+        type: "barrel-append",
+        path: `${config.paths.views}/{{kebabCase name}}/index.ts`,
+        exportLine: "export * from './{{kebabCase name}}-list';"
+      },
+      {
+        type: "barrel-append",
+        path: `${config.paths.views}/index.ts`,
+        exportLine: "export * from './{{kebabCase name}}';"
+      }
+    );
+  }
+  if (artifacts.includes("page")) {
+    const pageSuffix = config.naming.pageSuffix;
+    actions.push({
+      type: "add",
+      path: `${config.paths.pages}/{{kebabCase name}}/{{pascalCase name}}${pageSuffix}.tsx`,
+      templateFile: "page/Page.tsx.hbs",
+      data: { pageSuffix }
+    });
+  }
+  if (artifacts.includes("validation")) {
+    actions.push(
+      {
+        type: "add",
+        path: `${config.paths.validations}/{{camelCase name}}${validationSuffix}`,
+        templateFile: "validation/validation.ts.hbs"
+      },
+      {
+        type: "barrel-append",
+        path: `${config.paths.validations}/index.ts`,
+        exportLine: `export * from './{{camelCase name}}${validationBarrelExt}';`
+      }
+    );
+  }
+  return actions;
+}
+
+// src/generators/index.ts
+function getGenerators(_config) {
+  return [
+    {
+      name: "component-ui",
+      description: "CVA-based UI component (shadcn/ui style)",
+      prompts: () => componentUiPrompts(),
+      actions: (answers, cfg) => componentUiActions(answers, cfg)
+    },
+    {
+      name: "component-shared",
+      description: "Compound shared component",
+      prompts: () => componentSharedPrompts(),
+      actions: (answers, cfg) => componentSharedActions(answers, cfg),
+      preprocess: (answers) => preprocessComponentSharedAnswers(answers)
+    },
+    {
+      name: "component-form",
+      description: "React Hook Form component (useController-based)",
+      prompts: () => componentFormPrompts(),
+      actions: (answers, cfg) => componentFormActions(answers, cfg)
+    },
+    {
+      name: "page",
+      description: "Route-level page component",
+      prompts: (cfg) => pagePrompts(cfg),
+      actions: (answers, cfg) => pageActions(answers, cfg),
+      preprocess: (answers) => preprocessPageAnswers(answers)
+    },
+    {
+      name: "view",
+      description: "Feature view component",
+      prompts: (cfg) => viewPrompts(cfg),
+      actions: (answers, cfg) => viewActions(answers, cfg),
+      preprocess: (answers) => preprocessViewAnswers(answers)
+    },
+    {
+      name: "handler",
+      description: "API handler (+ types + hooks)",
+      prompts: () => handlerPrompts(),
+      actions: (answers, cfg) => handlerActions(answers, cfg)
+    },
+    {
+      name: "query-hook",
+      description: "React Query hook",
+      prompts: () => queryHookPrompts(),
+      actions: (answers, cfg) => queryHookActions(answers, cfg)
+    },
+    {
+      name: "mutation-hook",
+      description: "React Query mutation hook",
+      prompts: () => mutationHookPrompts(),
+      actions: (answers, cfg) => mutationHookActions(answers, cfg)
+    },
+    {
+      name: "types-dto",
+      description: "DTO type definitions",
+      prompts: () => typesDtoPrompts(),
+      actions: (answers, cfg) => typesDtoActions(answers, cfg)
+    },
+    {
+      name: "shared-hook",
+      description: "Custom utility hook",
+      prompts: () => sharedHookPrompts(),
+      actions: (answers, cfg) => sharedHookActions(answers, cfg)
+    },
+    {
+      name: "validation",
+      description: "Zod validation schema",
+      prompts: () => validationPrompts(),
+      actions: (answers, cfg) => validationActions(answers, cfg)
+    },
+    {
+      name: "feature",
+      description: "Full feature scaffold (handler + types + hooks + view + page)",
+      prompts: () => featurePrompts(),
+      actions: (answers, cfg) => featureActions(answers, cfg)
+    }
+  ];
+}
+
+// src/commands/generate.ts
+async function runGenerate(generatorName) {
+  let config;
+  try {
+    config = await loadConfig();
+  } catch (error) {
+    console.error(
+      chalk.red("Error loading config:"),
+      error instanceof Error ? error.message : error
+    );
+    console.log(chalk.yellow('Run "rq-codegen init" to create a config file.'));
+    process.exit(1);
+  }
+  resetHandlebars();
+  const generators = getGenerators(config);
+  if (!generatorName) {
+    const choices = generators.map((g) => ({
+      name: `${g.name.padEnd(18)} ${chalk.dim("\u2014")} ${g.description}`,
+      value: g.name
+    }));
+    const { selected } = await inquirer.prompt([
+      {
+        type: "list",
+        name: "selected",
+        message: "What would you like to generate?",
+        choices
+      }
+    ]);
+    generatorName = selected;
+  }
+  const generator = generators.find((g) => g.name === generatorName);
+  if (!generator) {
+    console.error(chalk.red(`Unknown generator: ${generatorName}`));
+    console.log(
+      chalk.yellow("Available generators:"),
+      generators.map((g) => g.name).join(", ")
+    );
+    process.exit(1);
+  }
+  console.log(chalk.cyan(`
+  Running: ${generator.name}
+`));
+  const prompts = generator.prompts(config);
+  const answers = await inquirer.prompt(prompts);
+  const processedAnswers = generator.preprocess ? generator.preprocess(answers) : answers;
+  const actions = generator.actions(processedAnswers, config);
+  const results = await executeActions(actions, processedAnswers, config);
+  console.log("");
+  for (const result of results) {
+    switch (result.type) {
+      case "created":
+        console.log(chalk.green("  CREATED"), result.message);
+        break;
+      case "updated":
+        console.log(chalk.blue("  UPDATED"), result.message);
+        break;
+      case "skipped":
+        console.log(chalk.yellow("  SKIPPED"), result.message);
+        break;
+      case "failed":
+        console.error(chalk.red("  FAILED"), result.message);
+        break;
+    }
+  }
+  const created = results.filter((r) => r.type === "created").length;
+  const updated = results.filter((r) => r.type === "updated").length;
+  const failed = results.filter((r) => r.type === "failed").length;
+  console.log("");
+  if (failed > 0) {
+    console.log(chalk.red(`  ${failed} action(s) failed.`));
+  }
+  console.log(
+    chalk.green(`  Done! ${created} file(s) created, ${updated} barrel(s) updated.
+`)
+  );
+}
+
+// src/commands/init.ts
+import fs6 from "fs";
+import path6 from "path";
+import chalk2 from "chalk";
+import inquirer2 from "inquirer";
+async function runInit(options) {
+  const configPath = path6.resolve(process.cwd(), "rqgen.config.ts");
+  if (fs6.existsSync(configPath) && !options.force) {
+    console.error(
+      chalk2.red("Config file already exists: rqgen.config.ts")
+    );
+    console.log(chalk2.yellow("Use --force to overwrite."));
+    process.exit(1);
+  }
+  console.log(chalk2.cyan("\n  Initializing @appswave/rq-codegen config...\n"));
+  const detectedAliases = detectAliasesFromTsConfig(process.cwd());
+  const srcDirExists = fs6.existsSync(path6.resolve(process.cwd(), "src"));
+  const srcDir = srcDirExists ? "./src" : ".";
+  const hasRouter = fs6.existsSync(
+    path6.resolve(process.cwd(), srcDir, "routes/router.tsx")
+  );
+  const hasI18n = fs6.existsSync(path6.resolve(process.cwd(), srcDir, "locales")) || fs6.existsSync(path6.resolve(process.cwd(), "i18next.config.ts"));
+  const answers = await inquirer2.prompt([
+    {
+      type: "confirm",
+      name: "i18n",
+      message: "Does your project use i18n (i18next)?",
+      default: hasI18n
+    },
+    {
+      type: "confirm",
+      name: "toast",
+      message: "Does your project use toast notifications?",
+      default: true
+    },
+    {
+      type: "confirm",
+      name: "routeRegistration",
+      message: "Enable automatic route registration when generating pages?",
+      default: hasRouter
+    }
+  ]);
+  const aliasesStr = detectedAliases ? formatAliases(detectedAliases) : "    // Auto-detected from tsconfig.json \u2014 customize if needed";
+  const configContent = `import { defineConfig } from '@appswave/rq-codegen';
+
+export default defineConfig({
+  srcDir: '${srcDir}',
+
+  aliases: {
+${aliasesStr}
+  },
+
+  features: {
+    i18n: ${answers.i18n},
+    toast: ${answers.toast},
+    barrel: true,
+    routeRegistration: ${answers.routeRegistration},
+  },
+
+  naming: {
+    dtoSuffixes: {
+      read: 'ForReadDto',
+      create: 'ForCreateDto',
+      update: 'ForUpdateDto',
+      list: 'ListDto',
+      listResponse: 'ListResponseDto',
+      params: 'ParamsDto',
+    },
+    validationSuffix: '.schema.ts',
+    pageSuffix: 'Page',
+    hookPrefix: 'use',
+  },
+
+  paths: {
+    handlers: 'api/handlers',
+    apiConfig: 'api/config',
+    types: 'types/api',
+    queries: 'lib/hooks/queries',
+    mutations: 'lib/hooks/mutations',
+    sharedHooks: 'lib/hooks/shared',
+    hookUtils: 'lib/hooks/utils',
+    uiComponents: 'components/ui',
+    sharedComponents: 'components/shared',
+    formComponents: 'components/forms',
+    pages: 'pages',
+    views: 'views',
+    validations: 'validations',
+  },
+${answers.routeRegistration ? `
+  router: {
+    routerFile: 'routes/router.tsx',
+    routesFile: 'routes/routes.ts',
+    layouts: ['MainLayout', 'DashboardLayout'],
+  },
+` : ""}
+  hooks: {
+    toast: { import: 'useToast', from: '@hooks/shared' },
+    translation: { import: 'useAppTranslation', from: '@hooks/shared' },
+    paginatedQuery: { import: 'usePaginatedDataTableQuery', from: '@hooks/utils' },
+  },
+});
+`;
+  fs6.writeFileSync(configPath, configContent, "utf-8");
+  console.log(chalk2.green("  Created rqgen.config.ts"));
+  console.log(chalk2.dim("  Edit the config to customize paths, aliases, and features.\n"));
+}
+function formatAliases(aliases) {
+  const lines = [];
+  const keyMap = {
+    api: "api",
+    components: "components",
+    hooks: "hooks",
+    types: "types",
+    utils: "utils",
+    contexts: "contexts",
+    constants: "constants",
+    views: "views",
+    pages: "pages",
+    validations: "validations",
+    assets: "assets",
+    routes: "routes",
+    hoc: "hoc",
+    appConfig: "appConfig"
+  };
+  for (const [key, configKey] of Object.entries(keyMap)) {
+    const value = aliases[key];
+    if (value) {
+      lines.push(`    ${configKey}: '${value}',`);
+    }
+  }
+  return lines.length > 0 ? lines.join("\n") : "    // No aliases detected \u2014 add your path aliases here";
+}
+
+// src/cli.ts
+function createCli() {
+  const program2 = new Command();
+  program2.name("rq-codegen").description(
+    "Config-driven code generator for React + TypeScript + React Query projects"
+  ).version("0.1.0");
+  program2.command("init").description("Initialize rqgen.config.ts with auto-detected settings").option("--force", "Overwrite existing config file").action(runInit);
+  program2.argument("[generator]", "Generator to run (e.g., handler, page, feature)").action(runGenerate);
+  return program2;
+}
+
+// bin/cli.ts
+var program = createCli();
+program.parse(process.argv);
+//# sourceMappingURL=cli.js.map