create-lumen 1.0.0

package/src/injector.js

@@ -0,0 +1,276 @@
+import { promises as fsp } from "fs";
+import path from "path";
+import { copyDirRecursive, writeFileRecursive } from "./utils/fs.js";
+
+export async function injectArchitecture(projectPath, templatesDir, architecture, language) {
+  const ext = language === "ts" ? "tsx" : "jsx";
+  const srcDir = path.join(templatesDir, "architectures", architecture, "src");
+
+  // Remove Vite's default App files BEFORE copying architecture
+  const defaultAppTsx = path.join(projectPath, "src", "App.tsx");
+  const defaultAppJsx = path.join(projectPath, "src", "App.jsx");
+  try { await fsp.rm(defaultAppTsx, { force: true }); } catch {}
+  try { await fsp.rm(defaultAppJsx, { force: true }); } catch {}
+
+  // Copy the architecture tree into the project's src/
+  await copyDirRecursive(srcDir, path.join(projectPath, "src"), (name) => {
+    // Skip files that don't match the language
+    if (language === "ts" && name.endsWith(".jsx")) return false;
+    if (language === "js" && name.endsWith(".tsx")) return false;
+    // Skip .ts files when JS, skip .js when TS (for non-component files)
+    if (language === "ts" && name.endsWith(".js") && !name.endsWith(".config.js")) return false;
+    if (language === "js" && name.endsWith(".ts") && !name.endsWith(".config.ts")) return false;
+    return true;
+  });
+
+  // Copy the architecture's main.tsx/main.jsx to src/main.{ext}
+  const mainSrc = path.join(
+    templatesDir,
+    "architectures",
+    architecture,
+    `main.${ext}`
+  );
+  try {
+    await fsp.access(mainSrc);
+    await fsp.copyFile(mainSrc, path.join(projectPath, "src", `main.${ext}`));
+  } catch {
+    // main file doesn't exist in template, skip
+  }
+
+  // Remove the opposite language's main file (Vite creates main.jsx by default)
+  const oppositeExt = language === "ts" ? "jsx" : "tsx";
+  const oppositeMain = path.join(projectPath, "src", `main.${oppositeExt}`);
+  try { await fsp.rm(oppositeMain, { force: true }); } catch {}
+}
+
+export async function injectConditionals(projectPath, templatesDir, responses, architecture, language) {
+  const ext = language === "ts" ? "tsx" : "jsx";
+
+  // 1. State management
+  if (responses.stateManagement === "redux") {
+    await injectOverlay(
+      projectPath,
+      templatesDir,
+      `conditional/state/redux/${architecture}`,
+      language
+    );
+    await updateMainWithProvider(projectPath, "redux", architecture, ext);
+  } else if (responses.stateManagement === "zustand") {
+    await injectOverlay(
+      projectPath,
+      templatesDir,
+      `conditional/state/zustand/${architecture}`,
+      language
+    );
+  }
+
+  // 2. Router (overwrites App.tsx with routed version)
+  if (responses.router) {
+    await injectOverlay(
+      projectPath,
+      templatesDir,
+      `conditional/router/${architecture}`,
+      language
+    );
+  }
+
+  // 3. Icons (overwrites home page)
+  if (responses.iconLibrary && responses.iconLibrary !== "none") {
+    await injectOverlay(
+      projectPath,
+      templatesDir,
+      `conditional/icons/${responses.iconLibrary}/${architecture}`,
+      language
+    );
+  }
+
+  // 4. Axios
+  if (responses.axios) {
+    await injectOverlay(
+      projectPath,
+      templatesDir,
+      `conditional/axios/${architecture}`,
+      language
+    );
+  }
+
+  // 5. Testing
+  if (responses.testing === "vitest") {
+    await injectTesting(projectPath, templatesDir, "vitest", language, architecture);
+  } else if (responses.testing === "jest") {
+    await injectTesting(projectPath, templatesDir, "jest", language, architecture);
+  }
+
+  // 6. Linter
+  if (responses.linter === "eslint") {
+    await injectLinter(projectPath, templatesDir, "eslint", language);
+  } else if (responses.linter === "oxlint") {
+    await injectLinter(projectPath, templatesDir, "oxlint", language);
+  }
+
+  // 7. Create feature script (feature-based only)
+  if (architecture === "feature-based") {
+    await injectCreateFeatureScript(projectPath, templatesDir, language);
+  }
+}
+
+async function injectOverlay(projectPath, templatesDir, overlayPath, language) {
+  const srcDir = path.join(templatesDir, overlayPath, "src");
+  try {
+    await fsp.access(srcDir);
+    await copyDirRecursive(srcDir, path.join(projectPath, "src"), (name) => {
+      if (language === "ts" && name.endsWith(".jsx")) return false;
+      if (language === "js" && name.endsWith(".tsx")) return false;
+      if (language === "ts" && name.endsWith(".js") && !name.endsWith(".config.js")) return false;
+      if (language === "js" && name.endsWith(".ts") && !name.endsWith(".config.ts")) return false;
+      return true;
+    });
+  } catch {
+    // overlay src dir doesn't exist
+  }
+}
+
+async function injectTesting(projectPath, templatesDir, framework, language, architecture) {
+  const testingDir = path.join(templatesDir, "conditional", "testing", framework);
+
+  // Copy config files to project root
+  const configExt = language === "ts" ? "ts" : "js";
+  const configSrc = path.join(testingDir, `${framework}.config.${configExt}`);
+  try {
+    await fsp.access(configSrc);
+    await fsp.copyFile(configSrc, path.join(projectPath, `${framework}.config.${configExt}`));
+  } catch {}
+
+  // Copy setup file
+  const setupSrc = path.join(testingDir, `src/test/setup.${configExt}`);
+  try {
+    await fsp.access(setupSrc);
+    const setupDest = path.join(projectPath, "src", "test", `setup.${configExt}`);
+    await writeFileRecursive(setupDest, await fsp.readFile(setupSrc, "utf8"));
+  } catch {}
+
+  // Copy test file
+  const testExt = language === "ts" ? "tsx" : "jsx";
+  const testSrc = path.join(testingDir, `src/__tests__/App.test.${testExt}`);
+  try {
+    await fsp.access(testSrc);
+    const testDest = path.join(projectPath, "src", "__tests__", `App.test.${testExt}`);
+    await writeFileRecursive(testDest, await fsp.readFile(testSrc, "utf8"));
+  } catch {}
+
+  // Add test script to package.json
+  const pkgPath = path.join(projectPath, "package.json");
+  try {
+    const content = await fsp.readFile(pkgPath, "utf8");
+    const pkg = JSON.parse(content);
+    if (!pkg.scripts) pkg.scripts = {};
+    if (framework === "vitest") {
+      pkg.scripts.test = "vitest";
+      pkg.scripts["test:run"] = "vitest run";
+    } else {
+      pkg.scripts.test = "jest";
+      pkg.scripts["test:watch"] = "jest --watch";
+    }
+    await fsp.writeFile(pkgPath, JSON.stringify(pkg, null, 2) + "\n", "utf8");
+  } catch {}
+}
+
+async function injectLinter(projectPath, templatesDir, linter, language) {
+  const lintingDir = path.join(templatesDir, "conditional", "linting", linter);
+
+  if (linter === "eslint") {
+    const configExt = language === "ts" ? "ts" : "js";
+    const configSrc = path.join(lintingDir, `eslint.config.${configExt}`);
+    try {
+      await fsp.access(configSrc);
+      await fsp.copyFile(configSrc, path.join(projectPath, `eslint.config.${configExt}`));
+    } catch {}
+  } else if (linter === "oxlint") {
+    const configSrc = path.join(lintingDir, "oxlintrc.json");
+    try {
+      await fsp.access(configSrc);
+      await fsp.copyFile(configSrc, path.join(projectPath, "oxlintrc.json"));
+    } catch {}
+  }
+
+  // Add lint script to package.json
+  const pkgPath = path.join(projectPath, "package.json");
+  try {
+    const content = await fsp.readFile(pkgPath, "utf8");
+    const pkg = JSON.parse(content);
+    if (!pkg.scripts) pkg.scripts = {};
+    if (linter === "eslint") {
+      pkg.scripts.lint = "eslint .";
+      pkg.scripts["lint:fix"] = "eslint . --fix";
+    } else {
+      pkg.scripts.lint = "oxlint .";
+    }
+    await fsp.writeFile(pkgPath, JSON.stringify(pkg, null, 2) + "\n", "utf8");
+  } catch {}
+}
+
+async function injectCreateFeatureScript(projectPath, templatesDir, language) {
+  const scriptSrc = path.join(templatesDir, "architectures", "feature-based", "scripts", "create-feature.mjs");
+  const scriptDest = path.join(projectPath, "scripts", "create-feature.mjs");
+
+  try {
+    await fsp.access(scriptSrc);
+    let content = await fsp.readFile(scriptSrc, "utf8");
+
+    // Adapt to JS if needed
+    if (language === "js") {
+      // Replace .ts extensions with .js in the initialFiles
+      content = content
+        .replace(/interfaces\/index\.ts/g, "interfaces/index.js")
+        .replace(/services\/index\.ts/g, "services/index.js")
+        .replace(/store\/index\.ts/g, "store/index.js")
+        .replace(/hooks\/index\.ts/g, "hooks/index.js")
+        .replace(/pages\/index\.ts/g, "pages/index.js");
+    }
+
+    await writeFileRecursive(scriptDest, content);
+  } catch {}
+
+  // Add script to package.json
+  const pkgPath = path.join(projectPath, "package.json");
+  try {
+    const content = await fsp.readFile(pkgPath, "utf8");
+    const pkg = JSON.parse(content);
+    if (!pkg.scripts) pkg.scripts = {};
+    pkg.scripts["create:feature"] = "node scripts/create-feature.mjs";
+    await fsp.writeFile(pkgPath, JSON.stringify(pkg, null, 2) + "\n", "utf8");
+  } catch {}
+}
+
+async function updateMainWithProvider(projectPath, stateType, architecture, ext) {
+  const mainPath = path.join(projectPath, "src", `main.${ext}`);
+  try {
+    let content = await fsp.readFile(mainPath, "utf8");
+
+    if (architecture === "feature-based") {
+      if (!content.includes("StoreProvider")) {
+        content = content.replace(
+          /import App from ['"]@\/app\/App['"]\n?/,
+          "import App from '@/app/App'\nimport { StoreProvider } from '@/app/providers/StoreProvider'\n"
+        );
+        content = content.replace(
+          /<App \/>/,
+          "<StoreProvider>\n        <App />\n      </StoreProvider>"
+        );
+      }
+    } else {
+      if (!content.includes("StoreProvider")) {
+        content = content.replace(
+          /import App from ['"]\.\/App['"]\n?/,
+          "import App from './App'\nimport { StoreProvider } from './context/StoreProvider'\n"
+        );
+        content = content.replace(
+          /<App \/>/,
+          "<StoreProvider>\n        <App />\n      </StoreProvider>"
+        );
+      }
+    }
+
+    await fsp.writeFile(mainPath, content, "utf8");
+  } catch {}
+}

package/src/main.js

@@ -0,0 +1,197 @@
+import { isCancel, log, spinner, text } from "@clack/prompts";
+import chalk from "chalk";
+import path from "path";
+import { fileURLToPath } from "url";
+
+import { confirmEmptyFolder } from "./confirm-empty-folder.js";
+import { cleanupBoilerplate } from "./cleanup.js";
+import { configureProject } from "./configure.js";
+import { setupCssFramework } from "./css.js";
+import { injectArchitecture, injectConditionals } from "./injector.js";
+import { getPkgManager } from "./utils/pkg-manager.js";
+import { handleDevServer } from "./utils/dev-server.js";
+import { getUserInputs, onCancel } from "./prompts.js";
+import { runBaseInstall, runGitInit, runViteCreate } from "./scaffold.js";
+import { installAllDeps } from "./dependencies.js";
+import { generateReadme } from "./readme.js";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const TEMPLATES_DIR = path.join(__dirname, "../templates");
+const CURRENT_DIR = process.cwd();
+
+export async function main() {
+  const pkg = getPkgManager();
+
+  // 1. Project name
+  const cliArg = process.argv[2];
+  let projectName;
+
+  if (cliArg && cliArg.trim()) {
+    projectName = cliArg.trim();
+    log.step(chalk.gray(`Project name: ${chalk.bold(projectName)}`));
+  } else {
+    projectName = await text({
+      message: "What is your project name?",
+      placeholder: "my-app",
+      validate(value) {
+        if (!value || !value.trim()) return "Project name is required!";
+      },
+    });
+    if (isCancel(projectName)) onCancel();
+  }
+
+  // 2. Handle existing folder
+  await confirmEmptyFolder(projectName);
+
+  // 3. Collect user preferences
+  const responses = await getUserInputs(projectName);
+
+  const projectPath = path.resolve(CURRENT_DIR, projectName);
+
+  // 4. Scaffold via vite create
+  const createSpin = spinner();
+  createSpin.start("Creating your Vite + React project...");
+  try {
+    await runViteCreate(projectPath, projectName, pkg, responses.language);
+    createSpin.stop(chalk.green("Project created successfully!"));
+  } catch (err) {
+    createSpin.stop(chalk.red("Failed to create project."));
+    throw err;
+  }
+
+  // 5. Install base dependencies
+  const depSpin = spinner();
+  depSpin.start(`Installing dependencies using ${pkg}...`);
+  try {
+    await runBaseInstall(projectPath, pkg);
+    depSpin.stop(chalk.green("Dependencies installed."));
+  } catch (err) {
+    depSpin.stop(chalk.red("Failed to install dependencies."));
+    throw err;
+  }
+
+  // 6. Git init (if requested)
+  if (responses.gitInit) {
+    const gitSpin = spinner();
+    gitSpin.start("Initializing git repository...");
+    try {
+      await runGitInit(projectPath);
+      gitSpin.stop(chalk.green("Git repository initialized."));
+    } catch (err) {
+      gitSpin.stop(chalk.red("Git initialization failed."));
+      throw err;
+    }
+  }
+
+  // 7. Inject architecture templates
+  const archSpin = spinner();
+  archSpin.start(
+    `Setting up ${responses.architecture === "feature-based" ? "feature-based" : "component-based"} architecture...`
+  );
+  try {
+    await injectArchitecture(
+      projectPath,
+      TEMPLATES_DIR,
+      responses.architecture,
+      responses.language
+    );
+    archSpin.stop(chalk.green("Architecture scaffolding complete."));
+  } catch (err) {
+    archSpin.stop(chalk.red("Failed to scaffold architecture."));
+    throw err;
+  }
+
+  // 8. Inject conditional features
+  const condSpin = spinner();
+  condSpin.start("Installing additional features...");
+  try {
+    await injectConditionals(
+      projectPath,
+      TEMPLATES_DIR,
+      responses,
+      responses.architecture,
+      responses.language
+    );
+    condSpin.stop(chalk.green("Features configured."));
+  } catch (err) {
+    condSpin.stop(chalk.red("Failed to configure features."));
+    throw err;
+  }
+
+  // 9. Install all additional dependencies in one batch
+  const extrasSpin = spinner();
+  extrasSpin.start("Installing additional dependencies...");
+  try {
+    await installAllDeps(responses, pkg, projectPath);
+    extrasSpin.stop(chalk.green("Additional dependencies installed."));
+  } catch (err) {
+    extrasSpin.stop(chalk.red("Failed to install additional dependencies."));
+    throw err;
+  }
+
+  // 10. CSS framework setup
+  const cssSpin = spinner();
+  const cssLabel =
+    responses.cssFramework === "none"
+      ? "CSS reset"
+      : responses.cssFramework === "tailwind"
+      ? "Tailwind CSS"
+      : "Bootstrap";
+  if (responses.cssFramework !== "none") {
+    cssSpin.start(`Setting up ${cssLabel}...`);
+  }
+  try {
+    await setupCssFramework({
+      projectPath,
+      templatesDir: TEMPLATES_DIR,
+      language: responses.language,
+      cssFramework: responses.cssFramework,
+      ext: responses.language === "ts" ? "tsx" : "jsx",
+      pkg,
+    });
+    if (responses.cssFramework !== "none") {
+      cssSpin.stop(chalk.green(`${cssLabel} setup complete.`));
+    }
+  } catch (err) {
+    cssSpin.stop(chalk.red(`Failed to setup ${cssLabel}.`));
+    throw err;
+  }
+
+  // 11. Configure path aliases + package.json
+  const configSpin = spinner();
+  configSpin.start("Configuring project...");
+  try {
+    await configureProject(projectPath, responses.language, responses.cssFramework);
+    configSpin.stop(chalk.green("Project configured."));
+  } catch (err) {
+    configSpin.stop(chalk.red("Failed to configure project."));
+    throw err;
+  }
+
+  // 12. Cleanup boilerplate
+  await cleanupBoilerplate(projectPath);
+
+  // 13. Generate README.md + LICENSE (if requested)
+  if (responses.readme) {
+    const readmeSpin = spinner();
+    readmeSpin.start("Generating README.md and LICENSE...");
+    try {
+      await generateReadme(projectPath, projectName, responses);
+      readmeSpin.stop(chalk.green("README.md and LICENSE generated."));
+    } catch (err) {
+      readmeSpin.stop(chalk.red("Failed to generate README.md and LICENSE."));
+      throw err;
+    }
+  }
+
+  log.step(chalk.green("\nProject setup complete!"));
+  log.message(
+    chalk.gray(
+      `  Architecture: ${responses.architecture === "feature-based" ? "Feature-based" : "Component-based"}`
+    )
+  );
+
+  // 14. Offer dev server
+  await handleDevServer(pkg, projectName);
+}

package/src/prompts.js

@@ -0,0 +1,232 @@
+import { cancel, confirm, isCancel, note, select, text } from "@clack/prompts";
+import chalk from "chalk";
+import { configExists, loadConfig, saveConfig } from "./config-cache.js";
+
+export function onCancel() {
+  console.log(chalk.gray("\n\nOperation cancelled.\n"));
+  process.exit(1);
+}
+
+function formatConfig(responses) {
+  const lang = responses.language === "ts" ? "TypeScript" : "JavaScript";
+  const arch =
+    responses.architecture === "feature-based"
+      ? "Feature-based"
+      : "Component-based";
+  const css =
+    responses.cssFramework === "none"
+      ? "None"
+      : responses.cssFramework === "tailwind"
+      ? "Tailwind CSS"
+      : "Bootstrap";
+  const testing =
+    responses.testing === "none"
+      ? "None"
+      : responses.testing === "vitest"
+      ? "Vitest"
+      : "Jest";
+  const state =
+    responses.stateManagement === "none"
+      ? "None"
+      : responses.stateManagement === "redux"
+      ? "Redux Toolkit"
+      : "Zustand";
+
+  return [
+    `• ${chalk.bold("Architecture:")} ${chalk.green(arch)}`,
+    `• ${chalk.bold("Language:")} ${chalk.green(lang)}`,
+    `• ${chalk.bold("CSS:")} ${chalk.yellow(css)}`,
+    `• ${chalk.bold("Testing:")} ${chalk.magenta(testing)}`,
+    `• ${chalk.bold("Router:")} ${responses.router ? chalk.green("Yes") : chalk.red("No")}`,
+    `• ${chalk.bold("State:")} ${chalk.blue(state)}`,
+    `• ${chalk.bold("Icons:")} ${chalk.blue(responses.iconLibrary === "none" ? "None" : responses.iconLibrary === "lucide" ? "Lucide" : "Huge")}`,
+    `• ${chalk.bold("Axios:")} ${responses.axios ? chalk.green("Yes") : chalk.red("No")}`,
+    `• ${chalk.bold("Linter:")} ${responses.linter === "oxlint" ? chalk.green("Oxlint") : responses.linter === "eslint" ? chalk.yellow("ESLint") : chalk.red("None")}`,
+    `• ${chalk.bold("Git:")} ${responses.gitInit ? chalk.green("Yes") : chalk.red("No")}`,
+    `• ${chalk.bold("README:")} ${responses.readme ? chalk.green("Yes") : chalk.red("No")}`,
+  ].join("\n");
+}
+
+export async function getUserInputs(projectName) {
+  let oldConfig = {};
+  let useOldConfig = false;
+
+  if (await configExists()) {
+    oldConfig = await loadConfig();
+    oldConfig.projectName = projectName;
+
+    note(
+      `Previous setup found:\n\n${formatConfig(oldConfig)}\n`,
+      "Previous Configuration"
+    );
+
+    const useExisting = await select({
+      message: "How would you like to proceed?",
+      options: [
+        { value: true, label: "Continue with previous setup" },
+        { value: false, label: "Start fresh (new setup)" },
+      ],
+      initialValue: true,
+    });
+
+    if (isCancel(useExisting)) onCancel();
+    useOldConfig = useExisting;
+
+    if (useOldConfig) {
+      return { ...oldConfig, projectName };
+    }
+  }
+
+  // Quick Setup
+  const quickSetup = await confirm({
+    message:
+      "Quick Setup? (TypeScript + Tailwind + Feature-based + Router + ESLint + Vitest)",
+    initialValue: true,
+  });
+  if (isCancel(quickSetup)) onCancel();
+
+  if (quickSetup) {
+    const responses = {
+      projectName,
+      architecture: "feature-based",
+      language: "ts",
+      cssFramework: "tailwind",
+      testing: "vitest",
+      router: true,
+      stateManagement: "none",
+      iconLibrary: "none",
+      axios: false,
+      linter: "eslint",
+      gitInit: false,
+      readme: true,
+    };
+    await saveConfig(responses);
+    return responses;
+  }
+
+  // Custom setup
+  const architecture = await select({
+    message: "Which project architecture do you want?",
+    options: [
+      {
+        label: "Feature-based",
+        value: "feature-based",
+        hint: "Scales to large apps — code grouped by business domain",
+      },
+      {
+        label: "Component-based",
+        value: "component-based",
+        hint: "Small apps / component libraries — code grouped by UI type",
+      },
+    ],
+    initialValue: "feature-based",
+  });
+  if (isCancel(architecture)) onCancel();
+
+  const language = await select({
+    message: "Which language do you want to use?",
+    options: [
+      { label: "TypeScript", value: "ts" },
+      { label: "JavaScript", value: "js" },
+    ],
+    initialValue: "ts",
+  });
+  if (isCancel(language)) onCancel();
+
+  const cssFramework = await select({
+    message: "Which CSS framework do you want to use?",
+    options: [
+      { label: "Tailwind CSS", value: "tailwind" },
+      { label: "Bootstrap", value: "bootstrap" },
+      { label: "None", value: "none" },
+    ],
+    initialValue: "tailwind",
+  });
+  if (isCancel(cssFramework)) onCancel();
+
+  const testing = await select({
+    message: "Which testing framework do you want to set up?",
+    options: [
+      { label: "Vitest", value: "vitest" },
+      { label: "Jest", value: "jest" },
+      { label: "None", value: "none" },
+    ],
+    initialValue: "vitest",
+  });
+  if (isCancel(testing)) onCancel();
+
+  const router = await confirm({
+    message: "Would you like to install React Router?",
+    initialValue: true,
+  });
+  if (isCancel(router)) onCancel();
+
+  const stateManagement = await select({
+    message: "Which state management library do you want to use?",
+    options: [
+      { label: "None", value: "none" },
+      { label: "Redux Toolkit", value: "redux" },
+      { label: "Zustand", value: "zustand" },
+    ],
+    initialValue: "none",
+  });
+  if (isCancel(stateManagement)) onCancel();
+
+  const iconLibrary = await select({
+    message: "Which icon library would you like to use?",
+    options: [
+      { label: "None", value: "none" },
+      { label: "Lucide Icons", value: "lucide" },
+      { label: "Huge Icons", value: "huge" },
+    ],
+    initialValue: "none",
+  });
+  if (isCancel(iconLibrary)) onCancel();
+
+  const axios = await confirm({
+    message: "Would you like to install Axios?",
+    initialValue: false,
+  });
+  if (isCancel(axios)) onCancel();
+
+  const gitInit = await confirm({
+    message: "Would you like to initialize a Git repository?",
+    initialValue: false,
+  });
+  if (isCancel(gitInit)) onCancel();
+
+  const linter = await select({
+    message: "Which linter do you want to use?",
+    options: [
+      { label: "ESLint", value: "eslint", hint: "Industry standard JavaScript linter (Recommended)" },
+      { label: "Oxlint", value: "oxlint", hint: "Fast Rust-based linter" },
+      { label: "None", value: "none" },
+    ],
+    initialValue: "eslint",
+  });
+  if (isCancel(linter)) onCancel();
+
+  const readme = await confirm({
+    message: "Would you like to generate a README.md and LICENSE?",
+    initialValue: true,
+  });
+  if (isCancel(readme)) onCancel();
+
+  const responses = {
+    projectName,
+    architecture,
+    language,
+    cssFramework,
+    testing,
+    router,
+    stateManagement,
+    iconLibrary,
+    axios,
+    linter,
+    gitInit,
+    readme,
+  };
+
+  await saveConfig(responses);
+  return responses;
+}