@abuhannaa/create-apptemplate 1.0.12 → 1.1.1

package/dist/index.js

@@ -4,679 +4,13 @@
 import { intro, outro, isCancel as isCancel2 } from "@clack/prompts";
 import pc3 from "picocolors";
 
-// src/types.ts
-var ALL_FEATURES = [
-  "auth",
-  "userManagement",
-  "departments",
-  "fileUpload",
-  "auditLogs",
-  "notifications",
-  "dataExport",
-  "dashboard"
-];
-
-// src/features.ts
-var FEATURE_OPTIONS = [
-  {
-    value: "auth",
-    label: "Authentication (Login, JWT, Guards)",
-    hint: "Login/logout pages, JWT middleware, auth guards, profile"
-  },
-  {
-    value: "userManagement",
-    label: "User Management",
-    hint: "User CRUD, roles, permissions"
-  },
-  {
-    value: "departments",
-    label: "Departments",
-    hint: "Department CRUD module"
-  },
-  {
-    value: "fileUpload",
-    label: "File Management",
-    hint: "File upload, download, preview"
-  },
-  {
-    value: "auditLogs",
-    label: "Audit Logging",
-    hint: "Track all data changes with audit trail"
-  },
-  {
-    value: "notifications",
-    label: "Notifications",
-    hint: "Real-time notification system (WebSocket)"
-  },
-  {
-    value: "dataExport",
-    label: "Data Export",
-    hint: "CSV, Excel, PDF export"
-  },
-  {
-    value: "dashboard",
-    label: "Dashboard",
-    hint: "Dashboard page with statistics (Requires Users, Depts, Notifications)"
-  }
-];
-function applyFeatureDependencies(selected) {
-  let result = [...selected];
-  if (!result.includes("auth")) {
-    result = result.filter((f) => f !== "userManagement" && f !== "departments");
-  }
-  if (!result.includes("userManagement")) {
-    result = result.filter((f) => f !== "departments");
-  }
-  if (!result.includes("userManagement") || !result.includes("departments") || !result.includes("notifications")) {
-    result = result.filter((f) => f !== "dashboard");
-  }
-  if (!result.includes("userManagement") || !result.includes("departments")) {
-    result = result.filter((f) => f !== "dataExport");
-  }
-  return result;
-}
-var DOTNET_CLEAN_MAP = {
-  auth: {
-    backend: [
-      // Application layer
-      "src/Core/App.Template.Application/Features/Authentication",
-      "src/Core/App.Template.Application/DTOs/Auth",
-      "src/Core/App.Template.Application/Interfaces/IJwtTokenService.cs",
-      "src/Core/App.Template.Application/Interfaces/IPasswordHashService.cs",
-      "src/Core/App.Template.Application/Interfaces/ISsoAuthService.cs",
-      "src/Core/App.Template.Application/Interfaces/IEmailService.cs",
-      // Infrastructure layer
-      "src/Infrastructure/App.Template.Infrastructure/Services/JwtTokenService.cs",
-      "src/Infrastructure/App.Template.Infrastructure/Services/PasswordHashService.cs",
-      "src/Infrastructure/App.Template.Infrastructure/Services/SsoAuthService.cs",
-      "src/Infrastructure/App.Template.Infrastructure/Services/SsoApiModels.cs",
-      "src/Infrastructure/App.Template.Infrastructure/Services/EmailService.cs",
-      // Presentation layer
-      "src/Presentation/App.Template.WebAPI/Controllers/AuthController.cs",
-      "src/Core/App.Template.Application/DTOs/UserDto.cs"
-      // Required by Auth
-    ],
-    frontend: []
-    // Frontend auth files handled by pattern below
-  },
-  userManagement: {
-    backend: [
-      "src/Core/App.Template.Application/Features/UserManagement",
-      // 'src/Core/App.Template.Application/DTOs/UserDto.cs', // Moved to auth
-      "src/Presentation/App.Template.WebAPI/Controllers/UsersController.cs"
-    ],
-    frontend: []
-  },
-  departments: {
-    backend: [
-      "src/Core/App.Template.Application/Features/DepartmentManagement",
-      "src/Core/App.Template.Application/DTOs/DepartmentDto.cs",
-      "src/Core/App.Template.Application/Interfaces/IOrganizationService.cs",
-      "src/Infrastructure/App.Template.Infrastructure/Services/OrganizationService.cs",
-      "src/Presentation/App.Template.WebAPI/Controllers/DepartmentsController.cs"
-    ],
-    frontend: []
-  },
-  fileUpload: {
-    backend: [
-      "src/Core/App.Template.Application/Features/FileManagement",
-      "src/Core/App.Template.Application/DTOs/UploadedFileDto.cs",
-      "src/Core/App.Template.Application/Interfaces/IFileStorageService.cs",
-      "src/Infrastructure/App.Template.Infrastructure/Services/FileStorageService.cs",
-      "src/Presentation/App.Template.WebAPI/Controllers/FilesController.cs"
-    ],
-    frontend: []
-  },
-  auditLogs: {
-    backend: [
-      "src/Core/App.Template.Application/Features/AuditLogManagement",
-      "src/Core/App.Template.Application/DTOs/AuditLogDto.cs",
-      "src/Infrastructure/App.Template.Infrastructure/Persistence/AuditEntry.cs",
-      "src/Presentation/App.Template.WebAPI/Controllers/AuditLogsController.cs"
-    ],
-    frontend: []
-  },
-  notifications: {
-    backend: [
-      "src/Core/App.Template.Application/Features/NotificationManagement",
-      "src/Core/App.Template.Application/DTOs/NotificationDto.cs",
-      "src/Core/App.Template.Application/Interfaces/INotificationService.cs",
-      "src/Infrastructure/App.Template.Infrastructure/Services/NotificationService.cs",
-      "src/Infrastructure/App.Template.Infrastructure/Hubs",
-      "src/Infrastructure/App.Template.Infrastructure/SignalR",
-      "src/Presentation/App.Template.WebAPI/Controllers/NotificationsController.cs"
-    ],
-    frontend: []
-  },
-  dataExport: {
-    backend: [
-      "src/Core/App.Template.Application/Interfaces/IExportService.cs",
-      "src/Infrastructure/App.Template.Infrastructure/Services/ExportService.cs",
-      "src/Presentation/App.Template.WebAPI/Controllers/ExportController.cs"
-    ],
-    frontend: []
-  },
-  dashboard: {
-    backend: [],
-    frontend: []
-  }
-};
-var DOTNET_NLAYER_MAP = {
-  auth: {
-    backend: [
-      "src/App.Template.Api/Controllers/AuthController.cs",
-      "src/App.Template.Api/Services/AuthService.cs",
-      "src/App.Template.Api/Services/JwtTokenGenerator.cs",
-      "src/App.Template.Api/Models/Dtos/AuthDtos.cs",
-      "src/App.Template.Api/Models/Dtos/UserDtos.cs"
-      // Required by Auth
-    ],
-    frontend: []
-  },
-  userManagement: {
-    backend: [
-      "src/App.Template.Api/Controllers/UsersController.cs",
-      "src/App.Template.Api/Services/UserService.cs",
-      "src/App.Template.Api/Services/IUserService.cs",
-      "src/App.Template.Api/Repositories/UserRepository.cs",
-      "src/App.Template.Api/Repositories/IUserRepository.cs"
-      // 'src/App.Template.Api/Models/Dtos/UserDtos.cs', // Moved to auth
-    ],
-    frontend: []
-  },
-  departments: {
-    backend: [
-      "src/App.Template.Api/Controllers/DepartmentsController.cs",
-      "src/App.Template.Api/Models/Dtos/DepartmentDtos.cs"
-    ],
-    frontend: []
-  },
-  fileUpload: {
-    backend: [
-      "src/App.Template.Api/Controllers/FilesController.cs"
-    ],
-    frontend: []
-  },
-  auditLogs: {
-    backend: [],
-    frontend: []
-  },
-  notifications: {
-    backend: [
-      "src/App.Template.Api/Controllers/NotificationsController.cs",
-      "src/App.Template.Api/Infrastructure/Hubs"
-    ],
-    frontend: []
-  },
-  dataExport: {
-    backend: [
-      "src/App.Template.Api/Controllers/ExportController.cs"
-    ],
-    frontend: []
-  },
-  dashboard: {
-    backend: [],
-    frontend: []
-  }
-};
-var DOTNET_FEATURE_MAP = {
-  auth: {
-    backend: [
-      "src/App.Template.Api/Features/Auth"
-    ],
-    frontend: []
-  },
-  userManagement: {
-    backend: [
-      // 'src/App.Template.Api/Features/Users', // Don't remove whole folder, Auth needs Entity/Repo/DTOs
-      "src/App.Template.Api/Features/Users/UsersController.cs",
-      "src/App.Template.Api/Features/Users/UserService.cs",
-      "src/App.Template.Api/Features/Users/IUserService.cs"
-    ],
-    frontend: []
-  },
-  departments: {
-    backend: [
-      "src/App.Template.Api/Features/Departments"
-    ],
-    frontend: []
-  },
-  fileUpload: {
-    backend: [
-      "src/App.Template.Api/Features/Files"
-    ],
-    frontend: []
-  },
-  auditLogs: {
-    backend: [],
-    frontend: []
-  },
-  notifications: {
-    backend: [
-      "src/App.Template.Api/Features/Notifications"
-    ],
-    frontend: []
-  },
-  dataExport: {
-    backend: [
-      "src/App.Template.Api/Features/Export"
-    ],
-    frontend: []
-  },
-  dashboard: {
-    backend: [],
-    frontend: []
-  }
-};
-var SPRING_CLEAN_MAP = {
-  auth: {
-    backend: [
-      "api/src/main/java/apptemplate/api/controllers/AuthController.java"
-    ],
-    frontend: []
-  },
-  userManagement: {
-    backend: [
-      "api/src/main/java/apptemplate/api/controllers/UsersController.java"
-    ],
-    frontend: []
-  },
-  departments: {
-    backend: [
-      "api/src/main/java/apptemplate/api/controllers/DepartmentsController.java"
-    ],
-    frontend: []
-  },
-  fileUpload: {
-    backend: [
-      "api/src/main/java/apptemplate/api/controllers/FilesController.java"
-    ],
-    frontend: []
-  },
-  auditLogs: {
-    backend: [
-      "api/src/main/java/apptemplate/api/controllers/AuditLogsController.java"
-    ],
-    frontend: []
-  },
-  notifications: {
-    backend: [
-      "api/src/main/java/apptemplate/api/controllers/NotificationsController.java"
-    ],
-    frontend: []
-  },
-  dataExport: {
-    backend: [
-      "api/src/main/java/apptemplate/api/controllers/ExportController.java"
-    ],
-    frontend: []
-  },
-  dashboard: {
-    backend: [],
-    frontend: []
-  }
-};
-var SPRING_NLAYER_MAP = {
-  auth: {
-    backend: [
-      "src/main/java/com/apptemplate/api/controller/AuthController.java"
-    ],
-    frontend: []
-  },
-  userManagement: {
-    backend: [
-      "src/main/java/com/apptemplate/api/controller/UserController.java"
-    ],
-    frontend: []
-  },
-  departments: {
-    backend: [
-      "src/main/java/com/apptemplate/api/controller/DepartmentController.java"
-    ],
-    frontend: []
-  },
-  fileUpload: {
-    backend: [
-      "src/main/java/com/apptemplate/api/controller/FileController.java"
-    ],
-    frontend: []
-  },
-  auditLogs: {
-    backend: [
-      "src/main/java/com/apptemplate/api/audit"
-    ],
-    frontend: []
-  },
-  notifications: {
-    backend: [
-      "src/main/java/com/apptemplate/api/controller/NotificationController.java"
-    ],
-    frontend: []
-  },
-  dataExport: {
-    backend: [
-      "src/main/java/com/apptemplate/api/controller/ExportController.java"
-    ],
-    frontend: []
-  },
-  dashboard: {
-    backend: [],
-    frontend: []
-  }
-};
-var SPRING_FEATURE_MAP = {
-  auth: {
-    backend: [
-      "src/main/java/com/apptemplate/api/features/auth"
-    ],
-    frontend: []
-  },
-  userManagement: {
-    backend: [
-      "src/main/java/com/apptemplate/api/features/users"
-    ],
-    frontend: []
-  },
-  departments: {
-    backend: [
-      "src/main/java/com/apptemplate/api/features/departments"
-    ],
-    frontend: []
-  },
-  fileUpload: {
-    backend: [
-      "src/main/java/com/apptemplate/api/features/files"
-    ],
-    frontend: []
-  },
-  auditLogs: {
-    backend: [
-      "src/main/java/com/apptemplate/api/common/audit"
-    ],
-    frontend: []
-  },
-  notifications: {
-    backend: [
-      "src/main/java/com/apptemplate/api/features/notifications"
-    ],
-    frontend: []
-  },
-  dataExport: {
-    backend: [
-      "src/main/java/com/apptemplate/api/features/export"
-    ],
-    frontend: []
-  },
-  dashboard: {
-    backend: [],
-    frontend: []
-  }
-};
-var NESTJS_CLEAN_MAP = {
-  auth: {
-    backend: [
-      "src/modules/auth"
-    ],
-    frontend: []
-  },
-  userManagement: {
-    backend: [
-      "src/modules/user-management"
-    ],
-    frontend: []
-  },
-  departments: {
-    backend: [
-      "src/modules/department-management"
-    ],
-    frontend: []
-  },
-  fileUpload: {
-    backend: [
-      "src/modules/file-management"
-    ],
-    frontend: []
-  },
-  auditLogs: {
-    backend: [
-      "src/modules/audit-log"
-    ],
-    frontend: []
-  },
-  notifications: {
-    backend: [
-      "src/modules/notification"
-    ],
-    frontend: []
-  },
-  dataExport: {
-    backend: [
-      "src/modules/export"
-    ],
-    frontend: []
-  },
-  dashboard: {
-    backend: [],
-    frontend: []
-  }
-};
-var NESTJS_NLAYER_MAP = {
-  auth: {
-    backend: [
-      "src/auth"
-    ],
-    frontend: []
-  },
-  userManagement: {
-    backend: [],
-    frontend: []
-  },
-  departments: {
-    backend: [
-      "src/modules/departments"
-    ],
-    frontend: []
-  },
-  fileUpload: {
-    backend: [
-      "src/modules/files"
-    ],
-    frontend: []
-  },
-  auditLogs: {
-    backend: [],
-    frontend: []
-  },
-  notifications: {
-    backend: [
-      "src/modules/notifications"
-    ],
-    frontend: []
-  },
-  dataExport: {
-    backend: [
-      "src/modules/export"
-    ],
-    frontend: []
-  },
-  dashboard: {
-    backend: [],
-    frontend: []
-  }
-};
-var NESTJS_FEATURE_MAP = {
-  auth: {
-    backend: [
-      "src/features/auth"
-    ],
-    frontend: []
-  },
-  userManagement: {
-    backend: [
-      "src/features/users"
-    ],
-    frontend: []
-  },
-  departments: {
-    backend: [
-      "src/features/departments"
-    ],
-    frontend: []
-  },
-  fileUpload: {
-    backend: [
-      "src/features/files"
-    ],
-    frontend: []
-  },
-  auditLogs: {
-    backend: [],
-    frontend: []
-  },
-  notifications: {
-    backend: [
-      "src/features/notifications"
-    ],
-    frontend: []
-  },
-  dataExport: {
-    backend: [
-      "src/features/export"
-    ],
-    frontend: []
-  },
-  dashboard: {
-    backend: [],
-    frontend: []
-  }
-};
-var VUE_FRONTEND_MAP = {
-  auth: [
-    "src/pages/login.vue",
-    "src/pages/forgot-password.vue",
-    "src/pages/reset-password.vue",
-    "src/pages/profile.vue",
-    "src/stores/auth.js",
-    "src/services/authApi.js"
-  ],
-  userManagement: [
-    "src/pages/users",
-    "src/stores/user.js",
-    "src/services/userApi.js"
-  ],
-  departments: [
-    "src/pages/departments",
-    "src/stores/department.js",
-    "src/services/departmentApi.js"
-  ],
-  fileUpload: [
-    "src/pages/files",
-    "src/services/fileService.js"
-  ],
-  auditLogs: [
-    "src/pages/audit-logs",
-    "src/services/auditLogService.js"
-  ],
-  notifications: [
-    "src/pages/notifications",
-    "src/stores/notification.js",
-    "src/stores/persistentNotification.js",
-    "src/services/notificationApi.js"
-  ],
-  dataExport: [
-    "src/services/exportService.js"
-  ],
-  dashboard: [
-    "src/pages/dashboard.vue"
-  ]
-};
-var REACT_FRONTEND_MAP = {
-  auth: [
-    "src/pages/Login.tsx",
-    "src/pages/ForgotPassword.tsx",
-    "src/pages/ResetPassword.tsx",
-    "src/pages/Profile.tsx",
-    "src/stores/authStore.ts",
-    "src/services/authApi.ts"
-  ],
-  userManagement: [
-    "src/pages/Users.tsx",
-    "src/stores/userStore.ts",
-    "src/services/userApi.ts"
-  ],
-  departments: [
-    "src/pages/Departments.tsx",
-    "src/stores/departmentStore.ts",
-    "src/services/departmentApi.ts"
-  ],
-  fileUpload: [
-    "src/pages/FilesPage.tsx",
-    "src/services/fileService.ts"
-  ],
-  auditLogs: [
-    "src/pages/AuditLogsPage.tsx",
-    "src/pages/AuditLogs.tsx",
-    "src/services/auditLogService.ts"
-  ],
-  notifications: [
-    "src/pages/Notifications.tsx",
-    "src/stores/notificationStore.ts",
-    "src/stores/persistentNotificationStore.ts",
-    "src/services/notificationApi.ts"
-  ],
-  dataExport: [
-    "src/services/exportService.ts"
-  ],
-  dashboard: [
-    "src/pages/Dashboard.tsx",
-    "src/pages/Dashboard.scss"
-  ]
-};
-function getBackendFileMap(backend, architecture) {
-  const key = `${backend}-${architecture}`;
-  switch (key) {
-    case "dotnet-clean":
-      return DOTNET_CLEAN_MAP;
-    case "dotnet-nlayer":
-      return DOTNET_NLAYER_MAP;
-    case "dotnet-feature":
-      return DOTNET_FEATURE_MAP;
-    case "spring-clean":
-      return SPRING_CLEAN_MAP;
-    case "spring-nlayer":
-      return SPRING_NLAYER_MAP;
-    case "spring-feature":
-      return SPRING_FEATURE_MAP;
-    case "nestjs-clean":
-      return NESTJS_CLEAN_MAP;
-    case "nestjs-nlayer":
-      return NESTJS_NLAYER_MAP;
-    case "nestjs-feature":
-      return NESTJS_FEATURE_MAP;
-    default:
-      return {};
-  }
-}
-function getFrontendFileMap(frontendFramework) {
-  return frontendFramework === "vue" ? VUE_FRONTEND_MAP : REACT_FRONTEND_MAP;
-}
-function getFeaturesLabel(features, allFeatures) {
-  if (features.length === allFeatures.length) {
-    return "All features";
-  }
-  if (features.length === 0) {
-    return "None (bare template)";
-  }
-  return features.map((f) => FEATURE_OPTIONS.find((o) => o.value === f)?.label || f).join(", ");
-}
-
 // src/cli.ts
 var validProjectTypes = ["fullstack", "backend", "frontend"];
 var validBackends = ["dotnet", "spring", "nestjs"];
 var validArchitectures = ["clean", "nlayer", "feature"];
 var validFrontendFrameworks = ["vue", "react"];
 var validUILibraries = ["vuetify", "primevue", "primereact", "mui"];
-var validFeatures = [...ALL_FEATURES];
+var validVariants = ["minimal", "full"];
 function parseArgs() {
   const args = process.argv.slice(2);
   const result = {};
@@ -763,20 +97,12 @@ function parseArgs() {
       i++;
       continue;
     }
-    if (arg === "--features" || arg === "--feat") {
+    if (arg === "-V" || arg === "--variant") {
       const value = args[++i];
-      if (value) {
-        if (value === "all") {
-          result.features = [...ALL_FEATURES];
-        } else {
-          const requested = value.split(",").map((s) => s.trim());
-          const valid = requested.filter((f) => validFeatures.includes(f));
-          const invalid = requested.filter((f) => !validFeatures.includes(f));
-          if (invalid.length > 0) {
-            console.warn(`Warning: Invalid features "${invalid.join(", ")}". Valid options: ${validFeatures.join(", ")}`);
-          }
-          result.features = applyFeatureDependencies(valid);
-        }
+      if (isValidVariant(value)) {
+        result.variant = value;
+      } else {
+        console.warn(`Warning: Invalid variant "${value}". Valid options: ${validVariants.join(", ")}`);
       }
       i++;
       continue;
@@ -803,6 +129,9 @@ function isValidFrontendFramework(value) {
 function isValidUI(value) {
   return value !== void 0 && validUILibraries.includes(value);
 }
+function isValidVariant(value) {
+  return value !== void 0 && validVariants.includes(value);
+}
 function isValidProjectName(value) {
   if (!value) return false;
   const pattern = /^[A-Za-z][A-Za-z0-9]*(\.[A-Za-z][A-Za-z0-9]*)+$/;
@@ -961,25 +290,25 @@ async function runInteractivePrompts(cliArgs) {
     if (p.isCancel(result)) return result;
     ui = result;
   }
-  let features = cliArgs.features || [...ALL_FEATURES];
-  if (!cliArgs.features) {
-    const result = await p.multiselect({
-      message: "Which features would you like to include?",
-      options: FEATURE_OPTIONS.map((opt) => ({
-        value: opt.value,
-        label: opt.label,
-        hint: opt.hint
-      })),
-      initialValues: [...ALL_FEATURES],
-      required: false
+  let variant = cliArgs.variant || "full";
+  if (!cliArgs.variant) {
+    const result = await p.select({
+      message: "Which template variant would you like?",
+      options: [
+        {
+          value: "full",
+          label: "Full",
+          hint: "User management, departments, dashboard, all features"
+        },
+        {
+          value: "minimal",
+          label: "Minimal",
+          hint: "Auth, files, audit logs, notifications (no user/dept management)"
+        }
+      ]
     });
     if (p.isCancel(result)) return result;
-    features = applyFeatureDependencies(result);
-    if (features.length < result.length) {
-      const removed = result.filter((f) => !features.includes(f));
-      const removedLabels = removed.map((f) => FEATURE_OPTIONS.find((o) => o.value === f)?.label || f);
-      console.log(pc.yellow(`  \u26A0 Auto-removed due to dependencies: ${removedLabels.join(", ")}`));
-    }
+    variant = result;
   }
   let projectName = cliArgs.projectName;
   const needsNamespace = projectType !== "frontend" && (backend === "dotnet" || backend === "spring");
@@ -1033,7 +362,7 @@ async function runInteractivePrompts(cliArgs) {
     summaryLines.push(`${pc.cyan("Frontend:")}         ${getFrontendLabel(frontendFramework)}`);
     summaryLines.push(`${pc.cyan("UI Library:")}       ${getUILabel(ui)}`);
   }
-  summaryLines.push(`${pc.cyan("Features:")}         ${getFeaturesLabel(features, ALL_FEATURES)}`);
+  summaryLines.push(`${pc.cyan("Template:")}         ${getVariantLabel(variant)}`);
   if (needsNamespace && projectName) {
     summaryLines.push(`${pc.cyan("Namespace:")}        ${projectName}`);
   }
@@ -1059,7 +388,7 @@ async function runInteractivePrompts(cliArgs) {
     projectName,
     installDeps,
     placeInRoot,
-    features
+    variant
   };
 }
 function toPascalCase(str) {
@@ -1097,6 +426,13 @@ function getUILabel(ui) {
   };
   return labels[ui];
 }
+function getVariantLabel(variant) {
+  const labels = {
+    full: "Full (all features)",
+    minimal: "Minimal (no user/dept management)"
+  };
+  return labels[variant];
+}
 
 // src/generator.ts
 import * as p2 from "@clack/prompts";
@@ -1108,7 +444,18 @@ import fs5 from "fs";
 import degit from "degit";
 import path2 from "path";
 import fs2 from "fs";
-async function downloadTemplate(repo, folder, destPath) {
+async function downloadBackendTemplate(repo, backend, architecture, variant, destPath) {
+  const folder = `backend/${backend}/${architecture}-architecture/${variant}`;
+  const source = `${repo}/${folder}`;
+  const emitter = degit(source, {
+    cache: false,
+    force: true,
+    verbose: false
+  });
+  await emitter.clone(destPath);
+}
+async function downloadFrontendTemplate(repo, framework, ui, variant, destPath) {
+  const folder = `frontend/${framework}/${ui}/${variant}`;
   const source = `${repo}/${folder}`;
   const emitter = degit(source, {
     cache: false,
@@ -1207,12 +554,16 @@ async function renameDotNetProject(projectPath, config, newDotName, newNamespace
   }
   if (!fs3.existsSync(backendDir)) return;
   const folderMappings = [
+    // Clean architecture (multi-project layout)
     ["src/Core/App.Template.Domain", `src/Core/${newDotName}.Domain`],
     ["src/Core/App.Template.Application", `src/Core/${newDotName}.Application`],
     ["src/Infrastructure/App.Template.Infrastructure", `src/Infrastructure/${newDotName}.Infrastructure`],
     ["src/Presentation/App.Template.WebAPI", `src/Presentation/${newDotName}.WebAPI`],
     ["tests/App.Template.Domain.Tests", `tests/${newDotName}.Domain.Tests`],
-    ["tests/App.Template.Application.Tests", `tests/${newDotName}.Application.Tests`]
+    ["tests/App.Template.Application.Tests", `tests/${newDotName}.Application.Tests`],
+    // Feature and NLayer architectures (single-project layout)
+    ["src/App.Template.Api", `src/${newDotName}.Api`],
+    ["tests/App.Template.Api.Tests", `tests/${newDotName}.Api.Tests`]
   ];
   for (const [oldFolder, newFolder] of folderMappings) {
     const oldPath = path3.join(backendDir, oldFolder);
@@ -1234,6 +585,39 @@ async function renameDotNetProject(projectPath, config, newDotName, newNamespace
     return content.replace(/App\.Template/g, newDotName).replace(/AppTemplate/g, newNamespace);
   });
 }
+function renameJavaPackageDir(oldDir, newDir) {
+  if (!fs3.existsSync(oldDir)) return;
+  const resolvedOld = path3.resolve(oldDir);
+  const resolvedNew = path3.resolve(newDir);
+  if (resolvedOld === resolvedNew) return;
+  if (fs3.existsSync(resolvedNew)) {
+    for (const entry of fs3.readdirSync(resolvedOld, { withFileTypes: true })) {
+      fs3.renameSync(
+        path3.join(resolvedOld, entry.name),
+        path3.join(resolvedNew, entry.name)
+      );
+    }
+    fs3.rmdirSync(resolvedOld);
+  } else {
+    fs3.mkdirSync(path3.dirname(resolvedNew), { recursive: true });
+    fs3.renameSync(resolvedOld, resolvedNew);
+  }
+  let current = path3.dirname(resolvedOld);
+  while (path3.basename(current) !== "java") {
+    if (!fs3.existsSync(current)) break;
+    try {
+      const remaining = fs3.readdirSync(current);
+      if (remaining.length === 0) {
+        fs3.rmdirSync(current);
+        current = path3.dirname(current);
+      } else {
+        break;
+      }
+    } catch {
+      break;
+    }
+  }
+}
 async function renameSpringProject(projectPath, config, newDotName) {
   let backendDir;
   if (config.projectType === "fullstack") {
@@ -1246,15 +630,43 @@ async function renameSpringProject(projectPath, config, newDotName) {
   if (!fs3.existsSync(backendDir)) return;
   const packageName = newDotName.toLowerCase().replace(/\./g, ".");
   const artifactId = newDotName.toLowerCase().replace(/\./g, "-");
-  const pomPath = path3.join(backendDir, "pom.xml");
-  if (fs3.existsSync(pomPath)) {
-    let content = fs3.readFileSync(pomPath, "utf-8");
-    content = content.replace(/<groupId>com\.apptemplate<\/groupId>/g, `<groupId>${packageName}</groupId>`).replace(/<artifactId>apptemplate<\/artifactId>/g, `<artifactId>${artifactId}</artifactId>`).replace(/com\.apptemplate/g, packageName);
-    fs3.writeFileSync(pomPath, content);
-  }
+  const pkgPath = newDotName.toLowerCase().replace(/\./g, "/");
+  const compactName = newDotName.replace(/\./g, "").toLowerCase();
+  const displayName = newDotName.replace(/\./g, "");
+  const isClean = config.architecture === "clean";
+  await updateFileContents(backendDir, [".xml"], (content) => {
+    return content.replace(/<artifactId>app-template<\/artifactId>/g, `<artifactId>${artifactId}</artifactId>`).replace(/com\.apptemplate/g, packageName).replace(/AppTemplate/g, displayName);
+  });
+  await updateFileContents(backendDir, [".yml", ".yaml", ".properties"], (content) => {
+    if (isClean) {
+      return content.replace(/AppTemplate/g, displayName).replace(/apptemplate\.local/g, `${compactName}.local`).replace(/apptemplate_(\w+)/g, `${compactName}_$1`).replace(/\bapptemplate\b/g, packageName);
+    } else {
+      return content.replace(/AppTemplate/g, displayName).replace(/com\.apptemplate/g, packageName);
+    }
+  });
   await updateFileContents(backendDir, [".java"], (content) => {
-    return content.replace(/com\.apptemplate/g, packageName);
+    if (isClean) {
+      return content.replace(/apptemplate\.local/g, `${compactName}.local`).replace(/\bapptemplate\b/g, packageName);
+    } else {
+      return content.replace(/com\.apptemplate/g, packageName);
+    }
   });
+  if (isClean) {
+    const modules = ["api", "application", "domain", "infrastructure"];
+    for (const module of modules) {
+      for (const sourceRoot of ["src/main/java", "src/test/java"]) {
+        const oldDir = path3.join(backendDir, module, sourceRoot, "apptemplate");
+        const newDir = path3.join(backendDir, module, sourceRoot, pkgPath);
+        renameJavaPackageDir(oldDir, newDir);
+      }
+    }
+  } else {
+    for (const sourceRoot of ["src/main/java", "src/test/java"]) {
+      const oldDir = path3.join(backendDir, sourceRoot, "com", "apptemplate");
+      const newDir = path3.join(backendDir, sourceRoot, ...packageName.split("."));
+      renameJavaPackageDir(oldDir, newDir);
+    }
+  }
 }
 async function updateCommonFiles(projectPath, _config, newDotName, newNamespace) {
   const filesToUpdate = [
@@ -1309,7 +721,7 @@ function getAllFiles(dir) {
   for (const entry of entries) {
     const fullPath = path3.join(dir, entry.name);
     if (entry.isDirectory()) {
-      if (!["node_modules", ".git", "bin", "obj", "dist", "build"].includes(entry.name)) {
+      if (!["node_modules", ".git", "bin", "obj", "dist", "build", "target"].includes(entry.name)) {
         files.push(...getAllFiles(fullPath));
       }
     } else {
@@ -1436,8 +848,6 @@ async function generateProject(config) {
   spinner2.start("Downloading templates...");
   try {
     if (config.projectType !== "frontend") {
-      const archSuffix = config.architecture === "clean" ? "" : `-${config.architecture}`;
-      const sourceFolder = `backend-${config.backend}${archSuffix}`;
       let destFolder;
       if (config.projectType === "fullstack") {
         destFolder = "backend";
@@ -1445,11 +855,10 @@ async function generateProject(config) {
         destFolder = config.placeInRoot ? "" : "backend";
       }
       const destPath = destFolder ? path5.join(absolutePath, destFolder) : absolutePath;
-      await downloadTemplate(REPO, sourceFolder, destPath);
-      spinner2.message(`Downloaded ${sourceFolder}`);
+      await downloadBackendTemplate(REPO, config.backend, config.architecture, config.variant, destPath);
+      spinner2.message(`Downloaded backend-${config.backend}-${config.architecture}-${config.variant}`);
     }
     if (config.projectType !== "backend") {
-      const sourceFolder = `frontend-${config.ui}`;
       let destFolder;
       if (config.projectType === "fullstack") {
         destFolder = "frontend";
@@ -1457,8 +866,8 @@ async function generateProject(config) {
         destFolder = config.placeInRoot ? "" : "frontend";
       }
       const destPath = destFolder ? path5.join(absolutePath, destFolder) : absolutePath;
-      await downloadTemplate(REPO, sourceFolder, destPath);
-      spinner2.message(`Downloaded ${sourceFolder}`);
+      await downloadFrontendTemplate(REPO, config.frontendFramework, config.ui, config.variant, destPath);
+      spinner2.message(`Downloaded frontend-${config.frontendFramework}-${config.ui}-${config.variant}`);
     }
     await copyRootFiles(REPO, absolutePath, config);
     spinner2.message("Downloaded configuration files");
@@ -1467,16 +876,6 @@ async function generateProject(config) {
     spinner2.stop("Download failed");
     throw error;
   }
-  const deselectedFeatures = ALL_FEATURES.filter((f) => !config.features.includes(f));
-  if (deselectedFeatures.length > 0) {
-    spinner2.start("Removing deselected feature files...");
-    try {
-      await removeDeselectedFeatures(absolutePath, config, deselectedFeatures);
-      spinner2.stop(`Removed ${deselectedFeatures.length} deselected feature(s)`);
-    } catch (error) {
-      spinner2.stop("Feature removal had warnings");
-    }
-  }
   spinner2.start("Updating configuration files...");
   try {
     await updateFolderReferences(absolutePath, config);
@@ -1521,48 +920,6 @@ async function generateProject(config) {
     await createAppSettingsFromExample(absolutePath, config);
   }
 }
-async function removeDeselectedFeatures(projectPath, config, deselectedFeatures) {
-  if (config.projectType !== "frontend") {
-    const backendMap = getBackendFileMap(config.backend, config.architecture);
-    let backendDir;
-    if (config.projectType === "fullstack") {
-      backendDir = path5.join(projectPath, "backend");
-    } else {
-      backendDir = config.placeInRoot ? projectPath : path5.join(projectPath, "backend");
-    }
-    for (const feature of deselectedFeatures) {
-      const featureMap = backendMap[feature];
-      if (featureMap) {
-        for (const filePath of featureMap.backend) {
-          const fullPath = path5.join(backendDir, filePath);
-          if (fs5.existsSync(fullPath)) {
-            fs5.rmSync(fullPath, { recursive: true, force: true });
-          }
-        }
-      }
-    }
-  }
-  if (config.projectType !== "backend") {
-    const frontendMap = getFrontendFileMap(config.frontendFramework);
-    let frontendDir;
-    if (config.projectType === "fullstack") {
-      frontendDir = path5.join(projectPath, "frontend");
-    } else {
-      frontendDir = config.placeInRoot ? projectPath : path5.join(projectPath, "frontend");
-    }
-    for (const feature of deselectedFeatures) {
-      const featurePaths = frontendMap[feature];
-      if (featurePaths) {
-        for (const filePath of featurePaths) {
-          const fullPath = path5.join(frontendDir, filePath);
-          if (fs5.existsSync(fullPath)) {
-            fs5.rmSync(fullPath, { recursive: true, force: true });
-          }
-        }
-      }
-    }
-  }
-}
 function cleanupFullstackDockerFiles(projectPath) {
   const filesToDelete = [
     "backend/Dockerfile",
@@ -1727,7 +1084,7 @@ async function main() {
         projectName: cliArgs.projectName,
         installDeps: cliArgs.install || false,
         placeInRoot: cliArgs.root || false,
-        features: cliArgs.features || [...ALL_FEATURES]
+        variant: cliArgs.variant || "full"
       };
     } else {
       const result = await runInteractivePrompts(cliArgs);
@@ -1763,8 +1120,9 @@ ${pc3.bold("Options:")}
   ${pc3.yellow("-u, --ui")}           UI library: vuetify, primevue (Vue) | mui, primereact (React)
   ${pc3.yellow("-n, --name")}         Project namespace (Company.Project format, .NET/Spring only)
   ${pc3.yellow("-r, --root")}         Place files in project root ${pc3.gray("(backend/frontend-only)")}
-  ${pc3.yellow("--features")}         Features to include (comma-separated or "all")
-                       Options: auth,userManagement,departments,fileUpload,auditLogs,notifications,dataExport,dashboard
+  ${pc3.yellow("-V, --variant")}      Template variant: full, minimal ${pc3.gray("(default: full)")}
+                       full: All features (user management, departments, dashboard)
+                       minimal: Auth, files, audit logs, notifications only
   ${pc3.yellow("-i, --install")}      Install dependencies after creation
   ${pc3.yellow("-h, --help")}         Show this help message
   ${pc3.yellow("-v, --version")}      Show version number
@@ -1776,8 +1134,8 @@ ${pc3.bold("Examples:")}
   ${pc3.gray("# Create fullstack project with .NET backend")}
   npm create apptemplate@latest my-app -b dotnet -n "MyCompany.MyApp" -i
 
-  ${pc3.gray("# Create backend-only project with Spring Boot")}
-  npm create apptemplate@latest my-api -t backend -b spring -n "MyCompany.MyApi"
+  ${pc3.gray("# Create minimal backend-only project (no user management)")}
+  npm create apptemplate@latest my-api -t backend -b spring -n "MyCompany.MyApi" -V minimal
 
   ${pc3.gray("# Create frontend-only project with PrimeVue")}
   npm create apptemplate@latest my-spa -t frontend -u primevue