1、封装异步执行命令

记得修改core/exec部分

  1. function exec(command, args, options = {}) {
  2.   const win32 = process.platform === 'win32'
  3.   const cmd = win32 ? 'cmd' : command
  4.   const cmdArgs = win32 ? ['/c'].concat(command, args) : args
  5.   return require('child_process').spawn(cmd, cmdArgs, options)
  6. }
  8. function execAysnc(command, args, options = {}) {
  9.   return new Promise((resolve, reject) => {
  10.     const cp = exec(command, args, options)
  11.     cp.on('error', function (error) {
  12.       reject(error)
  13.     })
  14.     cp.on('exit', e => {
  15.       resolve(e)
  16.     })
  17.   })
  18. }
  20. module.exports = {  sleep, execAysnc }

2、模板安装

  1.   async exec() {
  2.     try {
  3.       //记得加上async，使同步运行，一个trycatch可以捕获方法内的错误
  4.       //1、准备阶段
  5.       this.projectInfo = await this.prepare()
  6.       if (!this.projectInfo) return false
  7.       //2、下载模板
  8.       await this.downloadTemplate()
  9.       //3、安装模板
  10.       await this.installTemplate()
  11.     } catch (e) {
  12.       log.error(e.message)
  13.     }
  14.   }

1、安装模板时，根据模板类型选择安装标准模板或者自定义模板

  1. const templateTypes = {
  2.   TEMPLATE_TYPE_NORMAL: 'normal',
  3.   TEMPLATE_TYPE_CUSTOM: 'custom'
  4. }
  6. async installTemplate() {
  7.   if (this.template) {
  8.     if (!this.template.npmType) {
  9.       this.template.npmType = templateTypes.TEMPLATE_TYPE_NORMAL
  10.     }
  11.     if (this.template.npmType === templateTypes.TEMPLATE_TYPE_CUSTOM) {
  12.       await this.installCustomTemplate()
  13.     } else if (this.template.npmType === templateTypes.TEMPLATE_TYPE_NORMAL) {
  14.       await this.installNormalTemplate()
  15.     } else {
  16.       throw new Error('无法识别项目模板信息')
  17.     }
  18.   } else {
  19.     throw new Error('项目模板信息不存在')
  20.   }
  21. }

1、封装安装执行命令

  2. //白名单
  3. const WHITE_COMMAND = ['npm', 'cnpm', 'yarn']
  4. //白名单检测
  5.   checkWhiteCommand(cmd) {
  6.     if (WHITE_COMMAND.includes(cmd)) {
  7.       return cmd
  8.     }
  9.     return null
  10.   }
  12.   //安装命令
  13.   async execCommand(cmd, message) {
  14.     if (cmd) {
  15.       const tempCmd = cmd.split(' ')
  16.       const mainCmd = this.checkWhiteCommand(tempCmd[0])
  17.       if (!mainCmd) throw new Error('命令不存在')
  18.       const args = tempCmd.slice(1)
  19.       const installRet = await execAysnc(mainCmd, args, {
  20.         cwd: dir, //cwd 子进程的当前工作目录
  21.         stdio: 'inherit' //inherit  将相应的stdio传给父进程或者从父进程传入，相当于process.stdin,process.stout和process.stderr
  22.       })
  23.       if (installRet === 0) {
  24.         log.success(message + '成功')
  25.       } else {
  26.         throw new Error(message + '失败')
  27.       }
  28.     }
  29.   }

2、安装标准模板

  1.    //标准安装
  2.   async installNormalTemplate() {
  3.     const spinner = spinnerStart()
  4.     try {
  5.       console.log(this.pkg)
  6.       //拷贝模板代码到当前目录
  7.       const templatePath = path.resolve(this.pkg.cacheFilePath, 'template')
  8.       const dirs = fs.readdirSync(templatePath)
  9.       const filePath = path.resolve(templatePath, dirs[0])
  10.       targetPath = path.resolve(process.cwd(), this.projectInfo.project)
  11.       fse.ensureDirSync(filePath)
  12.       fse.ensureDirSync(targetPath)
  13.       fse.copySync(filePath, targetPath)
  14.     } catch (error) {
  15.       throw error
  16.     } finally {
  17.       spinner.stop(true)
  18.       log.success('模板安装成功')
  19.     }
  21.     const ignore = ['node_modules/**', 'public/**']
  22.     await this.ejsRender(ignore)
  24.     await this.execCommand(this.template.installCommand, '依赖安装')
  25.     await this.execCommand(this.template.startCommand, '项目启动')
  26.   }

3、自定义模板 暂不开发

  1. //自定义安装
  2.   async installCustomTemplate() {}

3、修改模板代码

使用 ejs 修改 haha-cli-dev-template-admin-element-vue2、haha-cli-dev-template-vue2 这个模板 template 目录下的 package.json 文件，在npm publish

  1.  "name": "<%= className %>",
  2.  "version": "<%= version %>",

因为发布到 npm 的版本号必须是正常的版本号，所以才需要嵌套一层，将外层作为 npm 模块，内层作为模板。

4、使用ejs进行模板渲染

  1.   //ejs渲染=>将模板中的转成模板中package.json定义的版本
  2.   ejsRender(ignore) {
  3.     return new Promise((resolve, reject) => {
  4.       //得到文件夹下除去ignore的所有路径，
  5.       require('glob')(
  6.         '**',
  7.         {
  8.           ignore,
  9.           cwd: targetPath,
  10.           nodir: true
  11.         },
  12.         (err, files) => {
  13.           if (err) {
  14.             reject(err)
  15.           }
  16.           Promise.all(
  17.             files.map(file => {
  18.               //得到每一个文件的具体路径
  19.               const filePath = path.join(targetPath, file)
  20.               return new Promise((resolve1, reject1) => {
  21.                 //解析文件
  22.                 ejs.renderFile(filePath, this.projectInfo, {}, function (err, str) {
  23.                   if (err) {
  24.                     reject1(err)
  25.                   } else {
  26.                     //使用renderFile得到的str是字符串，需要转成文件
  27.                     fse.writeFileSync(filePath, str)
  28.                     resolve1(str)
  29.                   }
  30.                 })
  31.               })
  32.             })
  33.           )
  34.             .then(() => resolve(files))
  35.             .catch(err => reject(err))
  36.         }
  37.       )
  38.     })
  39.   }

5、init命令直接传入项目名称

  1.   //3、选择创建项目或组件
  2.   async getBaseInfo() {
  3.     let info = {}
  4.     function isNamevalid(val) {
  5.       return /^[a-zA-Z]+([-][a-zA-Z0-9]|[_][a-zA-Z0-9]|[a-zA-Z0-9])*$/.test(val)
  6.     }
  7.     const { type } = await inquirer.prompt({
  8.       type: 'list',
  9.       message: '请选择初始化类型',
  10.       name: 'type',
  11.       default: TYPE_PROJECT,
  12.       choices: [
  13.         {
  14.           name: '项目',
  15.           value: TYPE_PROJECT
  16.         },
  17.         {
  18.           name: '组件',
  19.           value: TYPE_COMPONENT
  20.         }
  21.       ]
  22.     })
  23.     const promptArr = [
  24.       {
  25.         type: 'input',
  26.         message: '请输入项目版本号',
  27.         name: 'version',
  28.         default: '1.0.0',
  29.         validate: function (val) {
  30.           const done = this.async()
  31.           setTimeout(function () {
  32.             //!!semver.valid(val) !!转成Boolean类型
  33.             if (!!!semver.valid(val)) {
  34.               done('请输入合法的版本号')
  35.               return
  36.             }
  37.             done(null, true)
  38.           }, 0)
  39.         },
  40.         filter: val => {
  41.           if (!!semver.valid(val)) {
  42.             return semver.valid(val)
  43.           }
  44.           return val
  45.         }
  46.       },
  47.       {
  48.         type: 'list',
  49.         message: '请选择项目模板',
  50.         name: 'npmName',
  51.         choices: this.createTemplateChoice()
  52.       }
  53.     ]
  54.     if (type === TYPE_COMPONENT) {
  55.     }
  56.     if (type === TYPE_PROJECT) {
  57.       const projectPromt = {
  58.         type: 'input',
  59.         message: '请输入项目名称',
  60.         name: 'project',
  61.         default: 'HahaDemo',
  62.         validate: function (val) {
  63.           //检查项目名称和版本号的合法性
  64.           const done = this.async()
  65.           setTimeout(function () {
  66.             //1、必须首字母大写，
  67.             //2、尾字符必须为英文或者数字，不能为字符
  68.             //3、字符仅允许'-_'
  69.             //类型合法有：a a-b a_b a-b-c a_b_c a1_b1_c1 a1 a1-b1-c1
  70.             if (!isNamevalid(val)) {
  71.               done('请输入合法的项目名称(要求英文字母开头,数字或字母结尾,字符只允许使用 - 以及 _)')
  72.               return
  73.             }
  74.             done(null, true)
  75.           }, 0)
  76.         }
  77.       }
  78.       //命令行输入的projectName是否合法，不合法则重新填入项目名称
  79.       if (!isNamevalid(this.projectName)) {
  80.         promptArr.unshift(projectPromt)
  81.       } else {
  82.         info.project = this.projectName
  83.       }
  84.       const result = await inquirer.prompt(promptArr)
  85.       if (result?.project) {
  86.         info.project = result?.project
  87.       }
  88.       //4、获取项目的基本信息
  89.       return {
  90.         type,
  91.         ...result,
  92.         ...info,
  93.         className: require('kebab-case')(info.project).replace(/^-/, '')
  94.       }
  95.     }
  96.   }

6、完整代码

  1. 'use strict'
  3. const fs = require('fs')
  4. const path = require('path')
  5. const inquirer = require('inquirer')
  6. const fse = require('fs-extra')
  7. const semver = require('semver')
  8. const ejs = require('ejs')
  9. const Command = require('@haha-cli-dev/command')
  10. const log = require('@haha-cli-dev/log')
  11. const packages = require('@haha-cli-dev/packages')
  12. const { spinnerStart, execAysnc } = require('@haha-cli-dev/utils')
  14. const { getTemplate } = require('./template')
  16. const TYPE_PROJECT = 'project'
  17. const TYPE_COMPONENT = 'component'
  18. const templateTypes = {
  19.   TEMPLATE_TYPE_NORMAL: 'normal',
  20.   TEMPLATE_TYPE_CUSTOM: 'custom'
  21. }
  23. let targetPath
  24. //白名单
  25. const WHITE_COMMAND = ['npm', 'cnpm', 'yarn']
  27. class initCommand extends Command {
  28.   init() {
  29.     this.projectName = this._argv[0] || ''
  30.   }
  32.   /*
  33.     1、准备阶段
  34.     2、下载模板
  35.     3、安装模板
  36.    */
  37.   async exec() {
  38.     try {
  39.       //记得加上async，使同步运行，一个trycatch可以捕获方法内的错误
  40.       //1、准备阶段
  41.       this.projectInfo = await this.prepare()
  42.       console.log('this.projectInfo', this.projectInfo)
  43.       if (!this.projectInfo) return false
  44.       //2、下载模板
  45.       await this.downloadTemplate()
  46.       //3、安装模板
  47.       await this.installTemplate()
  48.     } catch (e) {
  49.       log.error(e?.message)
  50.       if (process.env.LOG_LEVEL === 'verbose') {
  51.         console.log('e', e)
  52.       }
  53.     }
  54.   }
  56.   async installTemplate() {
  57.     if (this.template) {
  58.       if (!this.template.npmType) {
  59.         this.template.npmType = templateTypes.TEMPLATE_TYPE_NORMAL
  60.       }
  61.       if (this.template.npmType === templateTypes.TEMPLATE_TYPE_CUSTOM) {
  62.         await this.installCustomTemplate()
  63.       } else if (this.template.npmType === templateTypes.TEMPLATE_TYPE_NORMAL) {
  64.         await this.installNormalTemplate()
  65.       } else {
  66.         throw new Error('无法识别项目模板信息')
  67.       }
  68.     } else {
  69.       throw new Error('项目模板信息不存在')
  70.     }
  71.   }
  73.   //自定义安装
  74.   async installCustomTemplate() {}
  76.   //标准安装
  77.   async installNormalTemplate() {
  78.     const spinner = spinnerStart('正在安装模板...')
  79.     try {
  80.       //拷贝模板代码到当前目录
  81.       const templatePath = path.resolve(this.pkg.cacheFilePath, 'template')
  82.       const dirs = fs.readdirSync(templatePath)
  83.       const filePath = path.resolve(templatePath, dirs[0])
  84.       targetPath = path.resolve(process.cwd(), this.projectInfo.project)
  85.       fse.ensureDirSync(filePath)
  86.       fse.ensureDirSync(targetPath)
  87.       fse.copySync(filePath, targetPath)
  88.     } catch (error) {
  89.       throw error
  90.     } finally {
  91.       spinner.stop(true)
  92.       log.success('模板安装成功')
  93.     }
  94.     const ignore = ['**/node_modules/**', ...this.template?.ignore.split(',')]
  95.     await this.ejsRender(ignore)
  97.     await this.execCommand(this.template.installCommand, '依赖安装')
  98.     await this.execCommand(this.template.startCommand, '项目启动')
  99.   }
  101.   //ejs渲染=>将模板中的转成模板中package.json定义的版本
  102.   ejsRender(ignore) {
  103.     return new Promise((resolve, reject) => {
  104.       //得到文件夹下除去ignore的所有路径，
  105.       require('glob')(
  106.         '**',
  107.         {
  108.           ignore,
  109.           cwd: targetPath,
  110.           nodir: true
  111.         },
  112.         (err, files) => {
  113.           if (err) {
  114.             reject(err)
  115.           }
  116.           Promise.all(
  117.             files.map(file => {
  118.               //得到每一个文件的具体路径
  119.               const filePath = path.join(targetPath, file)
  120.               return new Promise((resolve1, reject1) => {
  121.                 //解析文件
  122.                 ejs.renderFile(filePath, this.projectInfo, {}, function (err, str) {
  123.                   if (err) {
  124.                     reject1(err)
  125.                   } else {
  126.                     //使用renderFile得到的str是字符串，需要转成文件
  127.                     fse.writeFileSync(filePath, str)
  128.                     resolve1(str)
  129.                   }
  130.                 })
  131.               })
  132.             })
  133.           )
  134.             .then(() => resolve(files))
  135.             .catch(err => reject(err))
  136.         }
  137.       )
  138.     })
  139.   }
  141.   //白名单检测
  142.   checkWhiteCommand(cmd) {
  143.     if (WHITE_COMMAND.includes(cmd)) {
  144.       return cmd
  145.     }
  146.     return null
  147.   }
  149.   //安装命令
  150.   async execCommand(cmd, message) {
  151.     if (cmd) {
  152.       const tempCmd = cmd.split(' ')
  153.       const mainCmd = this.checkWhiteCommand(tempCmd[0])
  154.       if (!mainCmd) throw new Error('命令不存在')
  155.       const args = tempCmd.slice(1)
  156.       const installRet = await execAysnc(mainCmd, args, {
  157.         cwd: targetPath, //cwd 子进程的当前工作目录
  158.         stdio: 'inherit' //inherit  将相应的stdio传给父进程或者从父进程传入，相当于process.stdin,process.stout和process.stderr
  159.       })
  160.       if (installRet === 0) {
  161.         log.success(message + '成功')
  162.       } else {
  163.         throw new Error(message + '失败')
  164.       }
  165.     }
  166.   }
  168.   /*
  169.   下载模板
  170.     1、通过项目模板API获取项目模板信息
  171.      1.1通过egg.js搭建后端系统
  172.      1.2通过npm存储项目模板
  173.      1.3将项目模板信息存储到mongoDB数据库中
  174.      1.4通过egg.js获取mongoDB的数据并通过API返回
  175.     3、选择创建组件或项目
  176.     4、获取项目的基本信息
  177.   */
  178.   async downloadTemplate() {
  179.     const homePath = process.env.CLI_HOME_PATH
  180.     const targetPath = path.resolve(homePath, 'templates')
  181.     const storeDir = path.resolve(targetPath, 'node_modules')
  182.     this.template = this.templates.find(item => item.npmName === this.projectInfo.npmName)
  183.     const { npmName, version } = this.template
  184.     this.pkg = new packages({
  185.       targetPath,
  186.       storeDir,
  187.       packageName: npmName,
  188.       packageVersion: version
  189.     })
  190.     if (await this.pkg.exists()) {
  191.       const spinner = spinnerStart('模板更新中，请稍候')
  192.       try {
  193.         //更新
  194.         await this.pkg.update()
  195.       } catch (error) {
  196.         //抛出异常，让上层捕获
  197.         throw error
  198.       } finally {
  199.         //解决下载出错时，仍提示下载中的情况
  200.         spinner.stop(true)
  201.         if (await this.pkg.exists()) {
  202.           log.success('模板更新成功')
  203.         }
  204.       }
  205.     } else {
  206.       const spinner = spinnerStart('模板下载中，请稍候')
  207.       try {
  208.         //初始化
  209.         await this.pkg.install()
  210.       } catch (error) {
  211.         //抛出异常，让上层捕获
  212.         throw error
  213.       } finally {
  214.         //解决下载出错时，仍提示下载中的情况
  215.         spinner.stop(true)
  216.         if (await this.pkg.exists()) {
  217.           log.success('模板下载成功')
  218.         }
  219.       }
  220.     }
  221.   }
  223.   /*
  224.     准备阶段
  225.     1、判断当前目录是否为空
  226.       1.1 询问是否继续创建
  227.     2、是否启动强制更新
  228.     3、选择创建组件或项目
  229.     4、获取项目的基本信息
  230.   */
  231.   async prepare() {
  232.     //当前执行node命令时候的文件夹地址 ——工作目录
  233.     const localPath = process.cwd()
  234.     const force = this._argv[1]?.force
  235.     let isContinue = false
  236.     this.templates = await getTemplate()
  237.     //判断模板是否存在
  238.     if (!this.templates || this.templates.length === 0) {
  239.       throw new Error('当前不存在项目模板')
  240.     }
  241.     if (this.isCmdEmpty(localPath)) {
  242.       //1.1 询问是否继续创建
  243.       if (!force) {
  244.         const res = await inquirer.prompt({
  245.           type: 'confirm',
  246.           name: 'isContinue',
  247.           message: '当前文件夹内容不为空,是否在此继续创建项目?',
  248.           default: false
  249.         })
  250.         isContinue = res.isContinue
  251.         if (!isContinue) {
  252.           return false
  253.         }
  254.       }
  255.     }
  256.     // 2.是否启动强制安装
  257.     if (isContinue || force) {
  258.       const { isDelete } = await inquirer.prompt({
  259.         type: 'confirm',
  260.         name: 'isDelete',
  261.         message: '是否清空当前目录下的文件?',
  262.         default: false
  263.       })
  264.       if (isDelete) {
  265.         // 清空当前目录
  266.         fse.emptyDirSync(localPath)
  267.       }
  268.     }
  269.     return this.getBaseInfo()
  270.   }
  272.   //3、选择创建项目或组件
  273.   async getBaseInfo() {
  274.     let info = {}
  275.     function isNamevalid(val) {
  276.       return /^[a-zA-Z]+([-][a-zA-Z0-9]|[_][a-zA-Z0-9]|[a-zA-Z0-9])*$/.test(val)
  277.     }
  278.     const { type } = await inquirer.prompt({
  279.       type: 'list',
  280.       message: '请选择初始化类型',
  281.       name: 'type',
  282.       default: TYPE_PROJECT,
  283.       choices: [
  284.         {
  285.           name: '项目',
  286.           value: TYPE_PROJECT
  287.         },
  288.         {
  289.           name: '组件',
  290.           value: TYPE_COMPONENT
  291.         }
  292.       ]
  293.     })
  294.     const title = TYPE_PROJECT === type ? '项目' : '组件'
  295.     const promptArr = [
  296.       {
  297.         type: 'input',
  298.         message: `请输入${title}版本号`,
  299.         name: 'version',
  300.         default: '1.0.0',
  301.         validate: val => !!semver.valid(val) || '请输入合法的版本号',
  302.         filter: val => {
  303.           if (!!semver.valid(val)) {
  304.             return semver.valid(val)
  305.           }
  306.           return val
  307.         }
  308.       },
  309.       {
  310.         type: 'list',
  311.         message: `请选择${title}模板`,
  312.         name: 'npmName',
  313.         choices: this.createTemplateChoice(type)
  314.       }
  315.     ]
  316.     const projectPromt = {
  317.       type: 'input',
  318.       message: `请输入${title}名称`,
  319.       name: 'project',
  320.       default: 'HahaDemo',
  321.       validate: function (val) {
  322.         //检查项目名称和版本号的合法性
  323.         const done = this.async()
  324.         setTimeout(function () {
  325.           //1、必须首字母大写，
  326.           //2、尾字符必须为英文或者数字，不能为字符
  327.           //3、字符仅允许'-_'
  328.           //类型合法有：a a-b a_b a-b-c a_b_c a1_b1_c1 a1 a1-b1-c1
  329.           if (!isNamevalid(val)) {
  330.             done(`请输入合法的${title}名称(要求英文字母开头,数字或字母结尾,字符只允许使用 - 以及 _)`)
  331.             return
  332.           }
  333.           done(null, true)
  334.         }, 0)
  335.       }
  336.     }
  337.     //命令行输入的projectName是否合法，不合法则重新填入项目名称
  338.     if (!isNamevalid(this.projectName)) {
  339.       promptArr.unshift(projectPromt)
  340.     } else {
  341.       info.project = this.projectName
  342.     }
  343.     if (type === TYPE_COMPONENT) {
  344.       const descriptPrompt = {
  345.         type: 'input',
  346.         message: `请输入${title}描述`,
  347.         name: 'description',
  348.         validate: val => {
  349.           if (!val) {
  350.             return '组件描述不可以为空'
  351.           }
  352.           return true
  353.         }
  354.       }
  355.       promptArr.push(descriptPrompt)
  356.     }
  357.     const result = await inquirer.prompt(promptArr)
  358.     if (result?.project) {
  359.       info.project = result?.project
  360.     }
  361.     //4、获取项目的基本信息
  362.     return {
  363.       type,
  364.       ...result,
  365.       ...info,
  366.       className: require('kebab-case')(info.project).replace(/^-/, '')
  367.     }
  368.   }
  370.   createTemplateChoice(type) {
  371.     return this.templates
  372.       .filter(item => item.tag === type)
  373.       ?.map(item => ({
  374.         name: item.name,
  375.         value: item.npmName
  376.       }))
  377.   }
  379.   //判断当前路径是否不为空
  380.   isCmdEmpty(localPath) {
  381.     let fileList = fs.readdirSync(localPath)
  382.     fileList = fileList.filter(item => !item.startsWith('.') && item !== 'node_modules')
  383.     return fileList && fileList.length > 0
  384.   }
  385. }
  387. function init(argv) {
  388.   return new initCommand(argv)
  389. }
  391. module.exports = init
  392. module.exports.initCommand = initCommand
  393. 'use strict'
  395. const fs = require('fs')
  396. const path = require('path')
  397. const inquirer = require('inquirer')
  398. const fse = require('fs-extra')
  399. const semver = require('semver')
  400. const ejs = require('ejs')
  401. const Command = require('@haha-cli-dev/command')
  402. const log = require('@haha-cli-dev/log')
  403. const packages = require('@haha-cli-dev/packages')
  404. const { spinnerStart, execAysnc } = require('@haha-cli-dev/utils')
  406. const { getTemplate } = require('./template')
  408. const TYPE_PROJECT = 'project'
  409. const TYPE_COMPONENT = 'component'
  410. const templateTypes = {
  411.   TEMPLATE_TYPE_NORMAL: 'normal',
  412.   TEMPLATE_TYPE_CUSTOM: 'custom'
  413. }
  415. let targetPath
  416. //白名单
  417. const WHITE_COMMAND = ['npm', 'cnpm', 'yarn']
  419. class initCommand extends Command {
  420.   init() {
  421.     this.projectName = this._argv[0] || ''
  422.   }
  424.   /*
  425.     1、准备阶段
  426.     2、下载模板
  427.     3、安装模板
  428.    */
  429.   async exec() {
  430.     try {
  431.       //记得加上async，使同步运行，一个trycatch可以捕获方法内的错误
  432.       //1、准备阶段
  433.       this.projectInfo = await this.prepare()
  434.       console.log('this.projectInfo', this.projectInfo)
  435.       if (!this.projectInfo) return false
  436.       //2、下载模板
  437.       await this.downloadTemplate()
  438.       //3、安装模板
  439.       await this.installTemplate()
  440.     } catch (e) {
  441.       log.error(e?.message)
  442.       if (process.env.LOG_LEVEL === 'verbose') {
  443.         console.log('e', e)
  444.       }
  445.     }
  446.   }
  448.   async installTemplate() {
  449.     if (this.template) {
  450.       if (!this.template.npmType) {
  451.         this.template.npmType = templateTypes.TEMPLATE_TYPE_NORMAL
  452.       }
  453.       if (this.template.npmType === templateTypes.TEMPLATE_TYPE_CUSTOM) {
  454.         await this.installCustomTemplate()
  455.       } else if (this.template.npmType === templateTypes.TEMPLATE_TYPE_NORMAL) {
  456.         await this.installNormalTemplate()
  457.       } else {
  458.         throw new Error('无法识别项目模板信息')
  459.       }
  460.     } else {
  461.       throw new Error('项目模板信息不存在')
  462.     }
  463.   }
  465.   //自定义安装
  466.   async installCustomTemplate() {}
  468.   //标准安装
  469.   async installNormalTemplate() {
  470.     const spinner = spinnerStart('正在安装模板...')
  471.     try {
  472.       //拷贝模板代码到当前目录
  473.       const templatePath = path.resolve(this.pkg.cacheFilePath, 'template')
  474.       const dirs = fs.readdirSync(templatePath)
  475.       const filePath = path.resolve(templatePath, dirs[0])
  476.       targetPath = path.resolve(process.cwd(), this.projectInfo.project)
  477.       fse.ensureDirSync(filePath)
  478.       fse.ensureDirSync(targetPath)
  479.       fse.copySync(filePath, targetPath)
  480.     } catch (error) {
  481.       throw error
  482.     } finally {
  483.       spinner.stop(true)
  484.       log.success('模板安装成功')
  485.     }
  486.     const ignore = ['**/node_modules/**', ...this.template?.ignore.split(',')]
  487.     await this.ejsRender(ignore)
  489.     await this.execCommand(this.template.installCommand, '依赖安装')
  490.     await this.execCommand(this.template.startCommand, '项目启动')
  491.   }
  493.   //ejs渲染=>将模板中的转成模板中package.json定义的版本
  494.   ejsRender(ignore) {
  495.     return new Promise((resolve, reject) => {
  496.       //得到文件夹下除去ignore的所有路径，
  497.       require('glob')(
  498.         '**',
  499.         {
  500.           ignore,
  501.           cwd: targetPath,
  502.           nodir: true
  503.         },
  504.         (err, files) => {
  505.           if (err) {
  506.             reject(err)
  507.           }
  508.           Promise.all(
  509.             files.map(file => {
  510.               //得到每一个文件的具体路径
  511.               const filePath = path.join(targetPath, file)
  512.               return new Promise((resolve1, reject1) => {
  513.                 //解析文件
  514.                 ejs.renderFile(filePath, this.projectInfo, {}, function (err, str) {
  515.                   if (err) {
  516.                     reject1(err)
  517.                   } else {
  518.                     //使用renderFile得到的str是字符串，需要转成文件
  519.                     fse.writeFileSync(filePath, str)
  520.                     resolve1(str)
  521.                   }
  522.                 })
  523.               })
  524.             })
  525.           )
  526.             .then(() => resolve(files))
  527.             .catch(err => reject(err))
  528.         }
  529.       )
  530.     })
  531.   }
  533.   //白名单检测
  534.   checkWhiteCommand(cmd) {
  535.     if (WHITE_COMMAND.includes(cmd)) {
  536.       return cmd
  537.     }
  538.     return null
  539.   }
  541.   //安装命令
  542.   async execCommand(cmd, message) {
  543.     if (cmd) {
  544.       const tempCmd = cmd.split(' ')
  545.       const mainCmd = this.checkWhiteCommand(tempCmd[0])
  546.       if (!mainCmd) throw new Error('命令不存在')
  547.       const args = tempCmd.slice(1)
  548.       const installRet = await execAysnc(mainCmd, args, {
  549.         cwd: targetPath, //cwd 子进程的当前工作目录
  550.         stdio: 'inherit' //inherit  将相应的stdio传给父进程或者从父进程传入，相当于process.stdin,process.stout和process.stderr
  551.       })
  552.       if (installRet === 0) {
  553.         log.success(message + '成功')
  554.       } else {
  555.         throw new Error(message + '失败')
  556.       }
  557.     }
  558.   }
  560.   /*
  561.   下载模板
  562.     1、通过项目模板API获取项目模板信息
  563.      1.1通过egg.js搭建后端系统
  564.      1.2通过npm存储项目模板
  565.      1.3将项目模板信息存储到mongoDB数据库中
  566.      1.4通过egg.js获取mongoDB的数据并通过API返回
  567.     3、选择创建组件或项目
  568.     4、获取项目的基本信息
  569.   */
  570.   async downloadTemplate() {
  571.     const homePath = process.env.CLI_HOME_PATH
  572.     const targetPath = path.resolve(homePath, 'templates')
  573.     const storeDir = path.resolve(targetPath, 'node_modules')
  574.     this.template = this.templates.find(item => item.npmName === this.projectInfo.npmName)
  575.     const { npmName, version } = this.template
  576.     this.pkg = new packages({
  577.       targetPath,
  578.       storeDir,
  579.       packageName: npmName,
  580.       packageVersion: version
  581.     })
  582.     if (await this.pkg.exists()) {
  583.       const spinner = spinnerStart('模板更新中，请稍候')
  584.       try {
  585.         //更新
  586.         await this.pkg.update()
  587.       } catch (error) {
  588.         //抛出异常，让上层捕获
  589.         throw error
  590.       } finally {
  591.         //解决下载出错时，仍提示下载中的情况
  592.         spinner.stop(true)
  593.         if (await this.pkg.exists()) {
  594.           log.success('模板更新成功')
  595.         }
  596.       }
  597.     } else {
  598.       const spinner = spinnerStart('模板下载中，请稍候')
  599.       try {
  600.         //初始化
  601.         await this.pkg.install()
  602.       } catch (error) {
  603.         //抛出异常，让上层捕获
  604.         throw error
  605.       } finally {
  606.         //解决下载出错时，仍提示下载中的情况
  607.         spinner.stop(true)
  608.         if (await this.pkg.exists()) {
  609.           log.success('模板下载成功')
  610.         }
  611.       }
  612.     }
  613.   }
  615.   /*
  616.     准备阶段
  617.     1、判断当前目录是否为空
  618.       1.1 询问是否继续创建
  619.     2、是否启动强制更新
  620.     3、选择创建组件或项目
  621.     4、获取项目的基本信息
  622.   */
  623.   async prepare() {
  624.     //当前执行node命令时候的文件夹地址 ——工作目录
  625.     const localPath = process.cwd()
  626.     const force = this._argv[1]?.force
  627.     let isContinue = false
  628.     this.templates = await getTemplate()
  629.     //判断模板是否存在
  630.     if (!this.templates || this.templates.length === 0) {
  631.       throw new Error('当前不存在项目模板')
  632.     }
  633.     if (this.isCmdEmpty(localPath)) {
  634.       //1.1 询问是否继续创建
  635.       if (!force) {
  636.         const res = await inquirer.prompt({
  637.           type: 'confirm',
  638.           name: 'isContinue',
  639.           message: '当前文件夹内容不为空,是否在此继续创建项目?',
  640.           default: false
  641.         })
  642.         isContinue = res.isContinue
  643.         if (!isContinue) {
  644.           return false
  645.         }
  646.       }
  647.     }
  648.     // 2.是否启动强制安装
  649.     if (isContinue || force) {
  650.       const { isDelete } = await inquirer.prompt({
  651.         type: 'confirm',
  652.         name: 'isDelete',
  653.         message: '是否清空当前目录下的文件?',
  654.         default: false
  655.       })
  656.       if (isDelete) {
  657.         // 清空当前目录
  658.         fse.emptyDirSync(localPath)
  659.       }
  660.     }
  661.     return this.getBaseInfo()
  662.   }
  664.   //3、选择创建项目或组件
  665.   async getBaseInfo() {
  666.     let info = {}
  667.     function isNamevalid(val) {
  668.       return /^[a-zA-Z]+([-][a-zA-Z0-9]|[_][a-zA-Z0-9]|[a-zA-Z0-9])*$/.test(val)
  669.     }
  670.     const { type } = await inquirer.prompt({
  671.       type: 'list',
  672.       message: '请选择初始化类型',
  673.       name: 'type',
  674.       default: TYPE_PROJECT,
  675.       choices: [
  676.         {
  677.           name: '项目',
  678.           value: TYPE_PROJECT
  679.         },
  680.         {
  681.           name: '组件',
  682.           value: TYPE_COMPONENT
  683.         }
  684.       ]
  685.     })
  686.     const title = TYPE_PROJECT === type ? '项目' : '组件'
  687.     const promptArr = [
  688.       {
  689.         type: 'input',
  690.         message: `请输入${title}版本号`,
  691.         name: 'version',
  692.         default: '1.0.0',
  693.         validate: val => !!semver.valid(val) || '请输入合法的版本号',
  694.         filter: val => {
  695.           if (!!semver.valid(val)) {
  696.             return semver.valid(val)
  697.           }
  698.           return val
  699.         }
  700.       },
  701.       {
  702.         type: 'list',
  703.         message: `请选择${title}模板`,
  704.         name: 'npmName',
  705.         choices: this.createTemplateChoice(type)
  706.       }
  707.     ]
  708.     const projectPromt = {
  709.       type: 'input',
  710.       message: `请输入${title}名称`,
  711.       name: 'project',
  712.       default: 'HahaDemo',
  713.       validate: function (val) {
  714.         //检查项目名称和版本号的合法性
  715.         const done = this.async()
  716.         setTimeout(function () {
  717.           //1、必须首字母大写，
  718.           //2、尾字符必须为英文或者数字，不能为字符
  719.           //3、字符仅允许'-_'
  720.           //类型合法有：a a-b a_b a-b-c a_b_c a1_b1_c1 a1 a1-b1-c1
  721.           if (!isNamevalid(val)) {
  722.             done(`请输入合法的${title}名称(要求英文字母开头,数字或字母结尾,字符只允许使用 - 以及 _)`)
  723.             return
  724.           }
  725.           done(null, true)
  726.         }, 0)
  727.       }
  728.     }
  729.     //命令行输入的projectName是否合法，不合法则重新填入项目名称
  730.     if (!isNamevalid(this.projectName)) {
  731.       promptArr.unshift(projectPromt)
  732.     } else {
  733.       info.project = this.projectName
  734.     }
  735.     if (type === TYPE_COMPONENT) {
  736.       const descriptPrompt = {
  737.         type: 'input',
  738.         message: `请输入${title}描述`,
  739.         name: 'description',
  740.         validate: val => {
  741.           if (!val) {
  742.             return '组件描述不可以为空'
  743.           }
  744.           return true
  745.         }
  746.       }
  747.       promptArr.push(descriptPrompt)
  748.     }
  749.     const result = await inquirer.prompt(promptArr)
  750.     if (result?.project) {
  751.       info.project = result?.project
  752.     }
  753.     //4、获取项目的基本信息
  754.     return {
  755.       type,
  756.       ...result,
  757.       ...info,
  758.       className: require('kebab-case')(info.project).replace(/^-/, '')
  759.     }
  760.   }
  762.   createTemplateChoice(type) {
  763.     return this.templates
  764.       .filter(item => item.tag === type)
  765.       ?.map(item => ({
  766.         name: item.name,
  767.         value: item.npmName
  768.       }))
  769.   }
  771.   //判断当前路径是否不为空
  772.   isCmdEmpty(localPath) {
  773.     let fileList = fs.readdirSync(localPath)
  774.     fileList = fileList.filter(item => !item.startsWith('.') && item !== 'node_modules')
  775.     return fileList && fileList.length > 0
  776.   }
  777. }
  779. function init(argv) {
  780.   return new initCommand(argv)
  781. }
  783. module.exports = init
  784. module.exports.initCommand = initCommand
  785. 'use strict'
  787. const fs = require('fs')
  788. const path = require('path')
  789. const inquirer = require('inquirer')
  790. const fse = require('fs-extra')
  791. const semver = require('semver')
  792. const ejs = require('ejs')
  793. const Command = require('@haha-cli-dev/command')
  794. const log = require('@haha-cli-dev/log')
  795. const packages = require('@haha-cli-dev/packages')
  796. const { spinnerStart, execAysnc } = require('@haha-cli-dev/utils')
  798. const { getTemplate } = require('./template')
  800. const TYPE_PROJECT = 'project'
  801. const TYPE_COMPONENT = 'component'
  802. const templateTypes = {
  803.   TEMPLATE_TYPE_NORMAL: 'normal',
  804.   TEMPLATE_TYPE_CUSTOM: 'custom'
  805. }
  807. let dir = path.resolve(process.cwd(), 'vue-test2')
  809. //白名单
  810. const WHITE_COMMAND = ['npm', 'cnpm', 'yarn']
  812. class initCommand extends Command {
  813.   init() {
  814.     this.projectName = this._argv[0]
  815.   }
  817.   /*
  818.     1、准备阶段
  819.     2、下载模板
  820.     3、安装模板
  821.    */
  822.   async exec() {
  823.     try {
  824.       //记得加上async，使同步运行，一个trycatch可以捕获方法内的错误
  825.       //1、准备阶段
  826.       this.projectInfo = await this.prepare()
  827.       if (!this.projectInfo) return false
  828.       //2、下载模板
  829.       await this.downloadTemplate()
  830.       //3、安装模板
  831.       await this.installTemplate()
  832.     } catch (e) {
  833.       log.error(e?.message)
  834.       if (process.env.LOG_LEVEL === 'verbose') {
  835.         console.log('e', e)
  836.       }
  837.     }
  838.   }
  840.   async installTemplate() {
  841.     if (this.template) {
  842.       if (!this.template.npmType) {
  843.         this.template.npmType = templateTypes.TEMPLATE_TYPE_NORMAL
  844.       }
  845.       if (this.template.npmType === templateTypes.TEMPLATE_TYPE_CUSTOM) {
  846.         await this.installCustomTemplate()
  847.       } else if (this.template.npmType === templateTypes.TEMPLATE_TYPE_NORMAL) {
  848.         await this.installNormalTemplate()
  849.       } else {
  850.         throw new Error('无法识别项目模板信息')
  851.       }
  852.     } else {
  853.       throw new Error('项目模板信息不存在')
  854.     }
  855.   }
  857.   //自定义安装
  858.   async installCustomTemplate() {}
  860.   //标准安装
  861.   async installNormalTemplate() {
  862.     const spinner = spinnerStart()
  863.     try {
  864.       console.log(this.pkg)
  865.       //拷贝模板代码到当前目录
  866.       const templatePath = path.resolve(this.pkg.cacheFilePath, 'template')
  867.       const targetPath = process.cwd()
  868.       fse.ensureDirSync(templatePath)
  869.       fse.ensureDirSync(targetPath)
  870.       fse.copySync(templatePath, targetPath)
  871.     } catch (error) {
  872.       throw error
  873.     } finally {
  874.       spinner.stop(true)
  875.       log.success('模板安装成功')
  876.     }
  878.     const ignore = ['node_modules/**', 'public/**']
  879.     await this.ejsRender(ignore)
  881.     await this.execCommand(this.template.installCommand, '依赖安装')
  882.     await this.execCommand(this.template.startCommand, '项目启动')
  883.   }
  885.   //ejs渲染=>将模板中的转成模板中package.json定义的版本
  886.   ejsRender(ignore) {
  887.     return new Promise((resolve, reject) => {
  888.       //得到文件夹下除去ignore的所有路径，
  889.       require('glob')(
  890.         '**',
  891.         {
  892.           ignore,
  893.           cwd: dir,
  894.           nodir: true
  895.         },
  896.         (err, files) => {
  897.           if (err) {
  898.             reject(err)
  899.           }
  900.           Promise.all(
  901.             files.map(file => {
  902.               //得到每一个文件的具体路径
  903.               const filePath = path.join(dir, file)
  904.               return new Promise((resolve1, reject1) => {
  905.                 //解析文件
  906.                 ejs.renderFile(filePath, this.projectInfo, {}, function (err, str) {
  907.                   if (err) {
  908.                     reject1(err)
  909.                   } else {
  910.                     //使用renderFile得到的str是字符串，需要转成文件
  911.                     fse.writeFileSync(filePath, str)
  912.                     resolve1(str)
  913.                   }
  914.                 })
  915.               })
  916.             })
  917.           )
  918.             .then(() => resolve(files))
  919.             .catch(err => reject(err))
  920.         }
  921.       )
  922.     })
  923.   }
  925.   //白名单检测
  926.   checkWhiteCommand(cmd) {
  927.     if (WHITE_COMMAND.includes(cmd)) {
  928.       return cmd
  929.     }
  930.     return null
  931.   }
  933.   //安装命令
  934.   async execCommand(cmd, message) {
  935.     if (cmd) {
  936.       const tempCmd = cmd.split(' ')
  937.       const mainCmd = this.checkWhiteCommand(tempCmd[0])
  938.       if (!mainCmd) throw new Error('命令不存在')
  939.       const args = tempCmd.slice(1)
  940.       const installRet = await execAysnc(mainCmd, args, {
  941.         cwd: dir, //cwd 子进程的当前工作目录
  942.         stdio: 'inherit' //inherit  将相应的stdio传给父进程或者从父进程传入，相当于process.stdin,process.stout和process.stderr
  943.       })
  944.       if (installRet === 0) {
  945.         log.success(message + '成功')
  946.       } else {
  947.         throw new Error(message + '失败')
  948.       }
  949.     }
  950.   }
  952.   /*
  953.   下载模板
  954.     1、通过项目模板API获取项目模板信息
  955.      1.1通过egg.js搭建后端系统
  956.      1.2通过npm存储项目模板
  957.      1.3将项目模板信息存储到mongoDB数据库中
  958.      1.4通过egg.js获取mongoDB的数据并通过API返回
  959.     3、选择创建组件或项目
  960.     4、获取项目的基本信息
  961.   */
  962.   async downloadTemplate() {
  963.     const homePath = process.env.CLI_HOME_PATH
  964.     const targetPath = path.resolve(homePath, 'templates')
  965.     const storeDir = path.resolve(targetPath, 'node_modules')
  966.     this.template = this.templates.find(item => item.npmName === this.projectInfo.npmName)
  967.     const { npmName, version } = this.template
  968.     this.pkg = new packages({
  969.       targetPath,
  970.       storeDir,
  971.       packageName: npmName,
  972.       packageVersion: version
  973.     })
  974.     if (await this.pkg.exists()) {
  975.       const spinner = spinnerStart('模板更新中，请稍候')
  976.       try {
  977.         //更新
  978.         await this.pkg.update()
  979.       } catch (error) {
  980.         //抛出异常，让上层捕获
  981.         throw error
  982.       } finally {
  983.         //解决下载出错时，仍提示下载中的情况
  984.         spinner.stop(true)
  985.         if (await this.pkg.exists()) {
  986.           log.success('模板更新成功')
  987.         }
  988.       }
  989.     } else {
  990.       const spinner = spinnerStart('模板下载中，请稍候')
  991.       try {
  992.         //初始化
  993.         await this.pkg.install()
  994.       } catch (error) {
  995.         //抛出异常，让上层捕获
  996.         throw error
  997.       } finally {
  998.         //解决下载出错时，仍提示下载中的情况
  999.         spinner.stop(true)
  1000.         if (await this.pkg.exists()) {
  1001.           log.success('模板下载成功')
  1002.         }
  1003.       }
  1004.     }
  1005.   }
  1007.   /*
  1008.     准备阶段
  1009.     1、判断当前目录是否为空
  1010.       1.1 询问是否继续创建
  1011.     2、是否启动强制更新
  1012.     3、选择创建组件或项目
  1013.     4、获取项目的基本信息
  1014.   */
  1015.   async prepare() {
  1016.     //当前执行node命令时候的文件夹地址 ——工作目录
  1017.     const localPath = process.cwd()
  1018.     const force = this._argv[1]?.force
  1019.     let isContinue = false
  1020.     this.templates = await getTemplate()
  1021.     //判断模板是否存在
  1022.     if (!this.templates || this.templates.length === 0) {
  1023.       throw new Error('当前不存在项目模板')
  1024.     }
  1025.     if (this.isCmdEmpty(localPath)) {
  1026.       //1.1 询问是否继续创建
  1027.       if (!force) {
  1028.         const res = await inquirer.prompt({
  1029.           type: 'confirm',
  1030.           name: 'isContinue',
  1031.           message: '当前文件夹内容不为空,是否在此继续创建项目?',
  1032.           default: false
  1033.         })
  1034.         isContinue = res.isContinue
  1035.         if (!isContinue) {
  1036.           return false
  1037.         }
  1038.       }
  1039.     }
  1040.     // 2.是否启动强制安装
  1041.     if (isContinue || force) {
  1042.       const { isDelete } = await inquirer.prompt({
  1043.         type: 'confirm',
  1044.         name: 'isDelete',
  1045.         message: '是否清空当前目录下的文件?',
  1046.         default: false
  1047.       })
  1048.       if (isDelete) {
  1049.         // 清空当前目录
  1050.         fse.emptyDirSync(localPath)
  1051.       }
  1052.     }
  1053.     return this.getBaseInfo()
  1054.   }
  1056.   //3、选择创建项目或组件
  1057.   async getBaseInfo() {
  1058.     let info = {}
  1059.     function isNamevalid(val) {
  1060.       return /^[a-zA-Z]+([-][a-zA-Z0-9]|[_][a-zA-Z0-9]|[a-zA-Z0-9])*$/.test(val)
  1061.     }
  1062.     const { type } = await inquirer.prompt({
  1063.       type: 'list',
  1064.       message: '请选择初始化类型',
  1065.       name: 'type',
  1066.       default: TYPE_PROJECT,
  1067.       choices: [
  1068.         {
  1069.           name: '项目',
  1070.           value: TYPE_PROJECT
  1071.         },
  1072.         {
  1073.           name: '组件',
  1074.           value: TYPE_COMPONENT
  1075.         }
  1076.       ]
  1077.     })
  1078.     const promptArr = [
  1079.       {
  1080.         type: 'input',
  1081.         message: '请输入项目版本号',
  1082.         name: 'version',
  1083.         default: '1.0.0',
  1084.         validate: function (val) {
  1085.           const done = this.async()
  1086.           setTimeout(function () {
  1087.             //!!semver.valid(val) !!转成Boolean类型
  1088.             if (!!!semver.valid(val)) {
  1089.               done('请输入合法的版本号')
  1090.               return
  1091.             }
  1092.             done(null, true)
  1093.           }, 0)
  1094.         },
  1095.         filter: val => {
  1096.           if (!!semver.valid(val)) {
  1097.             return semver.valid(val)
  1098.           }
  1099.           return val
  1100.         }
  1101.       },
  1102.       {
  1103.         type: 'list',
  1104.         message: '请选择项目模板',
  1105.         name: 'npmName',
  1106.         choices: this.createTemplateChoice()
  1107.       }
  1108.     ]
  1109.     if (type === TYPE_COMPONENT) {
  1110.     }
  1111.     if (type === TYPE_PROJECT) {
  1112.       const projectPromt = {
  1113.         type: 'input',
  1114.         message: '请输入项目名称',
  1115.         name: 'project',
  1116.         default: 'HahaDemo',
  1117.         validate: function (val) {
  1118.           //检查项目名称和版本号的合法性
  1119.           const done = this.async()
  1120.           setTimeout(function () {
  1121.             //1、必须首字母大写，
  1122.             //2、尾字符必须为英文或者数字，不能为字符
  1123.             //3、字符仅允许'-_'
  1124.             //类型合法有：a a-b a_b a-b-c a_b_c a1_b1_c1 a1 a1-b1-c1
  1125.             if (!isNamevalid(val)) {
  1126.               done('请输入合法的项目名称(要求英文字母开头,数字或字母结尾,字符只允许使用 - 以及 _)')
  1127.               return
  1128.             }
  1129.             done(null, true)
  1130.           }, 0)
  1131.         }
  1132.       }
  1133.       //命令行输入的projectName是否合法，不合法则重新填入项目名称
  1134.       if (!isNamevalid(this.projectName)) {
  1135.         promptArr.unshift(projectPromt)
  1136.       } else {
  1137.         info.project = this.projectName
  1138.       }
  1139.       const result = await inquirer.prompt(promptArr)
  1140.       if (result?.project) {
  1141.         info.project = result?.project
  1142.       }
  1143.       //4、获取项目的基本信息
  1144.       return {
  1145.         type,
  1146.         ...result,
  1147.         ...info,
  1148.         className: require('kebab-case')(info.project).replace(/^-/, '')
  1149.       }
  1150.     }
  1151.   }
  1153.   createTemplateChoice() {
  1154.     return this.templates?.map(item => ({
  1155.       name: item.name,
  1156.       value: item.npmName
  1157.     }))
  1158.   }
  1160.   //判断当前路径是否不为空
  1161.   isCmdEmpty(localPath) {
  1162.     let fileList = fs.readdirSync(localPath)
  1163.     fileList = fileList.filter(item => !item.startsWith('.') && item !== 'node_modules')
  1164.     return fileList && fileList.length > 0
  1165.   }
  1166. }
  1168. function init(argv) {
  1169.   return new initCommand(argv)
  1170. }
  1172. module.exports = init
  1173. module.exports.initCommand = initCommand