ember.nvp 0.1.0 → 0.2.0

package/src/cli/generator.js

@@ -1,19 +1,74 @@
 import { mkdir } from "node:fs/promises";
 
+import baseApp from "#bases/minimal-app";
+import baseLibrary from "#bases/minimal-library";
+import { consolidateLintingScripts } from "../consolidators/linting.js";
+import { hasGit } from "#utils/git.js";
 /**
  * Generate project files by running layer functions
+ *
+ * @param {import('#utils/project.js').Project} project
  */
-export async function generateProject(projectPath, projectName, layers) {
-  // Create project directory
-  await mkdir(projectPath, { recursive: true });
-
-  // Run each layer's run function in sequence
-  for (const layer of layers) {
-    if (typeof layer.run === "function") {
-      await layer.run({
-        targetDir: projectPath,
-        projectName,
-      });
+export async function generateProject(project) {
+  await mkdir(project.directory, { recursive: true });
+
+  switch (project.desires.type) {
+    case "app":
+      await baseApp.run(project);
+      break;
+    case "library":
+      await baseLibrary.run(project);
+      break;
+  }
+
+  /**
+   * We could run these in a loop until there is no git diff
+   */
+  await runLap(project);
+
+  if (hasGit(project.directory)) {
+    await project.gitAdd();
+
+    if (await project.gitHasDiff()) {
+      let layerNames = project.desires.layers.map((l) => l.name).join(", ");
+      await project.gitCommit(
+        `[ember.nvp] Applied ${layerNames} to ${project.type}: ${project.name} -- Please report issues to https://github.com/NullVoxPopuli/ember.nvp/`,
+      );
     }
   }
+
+  await runLap(project);
+
+  if (hasGit(project.directory) && (await project.gitHasDiff())) {
+    await project.gitAdd();
+    await project.gitCommit(
+      `[ember.nvp] Consolidation commit -- Please report issues to https://github.com/NullVoxPopuli/ember.nvp/`,
+    );
+  }
+
+  await runLap(project);
+
+  if (hasGit(project.directory) && (await project.gitHasDiff())) {
+    await project.gitAdd();
+    await project.gitCommit(
+      `[ember.nvp] Consolidation commit -- Please report issues to https://github.com/NullVoxPopuli/ember.nvp/`,
+    );
+  }
+}
+
+/**
+ *
+ * @param {import('#utils/project.js').Project} project
+ */
+async function runLap(project) {
+  for (const layer of project.desires.layers) {
+    if (typeof layer.run !== "function") {
+      console.warn(`${layer.name} is not implemented`);
+      continue;
+    }
+
+    await layer.run(project);
+  }
+
+  await consolidateLintingScripts(project);
 }

package/src/cli/index.js

@@ -1,44 +1,75 @@
 #!/usr/bin/env node
 
 import * as p from "@clack/prompts";
-import { join } from "node:path";
-import pc from "picocolors";
 import { generateProject } from "./generator.js";
-import { askName } from './questions/name.js';
-import { askLayers } from './questions/layers.js';
-import { askPackageManager } from './questions/package-manager.js';
+import { askName } from "./questions/name.js";
+import { askLayers } from "./questions/layers.js";
+import { askProjectType } from "./questions/project-type.js";
+import { askPackageManager } from "./questions/package-manager.js";
+import { askPath } from "./questions/path.js";
+import { askIfOK } from "./questions/ok.js";
+import { styleText } from "node:util";
+import { Project } from "#utils/project.js";
 
+/**
+ * This whole file's primary purpose is to be an interactive CLI
+ * for `generateProject`.
+ *
+ * Other tools can call `generateProject` themselves if they wish
+ * if they want to provide different TUI/GUIs.
+ */
 async function main() {
   console.clear();
 
-  p.intro(pc.bgCyan(pc.black(" ember.nvp ")));
+  p.intro(styleText(["bgCyan", "black"], " ember.nvp "));
 
   const projectName = await askName();
+  const projectPath = await askPath(projectName);
+  const projectType = await askProjectType();
   const selectedLayers = await askLayers();
   const packageManager = await askPackageManager();
 
+  let project = new Project(projectPath, {
+    name: projectName,
+    type: projectType,
+    path: projectPath,
+    layers: selectedLayers,
+    packageManager,
+  });
+
+  await askIfOK();
+
   const s = p.spinner();
   s.start("Creating your Ember app...");
 
   try {
     // Generate the project
-    const projectPath = join(process.cwd(), projectName);
-    await generateProject(projectPath, projectName, selectedLayers);
+    await generateProject(project);
 
     s.stop("Project created!");
 
     p.note(
       `cd ${projectName}\n` +
-      `${packageManager} install\n` +
-      `${packageManager} ${packageManager === "npm" ? "run " : ""}start`,
+        `${packageManager} install\n` +
+        `${packageManager} ${packageManager === "npm" ? "run " : ""}start`,
       "Next steps",
     );
 
-    p.outro(pc.green("✓") + " Project ready! " + pc.dim("Happy coding!"));
+    p.outro(styleText("green", "✓") + " Project ready! " + styleText("dim", "Happy coding!"));
   } catch (err) {
     s.stop("Failed to create project");
-    p.cancel(`Error: ${err.message}`);
-    throw err;
+
+    if (err instanceof Error) {
+      p.cancel(`Error: ${err.message}`);
+      if (err.stack) {
+        console.error(err.stack);
+      }
+
+      process.exit(1);
+    }
+
+    p.cancel(`Error: ${String(err)}`);
+    process.exit(1);
   }
 }
 

package/src/cli/questions/layers.js

@@ -1,31 +1,53 @@
-import { readdir } from "node:fs/promises";
-import { join } from "node:path";
+import { answers, printArgInUse } from "#args";
+import { discoverLayers } from "#layers";
 
 import * as p from "@clack/prompts";
 
 export async function askLayers() {
+  const optionalLayers = (await discoverLayers()).filter(
+    (layer) => typeof layer.run === "function",
+  );
 
-  // Discover available layers
-  const layers = await discoverLayers();
+  const supported = new Set(optionalLayers.map((layer) => layer.name));
 
-  // Separate minimal from other layers
-  const minimalLayer = layers.find((l) => l.name === "minimal");
-  const optionalLayers = layers.filter((l) => l.name !== "minimal");
+  /**
+   *
+   * @param {string[] | undefined} selected
+   * @returns {selected is string[]}
+   */
+  function isValid(selected) {
+    if (!selected) return false;
+    if (Array.isArray(selected) && selected.length === 0) return false;
 
-  p.note(
-    `${pc.cyan("minimal")} layer is always included.\n` +
-    'It provides: type: "module", no compat, no testing, no linting.\n' +
-    "Perfect for demos and reproductions.",
-    "Base Layer",
-  );
+    return selected.every((name) => supported.has(name));
+  }
+
+  if (isValid(answers.layers)) {
+    let result = optionalLayers.filter((layer) => answers.layers.includes(layer.name));
+
+    printArgInUse(`layers`, result.map((layer) => layer.name).join(", "));
+
+    return result;
+  }
+
+  // Whenever we have a yes/no option, we use string values rather than true/false
+  const defaultValues = (
+    await Promise.all(
+      optionalLayers.map(async (layer) => {
+        let result = await layer.defaultValue?.();
+
+        return result && layer.name;
+      }),
+    )
+  ).filter(Boolean);
 
-  // Let user select additional features
   const selectedFeatures = await p.multiselect({
     message: "Select additional features:",
+    initialValues: defaultValues,
     options: optionalLayers.map((layer) => ({
       value: layer.name,
-      label: layer.label || layer.name,
-      hint: layer.description,
+      label: layer.label ?? layer.name,
+      hint: layer.hint,
     })),
     required: false,
   });
@@ -36,40 +58,7 @@ export async function askLayers() {
   }
 
   // Build the final configuration
-  const selectedLayers = [
-    minimalLayer,
-    ...optionalLayers.filter((l) => selectedFeatures.includes(l.name)),
-  ].filter(Boolean);
+  const selectedLayers = optionalLayers.filter((layer) => selectedFeatures.includes(layer.name));
 
   return selectedLayers;
-
-}
-
-async function discoverLayers() {
-  const layersDir = join(import.meta.dirname, '..', "..", "layers");
-  const entries = await readdir(layersDir, { withFileTypes: true });
-
-  const layers = [];
-
-  for (const entry of entries) {
-    if (entry.isDirectory()) {
-      const layerPath = join(layersDir, entry.name, "index.js");
-      try {
-        const layer = await import(layerPath);
-        layers.push({
-          name: entry.name,
-          ...layer.default,
-        });
-      } catch (err) {
-        // Skip layers that don't have proper exports
-        console.warn(
-          `Warning: Could not load layer ${entry.name}:`,
-          err.message,
-        );
-      }
-    }
-  }
-
-  return layers;
 }
-

package/src/cli/questions/name.js

@@ -1,14 +1,30 @@
 import * as p from "@clack/prompts";
 
+import packageNameRegex from "package-name-regex";
+import { answers, printArgInUse } from "#args";
+
+const DEFAULT = "my-app";
+
 export async function askName() {
+  if (answers.name) {
+    let isValid = packageNameRegex.test(answers.name);
+    if (isValid) {
+      printArgInUse("name", answers.name);
+
+      return answers.name;
+    }
+  }
   const projectName = await p.text({
     message: "What is your project name?",
-    placeholder: "my-app",
-    defaultValue: 'my-app',
+    placeholder: DEFAULT,
+    defaultValue: DEFAULT,
     validate(value) {
-      if (value.length === 0) return "Project name is required";
-      if (!/^[a-z0-9-]+$/.test(value)) {
-        return "Project name must be lowercase and can only contain letters, numbers, and hyphens";
+      if (value.length === 0) return;
+
+      let isValid = packageNameRegex.test(value);
+
+      if (!isValid) {
+        return "Project name must be a valid npm package-name";
       }
     },
   });
@@ -18,5 +34,5 @@ export async function askName() {
     return process.exit(0);
   }
 
-  return projectName;
+  return projectName ?? DEFAULT;
 }

package/src/cli/questions/ok.js

@@ -0,0 +1,38 @@
+import * as p from "@clack/prompts";
+import { answers, printArgInUse } from "#args";
+
+const SUPPORTED = new Set(["yes", "no"]);
+
+/**
+ *
+ * @param {string | undefined} selected
+ * @returns {selected is 'yes' | 'no'}
+ */
+function isValid(selected) {
+  if (!selected) return false;
+
+  return SUPPORTED.has(selected);
+}
+
+export async function askIfOK() {
+  if (isValid(answers.confirm)) {
+    printArgInUse("confirm", answers.confirm);
+
+    return answers.confirm;
+  }
+
+  const answer = await p.select({
+    message: "Do all the selections above look ok?",
+    options: [
+      { value: "yes", label: "yes, generate the project" },
+      { value: "no", label: "no, cancel" },
+    ],
+  });
+
+  if (p.isCancel(answer) || answer === "no") {
+    p.cancel("Operation cancelled");
+    return process.exit(0);
+  }
+
+  return answer;
+}

package/src/cli/questions/package-manager.js

@@ -1,13 +1,35 @@
 import * as p from "@clack/prompts";
+import { answers, printArgInUse } from "#args";
 
+const SUPPORTED = new Set(["pnpm", "npm"]);
+
+/**
+ *
+ * @param {string | undefined} selected
+ * @returns {selected is 'pnpm' | 'npm'}
+ */
+function isValid(selected) {
+  if (!selected) return false;
+
+  return SUPPORTED.has(selected);
+}
+
+/**
+ *
+ * @returns {Promise<import('#types').PackageManager>}
+ */
 export async function askPackageManager() {
+  if (isValid(answers.packageManager)) {
+    printArgInUse("packageManager", answers.packageManager);
+
+    return answers.packageManager;
+  }
 
   const packageManager = await p.select({
     message: "Which package manager?",
     options: [
       { value: "pnpm", label: "pnpm", hint: "Fast, disk space efficient" },
       { value: "npm", label: "npm", hint: "Node default" },
-      { value: "yarn", label: "yarn", hint: "Classic alternative" },
     ],
   });
 
@@ -18,4 +40,3 @@ export async function askPackageManager() {
 
   return packageManager;
 }
-

package/src/cli/questions/path.js

@@ -0,0 +1,59 @@
+import * as p from "@clack/prompts";
+
+import { join } from "node:path";
+import { answers, printArgInUse } from "#args";
+import { cwd } from "#utils/cwd.js";
+
+/**
+ *
+ * @param {string | undefined} value
+ * @returns
+ */
+function isValid(value) {
+  if (!value) return false;
+
+  return value.startsWith(".") || value.startsWith("/");
+}
+
+/**
+ * @param {string} name -- the projectName
+ */
+export async function askPath(name) {
+  if (answers.path) {
+    if (isValid(answers.path)) {
+      printArgInUse("path", answers.path);
+
+      return answers.path;
+    }
+  }
+
+  const defaultValue = join(cwd, name);
+
+  const answer = await p.text({
+    message: "Where would you like to place your project?",
+    placeholder: defaultValue.replace(cwd, "."),
+    defaultValue: defaultValue,
+    validate(value) {
+      if (value.length === 0) return;
+
+      if (!isValid(value)) {
+        return `Path must start with a '.' or '/' (be either a relative or absolute path)`;
+      }
+    },
+  });
+
+  if (p.isCancel(answer)) {
+    p.cancel("Operation cancelled");
+    return process.exit(0);
+  }
+
+  if (answer) {
+    if (answer.startsWith(".")) {
+      return join(cwd, answer);
+    }
+
+    return answer;
+  }
+
+  return defaultValue;
+}

package/src/cli/questions/project-type.js

@@ -0,0 +1,55 @@
+import * as p from "@clack/prompts";
+import { answers, printArgInUse } from "#args";
+
+/**
+ * addon is alias for library
+ */
+const SUPPORTED = new Set(["app", "library", "addon"]);
+
+/**
+ * @param {string | undefined} selected
+ * @returns {selected is "app" | "library" | "addon"}
+ */
+function isValid(selected) {
+  if (!selected) return false;
+
+  return SUPPORTED.has(selected);
+}
+
+/**
+ *
+ * @return {Promise<import('#types').ProjectType>}
+ */
+export async function askProjectType() {
+  if (isValid(answers.type)) {
+    printArgInUse("type", answers.type);
+
+    if (answers.type === "addon") return "library";
+
+    return answers.type;
+  }
+
+  const answer = await p.select({
+    message: "Which type of project?",
+    options: [
+      { value: "app", label: "web app", hint: "generates html, js, and css to deploy to the web" },
+      {
+        value: "library",
+        label: "library",
+        hint: "sharable code, usable by other libraries and apps alike",
+      },
+    ],
+  });
+
+  if (answer === "library") {
+    p.cancel("Not implemented yet, apologies!");
+    return process.exit(0);
+  }
+
+  if (p.isCancel(answer)) {
+    p.cancel("Operation cancelled");
+    return process.exit(0);
+  }
+
+  return answer;
+}

package/src/consolidators/linting.js

@@ -0,0 +1,51 @@
+import { getLatest } from "#utils/npm.js";
+import { packageJson } from "ember-apply";
+
+/**
+ * @param {import('#utils/project.js').Project} project
+ */
+export async function consolidateLintingScripts(project) {
+  // todo
+}
+
+/**
+ * @param {import('#utils/project.js').Project} project
+ */
+export async function maybeLintWithConcurrently(project) {
+  /** @type {Record<string, boolean>} */
+  let linting = {
+    prettier: false,
+    eslint: false,
+    "ember-template-lint": false,
+    stylelint: false,
+  };
+
+  let count = 0;
+  let manifest = await packageJson.read(project.directory);
+
+  for (let script of Object.values(manifest.scripts)) {
+    for (let bin of Object.keys(linting)) {
+      if (script.includes(bin)) {
+        linting[bin] = true;
+        count++;
+      }
+    }
+  }
+
+  if (count > 1) {
+    await packageJson.modify(async (json) => {
+      json.scripts ||= {};
+      json.devDependencies ||= {};
+      json.scripts.lint = 'concurrently "pnpm:lint:*(!fix)" --names "lint:" --prefixColors auto';
+      json.scripts["lint:fix"] =
+        'concurrently "pnpm:lint:*:fix" --names "fix:" --prefixColors auto && pnpm format';
+
+      Object.assign(
+        json.devDependencies,
+        await getLatest({
+          concurrently: "^9.2.1",
+        }),
+      );
+    }, project.directory);
+  }
+}

package/src/index.js

@@ -0,0 +1,2 @@
+export { generateProject } from "./cli/generator.js";
+export { Project } from "./utils/project.js";

package/src/layers/eslint-bundled-ember/files/eslint.config.js

@@ -0,0 +1,14 @@
+/**
+ * This tries to follow what the official blueprints are doing more closely
+ * but in a way that abstracts the dependencies and configuration
+ * out of your project.
+ *
+ * Handles: (G)TS + (G)JS, QUnit, Supporting Node files
+ */
+import { ember } from "ember-eslint";
+
+export default [
+  ...ember.recommended(import.meta.dirname),
+  // your modifications here
+  // see: https://eslint.org/docs/user-guide/configuring/configuration-files#how-do-overrides-work
+];

package/src/layers/eslint-bundled-ember/index.js

@@ -0,0 +1,91 @@
+import { getLatest } from "#utils/npm.js";
+import { files, packageJson } from "ember-apply";
+import { formatLabel } from "#utils/cli.js";
+import { maybeLintWithConcurrently } from "#consolidators/linting.js";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { hasDevDeps } from "#utils/manifest.js";
+
+/**
+ * @type {import('#types').Layer}
+ */
+export default {
+  label: formatLabel("ESLint", "ember's encapsulated config"),
+  hint: `Minimal dependencies added to package.json. Not official, but follows the official configuration`,
+
+  async run(project) {
+    await files.applyFolder(join(import.meta.dirname, "files"), project.directory);
+
+    await packageJson.addDevDependencies(
+      await getLatest({
+        "ember-eslint": "^0.6.1",
+        eslint: "^9.39.2",
+      }),
+      project.directory,
+    );
+
+    await packageJson.addScripts(
+      {
+        "lint:eslint": "eslint . --cache",
+        "lint:eslint:fix": "eslint . --fix",
+      },
+      project.directory,
+    );
+
+    await maybeLintWithConcurrently(project);
+  },
+
+  /**
+   * @overload
+   * @param {import('#utils/project.js').Project} project
+   * @param {true} explain
+   * @returns {Promise<{ isSetup: boolean; reasons: string[] }>}
+   */
+  /**
+   * @overload
+   * @param {import('#utils/project.js').Project} project
+   * @param {boolean | undefined} [explain]
+   * @returns {Promise<boolean>}
+   */
+  async isSetup(project, explain) {
+    const reasons = [];
+
+    if (!existsSync(join(project.directory, "eslint.config.js"))) {
+      reasons.push("eslint.config.js is missing");
+
+      if (!explain) return false;
+    }
+
+    let manifest = await packageJson.read(project.directory);
+
+    if (!hasDevDeps(manifest, ["ember-eslint", "eslint"])) {
+      reasons.push("missing required dependencies: ember-eslint, eslint");
+
+      if (!explain) return false;
+    }
+
+    let scripts = Object.values(manifest.scripts ?? {}).filter((script) =>
+      script.includes("eslint"),
+    );
+
+    if (!scripts.some((script) => script.includes("--cache"))) {
+      reasons.push("missing eslint script with --cache flag");
+
+      if (!explain) return false;
+    }
+    if (!scripts.some((script) => script.includes("--fix"))) {
+      reasons.push("missing eslint script with --fix flag");
+
+      if (!explain) return false;
+    }
+
+    if (explain) {
+      return {
+        isSetup: reasons.length === 0,
+        reasons,
+      };
+    }
+
+    return reasons.length === 0;
+  },
+};