pm-auto 1.0.6 → 1.0.7

package/src/config_reader.ts

@@ -1,132 +1,111 @@
 import fs from "fs/promises";
 import { getConfigPath } from "./config_path.js";
-
-import * as fsd from "fs";
-import * as path from "path";
 import type { CommandResult, ConfigType } from "./types/index.js";
 import { display } from "./display.js";
 import { confirm, isCancel, cancel } from "@clack/prompts";
 
-type PackageManager = "npm" | "yarn" | "pnpm";
-
 /**
- * Detect the package manager used in the project.
+ * Gets the required packages from the config file, transforms into a js object and with the options given
+ * it modifies the object and returns it
  */
 
-export function detectPackageManager(
-  projectPath: string = process.cwd(),
-): PackageManager | void {
-  // Check for lock files in order of specificity
-  if (fsd.existsSync(path.join(projectPath, "pnpm-lock.yaml"))) {
-    return "pnpm";
-  }
-
-  if (fsd.existsSync(path.join(projectPath, "yarn.lock"))) {
-    return "yarn";
-  }
-
-  if (fsd.existsSync(path.join(projectPath, "package-lock.json"))) {
-    return "npm";
-  }
-
-  // Default to npm if no lock file found
-  display("No Lock File Found", "error");
+//Check if the value is an array of ConfigType objects
+function isConfigTypeArray(value: unknown): value is ConfigType[] {
+  return (
+    Array.isArray(value) &&
+    value.every(
+      (item) =>
+        typeof item === "object" &&
+        item !== null &&
+        "packages" in item &&
+        Array.isArray((item as any).packages),
+    )
+  );
 }
 
-/**
- * Gets the required packages from the config file, transforms into a js object and with the options given
- * it modifies the object and returns it
- */
 export const getConfigObject = async (
   packages: string[],
   options?: any,
-): Promise<ConfigType[] | CommandResult[]> => {
-  if (!options.pkgJson) {
-    const configPath = getConfigPath();
-
-    //read config file content
-    let configContent = "";
-    try {
-      configContent = await fs.readFile(configPath as string, "utf8");
-    } catch (error) {
-      display(
-        `File not found ${error} Try updating the config file path`,
-        "error",
-      );
-    }
-
-    const configObject = JSON.parse(configContent);
-    let result: ConfigType[] = Object.values(configObject);
-
-    //filter the packages the user wants to install
-    if (packages.length > 0) {
-      result = packages
-        .map((pkgName) => {
-          const found = result.find((pkg) => pkg.name === pkgName);
-          if (!found) {
-            display(`Package '${pkgName}' not found in config`, "warning");
-          }
-          return found;
-        })
-        .filter((pkg) => pkg !== undefined);
-    }
-
-    /*
-     * Config object modification with the options given
-     */
-    //Add command to previous configured commands (-A/-add-command)
-    if (options.addCommand) {
-      result.forEach((config) => {
-        config.packages.forEach((pkg) => {
-          pkg.command = pkg.interactive
-            ? pkg.command
-            : pkg.command + " " + options.addCommand;
-        });
-      });
-    }
+): Promise<ConfigType[]> => {
+  const configPath = getConfigPath();
 
-    //Dry run - Display commands before execution
-    if (options.dryRun) {
-      display("Dry Run:", "info");
-      result.forEach((config) => {
-        display(`Package name -> ${config.name}`, "info");
-        config.packages.forEach((pkg) => {
-          display(`running ${pkg.command}`, "info");
-        });
-      });
-      const continuation = await confirm({
-        message: "Continue?",
-        initialValue: true,
-      });
+  //read config file content
+  let configContent = "";
+  try {
+    configContent = await fs.readFile(configPath as string, "utf8");
+  } catch (error) {
+    display(
+      `File not found ${error} Try updating the config file path`,
+      "error",
+    );
+  }
 
-      if (isCancel(continuation)) {
-        cancel("Operation cancelled.");
-        process.exit(0);
-      }
+  const configObject = JSON.parse(configContent);
 
-      if (!continuation) {
-        display("Operation cancelled. ", "success");
-        process.exit(0);
-      }
-    }
+  let result: ConfigType[] = [];
 
-    return result;
+  if (isConfigTypeArray(Object.values(configObject))) {
+    result = Object.values(configObject);
   } else {
-    //generate command for package.json
-    const pm = detectPackageManager();
+    display("Invalid config file format", "error");
+  }
 
-    const command = pm + " install";
+  //filter the packages the user wants to install
+  if (packages.length > 0 && result.length > 0) {
+    result = packages
+      .map((pkgName) => {
+        const found = result.find((pkg) => pkg.presetName === pkgName);
+        if (!found) {
+          display(`Package '${pkgName}' not found in config`, "warning");
+        }
+        return found;
+      })
+      .filter((pkg) => pkg !== undefined);
+  }
 
-    const result: CommandResult[] = [
-      {
-        name: "package.json",
-        interactive: [],
-        nonInteractive: [command],
-      },
-    ];
+  /*
+   * Config object modification with the options given
+   */
+
+  //Add flags to previous configured flags (-A/-add-flags)
+  if (options.addFlags) {
+    result.forEach((config) => {
+      config.packages.forEach((pkg) => {
+        if (pkg.flags) {
+          pkg.flags.push(pkg.interactive ? "" : options.addFlags);
+        } else {
+          pkg.flags = [pkg.interactive ? "" : options.addFlags];
+        }
+      });
+    });
+  }
 
-    return result;
+  //Dry run - Display commands before execution
+  if (options.dryRun) {
+    display("Dry Run:", "info");
+    result.forEach((config) => {
+      display(`Package name -> ${config.presetName}`, "info");
+      config.packages.forEach((pkg) => {
+        display(`running ${pkg.command}`, "info");
+      });
+    });
+    const continuation = await confirm({
+      message: "Continue?",
+      initialValue: true,
+    });
+
+    if (isCancel(continuation)) {
+      cancel("Operation cancelled.");
+      process.exit(0);
+    }
+
+    if (!continuation) {
+      display("Operation cancelled. ", "success");
+      process.exit(0);
+    }
   }
+
+  return result;
 };
 
 export const getConfigKeys = async (options: any) => {
@@ -176,7 +155,7 @@ export const getPackageDescription = async (packageName: string) => {
   const configObjectArray: ConfigType[] = Object.values(configObject);
 
   configObjectArray.forEach((configObject) => {
-    if (configObject.name === packageName) {
+    if (configObject.presetName === packageName) {
       const description = !configObject.description
         ? "No description"
         : configObject.description;

package/src/display.ts

@@ -22,6 +22,7 @@ export const display = (text: string, type: DisplayType) => {
       break;
 
     case "loading":
+      log.info(chalk.blue(text));
       s.start(text);
       return s; // Return spinner so it can be stopped later
 

package/src/index.ts

@@ -14,10 +14,8 @@ const program = new Command();
 
 program
   .name("pm-auto")
-  .version("1.0.6")
-  .description(
-    "A CLI tool to define and install your tech stack presets with one command.",
-  );
+  .version("1.0.7")
+  .description("Automate your project setup with one command");
 
 program
   .command("config <path>")
@@ -33,10 +31,9 @@ program
   .description(
     "Install packages using the detected package manager (Aliases: add, i)",
   )
-  .option("-p, --pkg-json", "Install packages from package.json")
   .option(
-    "-A, --add-command <command>",
-    "Add a custom command to all installation commands from config file",
+    "-A, --add-flags <flags>",
+    "Add custom flags to already defined flags from config file",
   )
   .option("-D, --dry-run", "Dry run - Display commands before execution")
   .action((packages, options) => {
@@ -62,12 +59,12 @@ program
   .command("list")
   .alias("ls")
   .description("List all packages from the config file")
-  .option("-D, --desc", "Display packages description", false)
+  .option("--desc", "Display packages description", false)
   .action((options) => {
     getConfigKeys(options);
   });
 
-//Displaying config details
+//Display a config description
 program
   .command("describe <package>")
   .alias("desc")

package/src/orchestrator.ts

@@ -1,24 +1,14 @@
-import { buildCommands, buildUninstallCommands } from "./build_command.js";
+import {
+  buildInstallCommands,
+  buildUninstallCommands,
+} from "./build_command.js";
 import { getConfigObject } from "./config_reader.js";
 import { display } from "./display.js";
-import { install } from "./install.js";
+import { runCommands } from "./run_commands.js";
 import type { ConfigType } from "./types/index.js";
 import { outro } from "@clack/prompts";
 
-//Check if the value is an array of ConfigType objects
-function isConfigTypeArray(value: unknown): value is ConfigType[] {
-  return (
-    Array.isArray(value) &&
-    value.every(
-      (item) =>
-        typeof item === "object" &&
-        item !== null &&
-        "packages" in item &&
-        Array.isArray((item as any).packages),
-    )
-  );
-}
-
+//Controls installation and uninstallation of packages
 export const orchestrator = (
   command: string,
   packages: string[],
@@ -26,28 +16,23 @@ export const orchestrator = (
 ) => {
   if (command === "install") {
     display(
-      `Installing packages... ${options.pkgJson ? "from package.json" : (packages as string[]).join(", ")}`,
+      `Installing packages... ${(packages as string[]).join(", ")}`,
       "info",
     );
-
+    const start = performance.now();
     getConfigObject(packages, options).then(async (config) => {
       if (config.length === 0) {
         display("No configuration found", "error");
         return;
       }
 
-      if (isConfigTypeArray(config)) {
-        const commands = buildCommands(config);
-
-        await install(commands);
-        outro("Done!");
+      const commands = buildInstallCommands(config);
 
-        display("Packages installed successfully", "success");
-      } else {
-        await install(config);
-        outro("Done!");
-        display("Packages from package.json installed successfully", "success");
-      }
+      await runCommands(commands);
+      outro("Done!");
+      const end = performance.now();
+      display(`Installation took ${Math.round((end - start) / 1000)}s`, "info");
+      display("Packages installed successfully", "success");
     });
   } else {
     display(
@@ -55,19 +40,19 @@ export const orchestrator = (
       "info",
     );
 
+    const start = performance.now();
     getConfigObject(packages, options).then(async (config) => {
       if (config.length === 0) {
         display("No configuration found", "error");
         return;
       }
 
-      if (isConfigTypeArray(config)) {
-        const commands = buildUninstallCommands(config);
-        await install(commands);
-        outro("Done!");
-
-        display("Packages uninstalled successfully", "success");
-      }
+      const commands = buildUninstallCommands(config);
+      await runCommands(commands);
+      outro("Done!");
+      const end = performance.now();
+      display(`Uninstallation took ${end - start}ms`, "info");
+      display("Packages uninstalled successfully", "success");
     });
   }
 };

package/src/{install.ts → run_commands.ts}

@@ -26,13 +26,13 @@ async function runCommand(command: string, interactive: boolean = false) {
 }
 
 /**
- * Install all commands
+ * Run all commands
  */
-export async function install(commands: CommandResult[]) {
+export async function runCommands(commands: CommandResult[]) {
   try {
     for (const command of commands) {
       // Wait for all interactive commands to finish first
-      if (command.interactive) {
+      if (command.interactive.length > 0) {
         for (const interactiveCommand of command.interactive) {
           display(`Running interactive command: ${interactiveCommand}`, "info");
           await runCommand(interactiveCommand, true);

package/src/types/index.ts

@@ -1,17 +1,26 @@
 export interface ConfigType {
-  name: string;
+  presetName: string;
   description?: string;
   packageManager: string;
-  packages: { command: string; interactive: boolean }[];
+  packages: {
+    command: string;
+    interactive: boolean;
+    dev?: boolean;
+    flags?: string[];
+    version?: string;
+  }[];
 }
 
 export interface PackageType {
   command: string;
   interactive: boolean;
+  dev?: boolean;
+  flags?: string[];
+  version?: string;
 }
 
 export interface CommandResult {
-  name: string;
+  presetName: string;
   interactive: string[];
   nonInteractive: string[];
 }