feat: guess pm, skip install/git (#42) by @lucas-labs

* fix: variables in template filenames
* feat: guess pm, prompt for PM and license option

+ adds pm guessing feature
+ adds option promptForNodePM (if setted to true
  it will ask for a pm and it will not use the new
  pm guessing feature to define which pm to use)
+ adds promptForLicense option (defaults to true)
  if setted to false, it will use UNLICENSED and not
  ask the user for a license
+ adds skipGitInit option, if setted to true it will
  skip git initialization step (can also be setted by
  --skip-git cli arg)
+ adds skipNpmInstall option, if setted to true it will
  skip npm install step (can also be setted by
  --skip-install cli arg)

* fix: tests
* chore: delete utils.ts
* Update src/npm.ts

Co-authored-by: uetchy <y@uechi.io>

Author: lucas-labs

src/index.ts

@@ -7,7 +7,7 @@ import path from 'path';
 import yargsInteractive, { OptionData } from 'yargs-interactive';
 import { exists, isOccupied } from './fs';
 import { getGitUser, initGit } from './git';
-import { addDeps, installDeps } from './npm';
+import { addDeps, installDeps, whichPm } from './npm';
 import { copy, getAvailableTemplates } from './template';
 
 export interface Option {
@@ -17,6 +17,10 @@ export interface Option {
 export interface Options {
   templateRoot: string;
   promptForTemplate?: boolean;
+  promptForLicense?: boolean;
+  promptForNodePM?: boolean;
+  skipGitInit?: boolean;
+  skipNpmInstall?: boolean;
   modifyName?: (name: string) => string | Promise<string>;
   extra?: Option;
   caveat?:
@@ -73,6 +77,8 @@ function getContact(author: string, email?: string) {
 async function getYargsOptions(
   templateRoot: string,
   promptForTemplate: boolean,
+  promptForLicense: boolean,
+  promptForNodePM: boolean,
   extraOptions: Option = {}
 ) {
   const gitUser = await getGitUser();
@@ -110,16 +116,16 @@ async function getYargsOptions(
       type: 'list',
       describe: 'license',
       choices: [...availableLicenses(), 'UNLICENSED'],
-      default: 'MIT',
-      prompt: 'if-no-arg',
+      default: promptForLicense ? 'MIT' : 'UNLICENSED',
+      prompt: promptForLicense ? 'if-no-arg' : 'never',
     },
     'node-pm': {
       type: 'list',
       describe:
         'select package manager to use for installing packages from npm',
       choices: ['npm', 'yarn', 'pnpm'],
-      default: 'npm',
-      prompt: 'never',
+      default: undefined, // undefined by default, we'll try to guess pm manager later
+      prompt: promptForNodePM ? 'if-no-arg' : 'never',
     },
     ...extraOptions,
   };
@@ -149,13 +155,21 @@ export async function create(appName: string, options: Options) {
     throw new CLIError(`${packageDir} is not empty directory.`);
   }
 
-  const { templateRoot, promptForTemplate = false } = options;
+  const {
+    templateRoot,
+    promptForTemplate = false,
+    promptForLicense = true,
+    promptForNodePM = false,
+  } = options;
 
   const yargsOption = await getYargsOptions(
     templateRoot,
     promptForTemplate,
+    promptForLicense,
+    promptForNodePM,
     options.extra
   );
+
   const args = await yargsInteractive()
     .usage('$0 <name> [args]')
     .interactive(yargsOption as any);
@@ -212,12 +226,17 @@ export async function create(appName: string, options: Options) {
   }
 
   // init git
-  try {
-    console.log('\nInitializing a git repository');
-    await initGit(packageDir);
-  } catch (err: any) {
-    if (err?.exitCode == 127) return; // no git available
-    throw err;
+  const skipGit = args['skip-git'];
+
+  // init git if option skipGitInit or arg --skip-git are not set
+  if (!(options.skipGitInit || skipGit)) {
+    try {
+      console.log('\nInitializing a git repository');
+      await initGit(packageDir);
+    } catch (err: any) {
+      if (err?.exitCode == 127) return; // no git available
+      throw err;
+    }
   }
 
   const run = (command: string, options: CommonOptions<string> = {}) => {
@@ -233,10 +252,16 @@ export async function create(appName: string, options: Options) {
   let installNpmPackage = async (packageName: string): Promise<void> => {};
 
   if (exists('package.json', packageDir)) {
-    const packageManager = args['node-pm'];
+    const nodePMArg = args['node-pm'];
+    const skipInstallArg = args['skip-install'];
+
+    // guess which package manager to use
+    const packageManager = whichPm(nodePMArg);
 
-    console.log(`Installing dependencies using ${packageManager}`);
-    await installDeps(packageDir, packageManager);
+    // install deps only if skipNpmInstall is not falsy
+    if (!(options.skipNpmInstall || skipInstallArg)) {
+      await installDeps(packageDir, packageManager);
+    }
 
     installNpmPackage = async (
       pkg: string | string[],

src/npm.ts

@@ -1,10 +1,49 @@
 import { NodePM, printCommand, CLIError } from '.';
 import { spawnPromise } from './fs';
 
+function getPm(name: string) {
+  switch (name) {
+    case 'pnpm':
+      return NodePM.Pnpm;
+
+    case 'yarn':
+      return NodePM.Yarn;
+
+    case 'npm':
+      return NodePM.Npm;
+  
+    default:
+      return NodePM.Npm;
+  }
+}
+
+// License for `whichPm`
+// The MIT License (MIT)
+// Copyright (c) 2017-2022 Zoltan Kochan <z@kochan.io>
+// https://github.com/zkochan/packages/tree/main/which-pm-runs
+export function whichPm(defaultPm?: string) {
+  // if there's a default pm (passed by argv), use it
+  if(defaultPm) {
+    return getPm(defaultPm);
+  }
+
+  if (!process.env.npm_config_user_agent) {
+    return NodePM.Npm;
+  }
+
+  const pmSpec = process.env.npm_config_user_agent.split(' ')[0]
+  const separatorPos = pmSpec.lastIndexOf('/')
+  const name = pmSpec.substring(0, separatorPos)
+
+  return getPm(name);
+}
+
 export async function installDeps(rootDir: string, pm: NodePM) {
   let command: string;
   let args: string[];
 
+  console.log(`Installing dependencies using ${pm}`);
+
   switch (pm) {
     case NodePM.Npm: {
       command = 'npm';

tests/index.test.ts

@@ -219,3 +219,32 @@ test('create unlicensed app', async () => {
   const existed = existsSync(`${baseDir}/create-greet/LICENSE`);
   expect(existed).toBeFalsy();
 }, 300000);
+
+it('should create project without npm install and without git', async () => {
+  const baseDir = mkdtempSync(TEST_PREFIX);
+
+  const opts = [
+    'create-greet',
+    '--description',
+    'desc.',
+    '--author',
+    '"Awesome Doe"',
+    '--email',
+    'awesome@example.com',
+    '--template',
+    'default',
+    '--license',
+    'UNLICENSED',
+    '--skip-install',
+    '--skip-git'
+  ];
+  const { stdout } = await execa(SCRIPT_PATH, opts, {
+    cwd: baseDir,
+  });
+
+  // cant check node_modules doesn't exist, because
+  // it will exist anyways after AfterHookOptions executes!
+  expect(stdout).not.toContain('Installing dependencies using');
+  expect(stdout).not.toContain('Initializing a git repository');
+  expect(existsSync(`${baseDir}/create-greet/.git`)).toBeFalsy();
+}, 300000);