vue-art-e4n 0.0.1

package/core/featureRules.js

@@ -0,0 +1,35 @@
+import { EXCLUSIVE_RULES, STORE_ARCHITECTURE_RULES } from "../config/rules.js";
+
+/**
+ * Disables feature choices based on exclusive selection rules.
+ *
+ * @param {string[]} selectedFeatures - Features currently selected by the user.
+ * @param {Array<{ value: string, label: string, disabled?: string }>} featureChoices - All available feature choices.
+ * @returns {Array<{ value: string, label: string, disabled?: string }>} Updated feature choices with disabled reasons applied.
+ */
+export function applyExclusiveRules(selectedFeatures, featureChoices) {
+  return featureChoices.map((choice) => {
+    const copy = { ...choice };
+    EXCLUSIVE_RULES.forEach((rule) => {
+      if (
+        selectedFeatures.includes(rule.ifSelected) &&
+        rule.disable === choice.value
+      ) {
+        copy.disabled = rule.reason;
+      }
+    });
+    return copy;
+  });
+}
+/**
+ * Filters architectures that are forbidden for a specific store.
+ *
+ * @param {string} store - The selected store type.
+ * @param {string[]} architectures - List of available architectures.
+ * @returns {string[]} Filtered architectures allowed for the store.
+ */
+export function filterArchitecturesByStore(store, architectures) {
+  const rule = STORE_ARCHITECTURE_RULES.find((r) => r.store === store);
+  if (!rule) return architectures;
+  return architectures.filter((a) => !rule.forbiddenArchitectures.includes(a));
+}

package/core/installPackages.js

@@ -0,0 +1,92 @@
+import { execa } from "execa";
+import fs from "fs";
+import path from "path";
+import { createPackageJson } from "./createPackageJson.js";
+/**
+ * Installs npm dependencies using selected package manager.
+ * Handles Ctrl+C interruption gracefully.
+ *
+ * @param {Object} options
+ * @param {string} options.projectDir
+ * @param {"npm"|"yarn"|"pnpm"} options.packageManager
+ * @param {string[]} options.features
+ * @param {string} options.framework
+ *
+ * @returns {Promise<void>}
+ */
+export async function installPackages({
+  projectDir,
+  framework,
+  features,
+  packageManager,
+  projectName,
+}) {
+  const pkgPath = path.join(projectDir, "package.json");
+  if (!fs.existsSync(pkgPath)) {
+    const { CORE_PACKAGES, PACKAGE_MAP } = await import(
+      "../config/packages.js"
+    );
+    const packages = new Set();
+    CORE_PACKAGES[framework]?.forEach((p) => packages.add(p));
+    features.forEach((f) => {
+      const pkgList = PACKAGE_MAP[framework]?.[f];
+      if (pkgList) pkgList.forEach((p) => packages.add(p));
+    });
+    createPackageJson({
+      projectDir,
+      projectName,
+      framework,
+      features,
+      packages: [...packages],
+    });
+    console.log("📝 Created package.json");
+  }
+
+  const pkgContent = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+  const hasDependencies =
+    (pkgContent.dependencies &&
+      Object.keys(pkgContent.dependencies).length > 0) ||
+    (pkgContent.devDependencies &&
+      Object.keys(pkgContent.devDependencies).length > 0);
+
+  if (!hasDependencies) {
+    console.log("No packages to install.");
+    return;
+  }
+
+  console.log(`\n📦 Installing packages with ${packageManager}...\n`);
+
+  let args = [];
+  if (packageManager === "npm") args = ["install"];
+  if (packageManager === "yarn") args = ["install"];
+  if (packageManager === "pnpm") args = ["install"];
+
+  try {
+    const subprocess = execa(packageManager, args, {
+      cwd: projectDir,
+      stdio: "inherit",
+    });
+
+    await subprocess;
+    console.log("\n✅ Packages installed successfully!\n");
+  } catch (error) {
+    if (
+      error.signal === "SIGINT" ||
+      error.code === "SIGINT" ||
+      error.exitCode === 130 ||
+      error.code === 130 ||
+      error.message?.includes("SIGINT") ||
+      error.message?.includes("canceled") ||
+      error.message?.includes("User force closed")
+    ) {
+      const sigintError = new Error(
+        "Installation interrupted by user (SIGINT)"
+      );
+      sigintError.signal = "SIGINT";
+      sigintError.code = "SIGINT";
+      sigintError.exitCode = 130;
+      throw sigintError;
+    }
+    throw error;
+  }
+}

package/core/runCLI.js

@@ -0,0 +1,67 @@
+import chalk from "chalk";
+import path from "path";
+import { collectProjectConfig } from "./steps/collectProjectConfig.js";
+import { reviewAndConfirm } from "./steps/reviewAndConfirm.js";
+import { createProjectStructure } from "./createProjectStructure.js";
+import { createPackageJson } from "./createPackageJson.js";
+import { installPackages } from "./installPackages.js";
+
+/**
+ * Main CLI workflow controller.
+ *
+ * Responsibilities:
+ * - Collect user configuration
+ * - Allow review & editing
+ * - Generate project structure
+ * - Generate package.json
+ * - Optionally install dependencies
+ *
+ * @returns {Promise<void>}
+ */
+export async function runCLI() {
+  try {
+    const config = await collectProjectConfig();
+
+    const confirmed = await reviewAndConfirm(config);
+    if (!confirmed) {
+      console.log(chalk.yellow("Project creation canceled."));
+      return;
+    }
+
+    const projectDir = path.resolve(process.cwd(), config.projectName);
+
+    createProjectStructure(config);
+
+    createPackageJson({
+      projectDir,
+      ...config,
+    });
+
+    console.log("📝 Created package.json");
+
+    if (confirmed.installNodeModules) {
+      await installPackages({
+        projectDir,
+        ...config,
+      });
+    }
+
+    console.log(chalk.green("\n✨ Project created successfully!\n"));
+    const pm = confirmed.packageManager || "npm";
+    const pmCommand = pm === "yarn" ? "yarn" : pm === "pnpm" ? "pnpm" : "npm";
+
+    console.log(chalk.cyan("📋 Next steps:\n"));
+    console.log(chalk.cyan(`  cd ${confirmed.projectName}`));
+    if (!confirmed.installNodeModules) {
+      console.log(chalk.yellow(`  ${pmCommand} install`));
+    }
+    console.log(chalk.cyan(`  ${pmCommand} run dev\n`));
+  } catch (error) {
+    if (error?.name === "ExitPromptError") {
+      console.log(chalk.yellow("\n⛔ Operation canceled.\n"));
+      process.exit(0);
+    }
+
+    throw error;
+  }
+}

package/core/selectArchitecture.js

@@ -0,0 +1,89 @@
+/**
+ * Prompts the user to select a project architecture.
+ * Filters available architectures based on store and recommends an optimal choice.
+ *
+ * @param {Object} options
+ * @param {"vue"|"vuetify"|"nuxt"} options.framework - Selected framework.
+ * @param {string} options.scale - Project scale (e.g., small, medium, large).
+ * @param {string} options.lifetime - Expected project lifetime.
+ * @param {string[]} options.features - Selected project features.
+ * @param {Record<string, string[]>} options.ARCHITECTURES - Available architectures per framework.
+ * @param {function} options.filterArchitecturesByStore - Function to filter architectures by store.
+ * @param {function} options.getRecommendedArchitecture - Function returning recommended architecture.
+ * @param {function} options.confirmPrompt - Async function to prompt user for yes/no confirmation.
+ * @param {function} options.singleChoiceCheckbox - Async function to prompt user to select a single option.
+ * @param {boolean} [options.skipRecommendation=false] - If true, skip recommendation and show list directly.
+ * @param {string} [options.currentArchitecture] - Current architecture value (for edit mode).
+ * @returns {Promise<string>} Selected or recommended architecture.
+ */
+export async function selectArchitecture({
+  framework,
+  scale,
+  lifetime,
+  features,
+  ARCHITECTURES,
+  filterArchitecturesByStore,
+  getRecommendedArchitecture,
+  confirmPrompt,
+  singleChoiceCheckbox,
+  skipRecommendation = false,
+  currentArchitecture,
+}) {
+  let architectures = ARCHITECTURES[framework];
+
+  if (!architectures || architectures.length === 0) {
+    throw new Error(
+      `No architectures defined for framework: ${framework}. Available frameworks: ${Object.keys(ARCHITECTURES).join(", ")}`
+    );
+  }
+
+  architectures = filterArchitecturesByStore(
+    features.includes("pinia")
+      ? "pinia"
+      : features.includes("vuex")
+      ? "vuex"
+      : null,
+    architectures
+  );
+
+  if (!architectures || architectures.length === 0) {
+    throw new Error(
+      `No architectures available after filtering for framework: ${framework}`
+    );
+  }
+
+  if (skipRecommendation) {
+    return singleChoiceCheckbox({
+      name: "architecture",
+      message: "Select architecture:",
+      choices: architectures.map((a) => ({ name: a, value: a })),
+      defaultValue: currentArchitecture && architectures.includes(currentArchitecture)
+        ? currentArchitecture
+        : undefined,
+    });
+  }
+
+  const recommended = getRecommendedArchitecture({
+    framework,
+    scale,
+    lifetime,
+    features,
+  });
+
+  const isRecommendedAvailable = architectures.includes(recommended);
+
+  if (isRecommendedAvailable) {
+    const useRecommended = await confirmPrompt(
+      `Recommended architecture: "${recommended}". Use it?`,
+      true
+    );
+
+    if (useRecommended) return recommended;
+  }
+
+  return singleChoiceCheckbox({
+    name: "architecture",
+    message: "Select architecture:",
+    choices: architectures.map((a) => ({ name: a, value: a })),
+  });
+}

package/core/steps/collectProjectConfig.js

@@ -0,0 +1,103 @@
+import { singleChoiceCheckbox, confirmPrompt } from "../../helpers/prompts.js";
+import { FEATURE_CHOICES } from "../../config/featuresConfig.js";
+import {
+  ARCHITECTURES,
+  getRecommendedArchitecture,
+} from "../../config/architectures.js";
+import {
+  applyExclusiveRules,
+  filterArchitecturesByStore,
+} from "../featureRules.js";
+import { selectArchitecture } from "../selectArchitecture.js";
+import inquirer from "inquirer";
+
+export async function collectProjectConfig() {
+  const { projectName } = await inquirer.prompt([
+    {
+      type: "input",
+      name: "projectName",
+      message: "Project name:",
+      validate: (v) => (v && !v.includes(" ") ? true : "Invalid project name"),
+    },
+  ]);
+
+  const framework = await singleChoiceCheckbox({
+    name: "framework",
+    message: "Select project type:",
+    choices: [
+      { name: "Vue", value: "vue" },
+      { name: "Nuxt 3", value: "nuxt" },
+      { name: "Vue 3 + Vuetify", value: "vuetify" },
+    ],
+  });
+
+  let features = [];
+  const featureChoices = applyExclusiveRules(features, FEATURE_CHOICES);
+  const featureResult = await inquirer.prompt([
+    {
+      type: "checkbox",
+      name: "features",
+      message: "Select features:",
+      choices: featureChoices,
+    },
+  ]);
+  features = featureResult.features;
+
+  const store = await singleChoiceCheckbox({
+    name: "store",
+    message: "Select store:",
+    choices: [
+      { name: "None", value: null },
+      { name: "Pinia", value: "pinia" },
+      { name: "Vuex", value: "vuex" },
+    ],
+  });
+  if (store) features.push(store);
+
+  const scale = await singleChoiceCheckbox({
+    name: "scale",
+    message: "Project scale:",
+    choices: [
+      { name: "Small", value: "small" },
+      { name: "Medium", value: "medium" },
+      { name: "Large", value: "large" },
+    ],
+  });
+
+  const lifetime = await singleChoiceCheckbox({
+    name: "lifetime",
+    message: "Project lifetime:",
+    choices: [
+      { name: "Short-term", value: "short" },
+      { name: "Long-term", value: "long" },
+    ],
+  });
+
+  const architecture = await selectArchitecture({
+    framework,
+    scale,
+    lifetime,
+    features,
+    ARCHITECTURES,
+    filterArchitecturesByStore,
+    getRecommendedArchitecture,
+    confirmPrompt,
+    singleChoiceCheckbox,
+  });
+
+  const packageManager = await singleChoiceCheckbox({
+    name: "packageManager",
+    message: "Select package manager:",
+    choices: ["npm", "yarn", "pnpm"].map((v) => ({ name: v, value: v })),
+  });
+
+  return {
+    projectName,
+    framework,
+    features,
+    architecture,
+    scale,
+    lifetime,
+    packageManager,
+  };
+}

package/core/steps/finalizeProject.js

@@ -0,0 +1,24 @@
+import path from "path";
+import chalk from "chalk";
+import { createProjectStructure } from "../createProjectStructure.js";
+import { createPackageJson } from "../createPackageJson.js";
+import { installPackages } from "../installPackages.js";
+import { getPackagesList } from "../utils/getPackagesList.js";
+
+export async function finalizeProject(config) {
+  const projectDir = path.resolve(process.cwd(), config.projectName);
+  const packages = getPackagesList(config.framework, config.features);
+
+  createProjectStructure(config);
+  createPackageJson({ ...config, projectDir, packages });
+
+  const install = await import("../../helpers/prompts.js").then((m) =>
+    m.confirmPrompt("Install node_modules now?", true)
+  );
+
+  if (install) {
+    await installPackages({ ...config, projectDir });
+  }
+
+  console.log(chalk.green("\n✨ Project created successfully!\n"));
+}

package/core/steps/reviewAndConfirm.js

@@ -0,0 +1,242 @@
+import { confirmPrompt, singleChoiceCheckbox } from "../../helpers/prompts.js";
+import { getPackagesList } from "../utils/getPackagesList.js";
+import inquirer from "inquirer";
+import { FEATURE_CHOICES } from "../../config/featuresConfig.js";
+import {
+  ARCHITECTURES,
+  getRecommendedArchitecture,
+} from "../../config/architectures.js";
+import {
+  applyExclusiveRules,
+  filterArchitecturesByStore,
+} from "../featureRules.js";
+import { selectArchitecture } from "../selectArchitecture.js";
+
+/**
+ * Allows user to edit individual configuration options
+ */
+async function editConfig(config) {
+  let editedConfig = { ...config };
+
+  // Edit project name
+  if (
+    await confirmPrompt(
+      `Edit project name? (Current: ${config.projectName})`,
+      false
+    )
+  ) {
+    const { projectName } = await inquirer.prompt([
+      {
+        type: "input",
+        name: "projectName",
+        message: "Project name:",
+        default: config.projectName,
+        validate: (v) =>
+          v && !v.includes(" ") ? true : "Invalid project name",
+      },
+    ]);
+    editedConfig.projectName = projectName;
+  }
+
+  // Edit framework
+  if (
+    await confirmPrompt(`Edit framework? (Current: ${config.framework})`, false)
+  ) {
+    editedConfig.framework = await singleChoiceCheckbox({
+      name: "framework",
+      message: "Select project type:",
+      choices: [
+        { name: "Vue", value: "vue" },
+        { name: "Nuxt 3", value: "nuxt" },
+        { name: "Vue 3 + Vuetify", value: "vuetify" },
+      ],
+      defaultValue: config.framework,
+    });
+  }
+
+  // Edit features
+  const currentStore = config.features.find(
+    (f) => f === "pinia" || f === "vuex"
+  );
+  const featuresWithoutStore = config.features.filter(
+    (f) => f !== "pinia" && f !== "vuex"
+  );
+
+  if (
+    await confirmPrompt(
+      `Edit features? (Current: ${config.features.join(", ") || "none"})`,
+      false
+    )
+  ) {
+    const featureChoices = applyExclusiveRules(
+      featuresWithoutStore,
+      FEATURE_CHOICES
+    );
+    const featureResult = await inquirer.prompt([
+      {
+        type: "checkbox",
+        name: "features",
+        message: "Select features:",
+        choices: featureChoices,
+        default: featuresWithoutStore,
+      },
+    ]);
+    editedConfig.features = featureResult.features;
+  } else {
+    // Keep features as is (without store, we'll add it separately)
+    editedConfig.features = [...featuresWithoutStore];
+  }
+
+  // Edit store (separate question)
+  if (
+    await confirmPrompt(
+      `Edit store? (Current: ${currentStore || "None"})`,
+      false
+    )
+  ) {
+    const store = await singleChoiceCheckbox({
+      name: "store",
+      message: "Select store:",
+      choices: [
+        { name: "None", value: null },
+        { name: "Pinia", value: "pinia" },
+        { name: "Vuex", value: "vuex" },
+      ],
+      defaultValue: currentStore || null,
+    });
+    if (store) editedConfig.features.push(store);
+  } else if (currentStore) {
+    // Keep old store if not editing
+    editedConfig.features.push(currentStore);
+  }
+
+  // Edit scale
+  if (
+    await confirmPrompt(`Edit project scale? (Current: ${config.scale})`, false)
+  ) {
+    editedConfig.scale = await singleChoiceCheckbox({
+      name: "scale",
+      message: "Project scale:",
+      choices: [
+        { name: "Small", value: "small" },
+        { name: "Medium", value: "medium" },
+        { name: "Large", value: "large" },
+      ],
+      defaultValue: config.scale,
+    });
+  }
+
+  // Edit lifetime
+  if (
+    await confirmPrompt(
+      `Edit project lifetime? (Current: ${config.lifetime})`,
+      false
+    )
+  ) {
+    editedConfig.lifetime = await singleChoiceCheckbox({
+      name: "lifetime",
+      message: "Project lifetime:",
+      choices: [
+        { name: "Short-term", value: "short" },
+        { name: "Long-term", value: "long" },
+      ],
+      defaultValue: config.lifetime,
+    });
+  }
+
+  // Edit architecture
+  if (
+    await confirmPrompt(
+      `Edit architecture? (Current: ${editedConfig.architecture})`,
+      false
+    )
+  ) {
+    editedConfig.architecture = await selectArchitecture({
+      framework: editedConfig.framework,
+      scale: editedConfig.scale,
+      lifetime: editedConfig.lifetime,
+      features: editedConfig.features,
+      ARCHITECTURES,
+      filterArchitecturesByStore,
+      getRecommendedArchitecture,
+      confirmPrompt,
+      singleChoiceCheckbox,
+      skipRecommendation: true,
+      currentArchitecture: editedConfig.architecture,
+    });
+  }
+
+  // Edit package manager
+  if (
+    await confirmPrompt(
+      `Edit package manager? (Current: ${config.packageManager})`,
+      false
+    )
+  ) {
+    editedConfig.packageManager = await singleChoiceCheckbox({
+      name: "packageManager",
+      message: "Select package manager:",
+      choices: ["npm", "yarn", "pnpm"].map((v) => ({ name: v, value: v })),
+      defaultValue: config.packageManager,
+    });
+  }
+
+  return editedConfig;
+}
+
+export async function reviewAndConfirm(config) {
+  const packages = getPackagesList(config.framework, config.features);
+
+  // Ask if user wants to edit
+  const wantsToEdit = await confirmPrompt(
+    `
+Project: ${config.projectName}
+Framework: ${config.framework}
+Architecture: ${config.architecture}
+Features: ${config.features.join(", ") || "none"}
+Packages: ${packages.join(", ") || "none"}
+
+Do you want to edit any of these options?`,
+    false
+  );
+
+  let finalConfig = config;
+  if (wantsToEdit) {
+    finalConfig = await editConfig(config);
+    // Show updated config and ask again
+    const updatedPackages = getPackagesList(
+      finalConfig.framework,
+      finalConfig.features
+    );
+    const proceed = await confirmPrompt(
+      `
+Updated configuration:
+Project: ${finalConfig.projectName}
+Framework: ${finalConfig.framework}
+Architecture: ${finalConfig.architecture}
+Features: ${finalConfig.features.join(", ") || "none"}
+Packages: ${updatedPackages.join(", ") || "none"}
+Proceed?`,
+      true
+    );
+
+    if (!proceed) {
+      return null;
+    }
+  } else {
+    const proceed = await confirmPrompt("Proceed?", true);
+    if (!proceed) {
+      return null;
+    }
+  }
+
+  const installNodeModules = await confirmPrompt(
+    "Do you want to install dependencies?",
+    true
+  );
+
+  return {
+    ...finalConfig,
+    installNodeModules,
+  };
+}

package/core/utils/getPackagesList.js

@@ -0,0 +1,29 @@
+import { CORE_PACKAGES, PACKAGE_MAP } from "../../config/packages.js";
+
+/**
+ * Generates a unique list of npm packages based on framework and selected features.
+ *
+ * - Includes core framework packages
+ * - Merges feature-based packages
+ * - Automatically removes duplicates
+ *
+ * @param {"vue"|"nuxt"|"vuetify"} framework
+ * The selected framework.
+ *
+ * @param {string[]} features
+ * List of enabled features (e.g. ["pinia", "eslint", "tailwind"]).
+ *
+ * @returns {string[]}
+ * A deduplicated array of npm package names.
+ */
+export function getPackagesList(framework, features) {
+  const set = new Set(CORE_PACKAGES[framework] || []);
+
+  features.forEach((feature) => {
+    PACKAGE_MAP[framework]?.[feature]?.forEach((pkg) => {
+      set.add(pkg);
+    });
+  });
+
+  return [...set];
+}