@npmcli/template-oss 4.1.2 → 4.3.0

package/bin/release-please.js

@@ -6,30 +6,24 @@ const main = require('../lib/release-please/index.js')
 const dryRun = !process.env.CI
 const [branch] = process.argv.slice(2)
 
-const setOutput = (key, val) => {
-  if (val && (!Array.isArray(val) || val.length)) {
-    if (dryRun) {
-      if (key === 'pr') {
-        console.log('PR:', val.title.toString())
-        console.log('='.repeat(40))
-        console.log(val.body.toString())
-        console.log('='.repeat(40))
-        for (const update of val.updates.filter(u => u.updater.changelogEntry)) {
-          console.log('CHANGELOG:', update.path)
-          console.log('-'.repeat(40))
-          console.log(update.updater.changelogEntry)
-          console.log('-'.repeat(40))
-        }
-        for (const update of val.updates.filter(u => u.updater.rawContent)) {
-          console.log('package:', update.path)
-          console.log('-'.repeat(40))
-          console.log(JSON.parse(update.updater.rawContent).name)
-          console.log(JSON.parse(update.updater.rawContent).version)
-          console.log('-'.repeat(40))
-        }
-      }
-    } else {
-      core.setOutput(key, JSON.stringify(val))
+const debugPr = (val) => {
+  if (dryRun) {
+    console.log('PR:', val.title.toString())
+    console.log('='.repeat(40))
+    console.log(val.body.toString())
+    console.log('='.repeat(40))
+    for (const update of val.updates.filter(u => u.updater.changelogEntry)) {
+      console.log('CHANGELOG:', update.path)
+      console.log('-'.repeat(40))
+      console.log(update.updater.changelogEntry)
+      console.log('-'.repeat(40))
+    }
+    for (const update of val.updates.filter(u => u.updater.rawContent)) {
+      console.log('package:', update.path)
+      console.log('-'.repeat(40))
+      console.log(JSON.parse(update.updater.rawContent).name)
+      console.log(JSON.parse(update.updater.rawContent).version)
+      console.log('-'.repeat(40))
     }
   }
 }
@@ -39,10 +33,30 @@ main({
   repo: process.env.GITHUB_REPOSITORY,
   dryRun,
   branch,
-}).then(({ pr, releases, release }) => {
-  setOutput('pr', pr)
-  setOutput('releases', releases)
-  setOutput('release', release)
+}).then(({ pr, release, releases }) => {
+  if (pr) {
+    debugPr(pr)
+    core.setOutput('pr', JSON.stringify(pr))
+    core.setOutput('pr-branch', pr.headBranchName)
+    core.setOutput('pr-number', pr.number)
+    core.setOutput('pr-sha', pr.sha)
+  }
+
+  if (release) {
+    core.setOutput('release', JSON.stringify(release))
+    core.setOutput('release-path', release.path)
+    core.setOutput('release-version', release.version)
+    core.setOutput('release-tag', release.tagName)
+    core.setOutput('release-url', release.url)
+  }
+
+  if (releases) {
+    core.setOutput('releases', JSON.stringify(releases))
+    core.setOutput('release-flags', JSON.stringify(releases.map((r) => {
+      return r.path === '.' ? '-iwr' : `-w ${r.path}`
+    })))
+  }
+
   return null
 }).catch(err => {
   if (dryRun) {

package/lib/apply/apply-files.js

@@ -3,7 +3,7 @@ const log = require('proc-log')
 const { rmEach, parseEach } = require('../util/files.js')
 
 const run = async (dir, files, options) => {
-  const { rm = [], add = {} } = files
+  const { rm, add } = files
 
   log.verbose('apply-files', 'rm', rm)
   await rmEach(dir, rm, options, (f) => fs.rm(f))

package/lib/apply/index.js

@@ -1,6 +1,6 @@
 const run = require('../index.js')
 
-module.exports = (root, content) => run(root, content, [
+module.exports = (root) => run(root, [
   require('./apply-files.js'),
   require('./apply-version.js'),
 ])

package/lib/check/check-apply.js

@@ -2,13 +2,14 @@ const log = require('proc-log')
 const { relative, basename } = require('path')
 const { rmEach, parseEach } = require('../util/files.js')
 const { partition } = require('lodash')
+const localeCompare = require('@isaacs/string-locale-compare')('en')
 
 const solution = 'npx template-oss-apply --force'
 
 const run = async (type, dir, files, options) => {
   const res = []
   const rel = (f) => relative(options.root, f)
-  const { add: addFiles = {}, rm: rmFiles = [] } = files
+  const { add: addFiles, rm: rmFiles } = files
 
   const rm = await rmEach(dir, rmFiles, options, (f) => rel(f))
   const [add, update] = partition(await parseEach(dir, addFiles, options, async (p) => {
@@ -28,7 +29,7 @@ const run = async (type, dir, files, options) => {
   if (rm.length) {
     res.push({
       title: `The following ${type} files need to be deleted:`,
-      body: rm,
+      body: rm.sort(localeCompare),
       solution,
     })
   }
@@ -37,13 +38,13 @@ const run = async (type, dir, files, options) => {
   if (add.length) {
     res.push({
       title: `The following ${type} files need to be added:`,
-      body: add,
+      body: add.sort(localeCompare),
       solution,
     })
   }
 
   log.verbose('check-apply', 'update', update)
-  res.push(...update.map(({ file, diff }) => ({
+  res.push(...update.sort((a, b) => localeCompare(a.file, b.file)).map(({ file, diff }) => ({
     title: `The ${type} file ${basename(file)} needs to be updated:`,
     body: [`${file}\n${'='.repeat(40)}\n${diff}`],
     solution,

package/lib/check/index.js

@@ -1,6 +1,6 @@
 const run = require('../index.js')
 
-module.exports = (root, content) => run(root, content, [
+module.exports = (root) => run(root, [
   require('./check-apply.js'),
   require('./check-required.js'),
   require('./check-unwanted.js'),

package/lib/config.js

@@ -1,101 +1,154 @@
-const { relative, dirname, join, posix, win32 } = require('path')
-const log = require('proc-log')
-const { uniq, defaults } = require('lodash')
+const { relative, dirname, join, extname, posix, win32 } = require('path')
+const { defaults, pick, omit, uniq } = require('lodash')
 const parseCIVersions = require('./util/parse-ci-versions.js')
 const getGitUrl = require('./util/get-git-url.js')
-const { name: NAME, version: LATEST_VERSION } = require('../package.json')
+const gitignore = require('./util/gitignore.js')
+const { withArrays } = require('./util/merge.js')
+const { FILE_KEYS, parseConfig: parseFiles, getAddedFiles } = require('./util/files.js')
 
 const CONFIG_KEY = 'templateOSS'
 const getPkgConfig = (pkg) => pkg[CONFIG_KEY] || {}
 
-const getContent = (contentPath) => {
-  if (typeof contentPath === 'string') {
-    return defaults(require(contentPath), {
-      sourceDir: dirname(require.resolve(contentPath)),
-    })
-  } else {
-    // allow passing in content directly for tests
-    return contentPath
+const { name: NAME, version: LATEST_VERSION } = require('../package.json')
+const MERGE_KEYS = [...FILE_KEYS, 'defaultContent', 'content']
+const DEFAULT_CONTENT = require.resolve(NAME)
+
+const merge = withArrays('branches', 'distPaths', 'allowPaths', 'ignorePaths')
+
+const makePosix = (v) => v.split(win32.sep).join(posix.sep)
+const deglob = (v) => makePosix(v).replace(/[/*]+$/, '')
+const posixDir = (v) => `${v === '.' ? '' : deglob(v).replace(/\/$/, '')}${posix.sep}`
+const posixGlob = (str) => `${posixDir(str)}**`
+
+const getCmdPath = (key, { rootConfig, defaultConfig, isRoot, path, root }) => {
+  // Make a path relative from a workspace to the root if we are in a workspace
+  const wsToRoot = (p) => isRoot ? p : makePosix(join(relative(path, root), p))
+
+  const rootPath = rootConfig[key]
+  const defaultPath = defaultConfig[key]
+  const isLocal = rootPath && rootPath !== defaultPath
+
+  return {
+    isLocal,
+    root: !isLocal ? defaultPath : `node ${rootPath}`,
+    local: !isLocal ? defaultPath : `node ${wsToRoot(rootPath)}`,
   }
 }
 
-// falsy means no content of this type
-const getFiles = (config, content) => config ? content : null
-const getFileKeys = (files) => files ? Object.keys(files.add || {}) : []
-const negatePath = (p) => {
-  // XXX: this negates the first part of each path for the gitignore
-  // files. it might make sense to negate more specific portions of the
-  // path for some paths like workspaces. so instead of ignoring !/workspaces
-  // it would only ignore !/workspaces/a, !/workspaces/b, etc
-  const [first, ...parts] = p.split(posix.sep)
-  const isDir = parts.length > 0
-  return `!${posix.sep}${first}${isDir ? posix.sep : ''}`
+const mergeConfigs = (...configs) => {
+  const mergedConfig = merge(...configs.map(c => pick(c, MERGE_KEYS)))
+  return defaults(mergedConfig, {
+    defaultContent: DEFAULT_CONTENT,
+    // allow all file types by default
+    ...FILE_KEYS.reduce((acc, key) => {
+      acc[key] = true
+      return acc
+    }, {}),
+  })
 }
 
-const makePosix = (str) => str.split(win32.sep).join(posix.sep)
+const readContentPath = (path) => {
+  if (!path) {
+    return {}
+  }
 
-const getConfig = async ({
-  pkgs,
-  workspaces,
+  let content = {}
+  const index = extname(path) === '.js' ? path : join(path, 'index.js')
+  const dir = dirname(index)
+
+  try {
+    content = require(index)
+  } catch {
+    // its ok if this fails since the content dir
+    // might only be to provide other files. the
+    // index.js is optional
+  }
+
+  return { content, dir }
+}
+
+const getConfig = (path, rawConfig) => {
+  const config = omit(readContentPath(path).content, FILE_KEYS)
+  return merge(config, rawConfig ? omit(rawConfig, FILE_KEYS) : {})
+}
+
+const getFiles = (path, rawConfig) => {
+  const { content, dir } = readContentPath(path)
+  if (!dir) {
+    return []
+  }
+  return [parseFiles(pick(content, FILE_KEYS), dir, pick(rawConfig, FILE_KEYS)), dir]
+}
+
+const getFullConfig = async ({
+  // the path to the root of the repo
   root,
+  // the path to the package being operated on
+  // this is the same as root when operating on the root
   path,
-  pkg,
-  // default content path is looked up via require.resolve
-  // so use the name of this module since package.json#main
-  // points to the content dir
-  content: contentPath = NAME,
-  config: {
-    rootRepo,
-    rootModule,
-    workspaceRepo,
-    workspaceModule,
-    version,
-    ...pkgConfig // this includes config merged in from root
-  },
+  // the full contents of the package.json for this package
+  pkgJson,
+  // an array of all package info {pkgJson,path,config}[]
+  pkgs,
+  // an array of all workspaces in this repo
+  workspaces,
+  // the config from the package.json in the root
+  rootConfig: _rootConfig,
+  // the config from the package.json being operated on
+  pkgConfig: _pkgConfig,
 }) => {
   const isRoot = root === path
-  const isLatest = version === LATEST_VERSION
-  const isDogFood = pkg.name === NAME
+  const isLatest = _pkgConfig.version === LATEST_VERSION
+  const isDogFood = pkgJson.name === NAME
   const isForce = process.argv.includes('--force')
-  const rawPkgConfig = getPkgConfig(pkg)
-
-  // this is written to ci yml files so it needs to always use posix
-  const pkgRelPath = makePosix(relative(root, path))
-  const gitUrl = await getGitUrl(root)
 
-  const {
-    rootRepo: rootRepoContent,
-    rootModule: rootModuleContent,
-    workspaceRepo: workspaceRepoContent,
-    workspaceModule: workspaceModuleContent,
-    ...baseContent
-  } = getContent(contentPath)
-
-  let repoFiles, moduleFiles
-  const ignorePaths = []
-
-  if (isRoot) {
-    repoFiles = getFiles(rootRepo, rootRepoContent)
-    moduleFiles = getFiles(rootModule, rootModuleContent)
-    ignorePaths.push(
-      // allow workspace paths if they are set, this is directly from
-      // map-workspaces so normalize to posix paths for gitignore
-      ...workspaces.map((p) => makePosix(relative(root, p))),
-      // allow both the repo and module files since this is the root
-      ...getFileKeys(repoFiles),
-      ...getFileKeys(moduleFiles),
-      // allow all workspace repo level files
-      ...pkgs.filter((p) => p.path !== path).flatMap((p) =>
-        getFileKeys(getFiles(p.config.workspaceRepo, workspaceRepoContent))
-      )
-    )
-  } else {
-    repoFiles = getFiles(workspaceRepo, workspaceRepoContent)
-    moduleFiles = getFiles(workspaceModule, workspaceModuleContent)
-    // In a workspace gitignores are relative to the workspace dir
-    // so we should only allow added module files
-    ignorePaths.push(...getFileKeys(moduleFiles))
-  }
+  // These config items are merged betweent the root and child workspaces and only come from
+  // the package.json because they can be used to read configs from other the content directories
+  const mergedConfig = mergeConfigs(_rootConfig, _pkgConfig)
+
+  const defaultConfig = getConfig(DEFAULT_CONTENT)
+  const [defaultFiles, defaultDir] = getFiles(DEFAULT_CONTENT, mergedConfig)
+  const useDefault = mergedConfig.defaultContent && defaultConfig
+
+  const rootConfig = getConfig(_rootConfig.content, _rootConfig)
+  const [rootFiles, rootDir] = getFiles(_rootConfig.content, mergedConfig)
+
+  // The content config only gets set from the package we are in, it doesn't inherit
+  // anything from the root
+  const rootPkgConfig = merge(useDefault, rootConfig)
+  const pkgConfig = merge(useDefault, getConfig(_pkgConfig.content, _pkgConfig))
+  const [pkgFiles, pkgDir] = getFiles(mergedConfig.content, mergedConfig)
+
+  // Files get merged in from the default content (that template-oss provides) as well
+  // as any content paths provided from the root or the workspace
+  const fileDirs = uniq([useDefault && defaultDir, rootDir, pkgDir].filter(Boolean))
+  const files = merge(useDefault && defaultFiles, rootFiles, pkgFiles)
+  const repoFiles = isRoot ? files.rootRepo : files.workspaceRepo
+  const moduleFiles = isRoot ? files.rootModule : files.workspaceModule
+
+  const allowRootDirs = [
+    // Allways allow module files in root or workspaces
+    ...getAddedFiles(moduleFiles),
+    ...isRoot ? [
+      // in the root allow all repo files
+      ...getAddedFiles(repoFiles),
+      // and allow all workspace repo level files in the root
+      ...pkgs
+        .filter(p => p.path !== root && p.config.workspaceRepo !== false)
+        .flatMap(() => getAddedFiles(files.workspaceRepo)),
+    ] : [],
+  ]
+
+  // root only configs
+  const npmPath = getCmdPath('npm', { rootConfig, defaultConfig, isRoot, path, root })
+  const npxPath = getCmdPath('npx', { rootConfig, defaultConfig, isRoot, path, root })
+
+  // these are written to ci yml files so it needs to always use posix
+  const pkgPath = makePosix(relative(root, path)) || '.'
+
+  // we use the raw paths from the package.json workspaces as ignore patterns in
+  // some cases. the workspaces passed in have already been run through map workspaces
+  const workspacePaths = (pkgJson.workspaces || []).map(deglob)
 
   // all derived keys
   const derived = {
@@ -106,7 +159,8 @@ const getConfig = async ({
     // For these cases it is helpful to know if we are in a
     // monorepo since template-oss might be used only for
     // workspaces and not the root or vice versa.
-    isMono: (isRoot && workspaces.length > 0) || !isRoot,
+    isRootMono: isRoot && !!workspaces.length,
+    isMono: !!workspaces.length,
     // repo
     repoDir: root,
     repoFiles,
@@ -116,14 +170,41 @@ const getConfig = async ({
     moduleFiles,
     applyModule: !!moduleFiles,
     // package
-    pkgName: pkg.name,
-    pkgNameFs: pkg.name.replace(/\//g, '-').replace(/@/g, ''),
-    pkgRelPath: pkgRelPath,
-    pkgPrivate: !!pkg.private,
+    pkgName: pkgJson.name,
+    pkgNameFs: pkgJson.name.replace(/\//g, '-').replace(/@/g, ''),
+    // paths
+    pkgPath,
+    pkgDir: posixDir(pkgPath),
+    pkgGlob: posixGlob(pkgPath),
+    pkgFlags: isRoot ? '-iwr' : `-w ${pkgJson.name}`,
+    allFlags: '-ws -iwr --if-present',
+    workspacePaths,
+    workspaceGlobs: workspacePaths.map(posixGlob),
     // booleans to control application of updates
     isForce,
     isDogFood,
     isLatest,
+    // whether to install and update npm in ci
+    // only do this if we aren't using a custom path to bin
+    updateNpm: !npmPath.isLocal,
+    rootNpmPath: npmPath.root,
+    localNpmPath: npmPath.local,
+    rootNpxPath: npxPath.root,
+    // lockfiles are only present at the root, so this only should be set for
+    // all workspaces based on the root
+    lockfile: rootPkgConfig.lockfile,
+    // gitignore
+    ignorePaths: [
+      ...gitignore.sort([
+        ...gitignore.allowRootDir(allowRootDirs),
+        ...isRoot && pkgConfig.lockfile ? ['!/package-lock.json'] : [],
+        ...(pkgConfig.allowPaths || []).map((p) => `!${p}`),
+        ...(pkgConfig.ignorePaths || []),
+      ]),
+      // these cant be sorted since they rely on order
+      // to allow a previously ignored directoy
+      ...isRoot ? gitignore.allowDir(workspaces.map((p) => makePosix(relative(root, p)))) : [],
+    ],
     // needs update if we are dogfooding this repo, with force argv, or its
     // behind the current version
     needsUpdate: isForce || isDogFood || !isLatest,
@@ -131,55 +212,31 @@ const getConfig = async ({
     __NAME__: NAME,
     __CONFIG_KEY__: CONFIG_KEY,
     __VERSION__: LATEST_VERSION,
+    __PARTIAL_DIRS__: fileDirs,
   }
 
-  // merge the rest of base and pkg content to make the
-  // full content object
-  const content = { ...baseContent, ...pkgConfig }
-
-  // set some defaults on content that can be overwritten unlike
-  // derived values which are calculated from other config
-  const contentDefaults = {}
-
-  if (content.npmBin && content.npmBin !== baseContent.npmBin) {
-    // make it relative to each workspace if they did not set the config themselves
-    if (!rawPkgConfig.npmBin) {
-      content.npmBin = makePosix(join(relative(path, root), content.npmBin))
-    }
-    // a bit of a hack but allow custom node paths or no node path at all
-    // checks if the first thing has node somewhere in it and if it doesnt
-    // puts a system node in front of the script
-    const execPaths = content.npmBin.split(' ')[0].split(posix.sep)
-    if (execPaths.every(p => p !== 'node')) {
-      content.npmBin = `node ${content.npmBin}`
-    }
-  }
-  if (Array.isArray(content.ciVersions)) {
-    const parsed = parseCIVersions(content.ciVersions)
-    contentDefaults.engines = parsed.engines
-    content.ciVersions = parsed.targets
-    log.verbose('config ci', parsed)
+  if (pkgConfig.ciVersions) {
+    const versions = pkgConfig.ciVersions
+    const defaultVersions = defaultConfig.ciVersions
+    const parsed = parseCIVersions(versions === 'latest' ? defaultVersions.slice(-1) : versions)
+    derived.ciVersions = parsed.targets
+    derived.engines = pkgConfig.engines || parsed.engines
   }
 
+  const gitUrl = await getGitUrl(root)
   if (gitUrl) {
-    contentDefaults.repository = {
+    derived.repository = {
       type: 'git',
       url: gitUrl,
-      ...(pkgRelPath ? { directory: pkgRelPath } : {}),
+      ...(!isRoot ? { directory: pkgPath } : {}),
     }
   }
 
-  contentDefaults.ignorePaths = uniq(
-    [...ignorePaths, ...(content.distPaths || [])].map(negatePath)
-  ).sort()
-
-  log.verbose('config', 'defaults', contentDefaults)
-
   return {
-    ...defaults(content, contentDefaults),
+    ...pkgConfig,
     ...derived,
   }
 }
 
-module.exports = getConfig
+module.exports = getFullConfig
 module.exports.getPkgConfig = getPkgConfig

package/lib/content/_job-matrix.yml

@@ -0,0 +1,29 @@
+name: {{ jobName }}
+if: github.repository_owner == 'npm'
+strategy:
+  fail-fast: false
+  matrix:
+    platform:
+      - name: Linux
+        os: ubuntu-latest
+        shell: bash
+      {{#if macCI}}
+      - name: macOS
+        os: macos-latest
+        shell: bash
+      {{/if}}
+      {{#if windowsCI}}
+      - name: Windows
+        os: windows-latest
+        shell: cmd
+      {{/if}}
+    node-version:
+      {{#each ciVersions}}
+      - {{ . }}
+      {{/each}}
+runs-on: $\{{ matrix.platform.os }}
+defaults:
+  run:
+    shell: $\{{ matrix.platform.shell }}
+steps:
+  {{> stepsSetup jobNodeMatrix=true }}

package/lib/content/_job.yml

@@ -0,0 +1,8 @@
+name: {{ jobName }}
+if: github.repository_owner == 'npm' {{~#if jobIf}} && {{{ jobIf }}}{{/if}}
+runs-on: ubuntu-latest
+defaults:
+  run:
+    shell: bash
+steps:
+  {{> stepsSetup }}

package/lib/content/_on-ci.yml

@@ -0,0 +1,30 @@
+workflow_dispatch:
+pull_request:
+  {{#if isWorkspace}}
+  paths:
+    - {{ pkgGlob }}
+  {{/if}}
+  {{#if isRootMono}}
+  paths-ignore:
+    {{#each workspaceGlob}}
+    - {{ . }}
+    {{/each}}
+  {{/if}}
+push:
+  branches:
+    {{#each branches}}
+    - {{ . }}
+    {{/each}}
+  {{#if isWorkspace}}
+  paths:
+    - {{ pkgGlob }}
+  {{/if}}
+  {{#if isRootMono}}
+  paths-ignore:
+    {{#each workspaceGlob}}
+    - {{ . }}
+    {{/each}}
+  {{/if}}
+schedule:
+  # "At 09:00 UTC (02:00 PT) on Monday" https://crontab.guru/#0_9_*_*_1
+  - cron: "0 9 * * 1"

package/lib/content/_step-checks.yml

@@ -0,0 +1,24 @@
+- name: {{#if jobCheck.sha}}Create{{else}}Conclude{{/if}} Check
+  uses: LouisBrunner/checks-action@v1.3.1
+  {{#if jobCheck.sha}}
+  id: check
+  {{#if jobCheck.if}}if: {{ jobCheck.if }}{{/if}}
+  {{else}}
+  if: always()
+  {{/if}}
+  with:
+    token: $\{{ secrets.GITHUB_TOKEN }}
+    {{#if jobCheck.sha}}
+    status: {{#if jobCheck.status}}{{ jobCheck.status }}{{else}}in_progress{{/if}} 
+    name: {{#if jobCheck.name}}{{ jobCheck.name }}{{else}}{{ jobName }}{{/if}}
+    sha: {{ jobCheck.sha }}
+    # XXX: this does not work when using the default GITHUB_TOKEN.
+    # Instead we post the main job url to the PR as a comment which
+    # will link to all the other checks. To work around this we would
+    # need to create a GitHub that would create on-demand tokens.
+    # https://github.com/LouisBrunner/checks-action/issues/18
+    # details_url:
+    {{else}}
+    conclusion: {{#if jobCheck.status}}{{ jobCheck.status }}{{else}}$\{{ job.status }}{{/if}}
+    check_id: {{#if jobCheck.id}}{{ jobCheck.id }}{{else}}$\{{ steps.check.outputs.check_id }}{{/if}}
+    {{/if}}

package/lib/content/_step-deps.yml

@@ -0,0 +1,2 @@
+- name: Install Dependencies
+  run: {{ rootNpmPath }} i --ignore-scripts --no-audit --no-fund {{~#if jobDepFlags}} {{ jobDepFlags }}{{/if}}

package/lib/content/_step-git.yml

@@ -0,0 +1,12 @@
+- name: Checkout
+  uses: actions/checkout@v3
+  {{#if jobCheckout}}
+  with:
+  {{#each jobCheckout}}
+    {{ @key }}: {{ this }}
+  {{/each}}
+  {{/if}}
+- name: Setup Git User
+  run: |
+    git config --global user.email "npm-cli+bot@github.com"
+    git config --global user.name "npm CLI robot"

package/lib/content/_step-lint.yml

@@ -0,0 +1,4 @@
+- name: Lint
+  run: {{ rootNpmPath }} run lint --ignore-scripts
+- name: Post Lint
+  run: {{ rootNpmPath }} run postlint --ignore-scripts