Update package versions and enhance CLI functionality

- Bump versions for several packages: create-awesome-node-app (0.4.26), @create-node-app/core (0.3.17), eslint-config-base (0.0.2), eslint-config-next (0.0.2), eslint-config-react (0.0.2), eslint-config-ts (0.0.2), and tsconfig (0.0.2).
- Add new CLI options to list available templates and addons.
- Implement functions to handle listing templates and addons in the CLI.
- Update README to include instructions for listing templates and addons.

Author: ulises-jeremias

package-lock.json

@@ -67,6 +67,21 @@ create-awesome-node-app --template react-vite-boilerplate --addons jotai materia
 
 This example uses the `react-vite-boilerplate` template and applies the `jotai`, `material-ui`, and `github-setup` extensions.
 
+### Listing Templates and Addons
+
+You can list all available templates and addons using the following flags:
+
+```sh
+# List all available templates
+create-awesome-node-app --list-templates
+
+# List all available addons
+create-awesome-node-app --list-addons
+
+# List addons compatible with a specific template
+create-awesome-node-app --template react-vite-boilerplate --list-addons
+```
+
 ## 🔗 Full List of Templates and Extensions
 
 You can find the full list of available templates and extensions in the [cna-templates repository](https://github.com/Create-Node-App/cna-templates).

packages/create-awesome-node-app/README.md

@@ -9,6 +9,7 @@ import {
 import { getCnaOptions } from "./options";
 import packageJson from "../package.json";
 import { TemplateOrExtension } from "@create-node-app/core/loaders";
+import { listTemplates, listAddons } from "./list";
 
 const program = new Command();
 
@@ -36,6 +37,8 @@ const main = async () => {
     .option("--use-yarn", "use yarn instead of npm or pnpm")
     .option("--use-pnpm", "use pnpm instead of yarn or npm")
     .option("--interactive", "run in interactive mode to select options", false)
+    .option("--list-templates", "list all available templates")
+    .option("--list-addons", "list all available addons")
     .action((providedProjectName: string | undefined) => {
       projectName = providedProjectName || projectName;
     });
@@ -57,14 +60,26 @@ const main = async () => {
     return;
   }
 
-  const options = await getCnaOptions({ ...opts, projectName });
+  // Handle list templates flag
+  if (opts.listTemplates) {
+    await listTemplates();
+    return;
+  }
+
+  // Handle list addons flag
+  if (opts.listAddons) {
+    await listAddons({
+      templateSlug: opts.template,
+    });
+    return;
+  }
 
-  const { useYarn, usePnpm, ...restOptions } = options;
+  // Extract package manager options directly from opts
+  const { useYarn, usePnpm, ...restOpts } = opts;
   const packageManager = useYarn ? "yarn" : usePnpm ? "pnpm" : "npm";
 
-  const templatesOrExtensions: TemplateOrExtension[] = [restOptions.template]
-    .concat(Array.isArray(restOptions.addons) ? restOptions.addons : [])
-    .concat(Array.isArray(restOptions.extend) ? restOptions.extend : [])
+  const templatesOrExtensions: TemplateOrExtension[] = [restOpts.template]
+    .concat(Array.isArray(restOpts.extend) ? restOpts.extend : [])
     .reduce((acc, templateOrExtension) => {
       if (!templateOrExtension) {
         return acc;
@@ -76,7 +91,7 @@ const main = async () => {
 
   return createNodeApp(
     projectName,
-    { ...restOptions, packageManager, templatesOrExtensions, projectName },
+    { ...restOpts, packageManager, templatesOrExtensions, projectName },
     getCnaOptions
   );
 };

packages/create-awesome-node-app/src/index.ts

@@ -0,0 +1,117 @@
+import chalk from "chalk";
+import {
+  getTemplateCategories,
+  getTemplatesForCategory,
+  getExtensionsGroupedByCategory,
+  getCategoryData,
+} from "./templates";
+
+/**
+ * List all available templates grouped by category
+ */
+export const listTemplates = async () => {
+  const categories = await getTemplateCategories();
+
+  console.log(chalk.bold.blue("\nAvailable Templates:"));
+
+  for (const categorySlug of categories) {
+    const categoryData = await getCategoryData(categorySlug);
+    const templates = await getTemplatesForCategory(categorySlug);
+
+    // Display category name if available, otherwise use the slug
+    const categoryName = categoryData?.name || categorySlug;
+    console.log(chalk.bold.green(`\n${categoryName}:`));
+
+    // Display category description if available
+    if (categoryData?.description) {
+      console.log(`  ${categoryData.description}`);
+    }
+
+    templates.forEach((template) => {
+      console.log(
+        `  ${chalk.yellow(template.name)} (${chalk.cyan(template.slug)})`
+      );
+      console.log(`    ${template.description}`);
+      if (template.labels && template.labels.length > 0) {
+        console.log(`    Keywords: ${template.labels.join(", ")}`);
+      }
+    });
+  }
+};
+
+/**
+ * List all available addons grouped by category
+ * @param templateSlug Optional template slug to filter compatible addons
+ * @param templateType Optional template type to filter compatible addons
+ */
+export const listAddons = async ({
+  templateSlug,
+  templateType,
+}: {
+  templateSlug?: string;
+  templateType?: string;
+}) => {
+  // If templateSlug is provided but templateType is not, try to get the template type
+  if (templateSlug && !templateType) {
+    templateType = await getTemplateTypeFromSlug(templateSlug);
+  }
+
+  const types = templateType ? [templateType, "all"] : ["all"];
+  const extensionsGroupedByCategory = await getExtensionsGroupedByCategory(
+    types
+  );
+
+  console.log(chalk.bold.blue("\nAvailable Addons:"));
+
+  if (templateSlug) {
+    console.log(
+      chalk.bold.green(`\nCompatible with template: ${templateSlug}`)
+    );
+  }
+
+  for (const [categorySlug, extensions] of Object.entries(
+    extensionsGroupedByCategory
+  )) {
+    const categoryData = await getCategoryData(categorySlug);
+
+    // Display category name if available, otherwise use the slug
+    const categoryName = categoryData?.name || categorySlug;
+    console.log(chalk.bold.green(`\n${categoryName}:`));
+
+    // Display category description if available
+    if (categoryData?.description) {
+      console.log(`  ${categoryData.description}`);
+    }
+
+    extensions.forEach((extension) => {
+      console.log(
+        `  ${chalk.yellow(extension.name)} (${chalk.cyan(extension.slug)})`
+      );
+      console.log(`    ${extension.description}`);
+      if (extension.labels && extension.labels.length > 0) {
+        console.log(`    Keywords: ${extension.labels.join(", ")}`);
+      }
+    });
+  }
+};
+
+/**
+ * Get template type from template slug
+ * @param templateSlug The template slug to look up
+ */
+export const getTemplateTypeFromSlug = async (
+  templateSlug: string
+): Promise<string | undefined> => {
+  const categories = await getTemplateCategories();
+
+  for (const category of categories) {
+    const templates = await getTemplatesForCategory(category);
+    const template = templates.find((t) => t.slug === templateSlug);
+
+    if (template) {
+      return template.type;
+    }
+  }
+
+  return undefined;
+};