feat: support non-interactive project creation and optional git

Author: bjohansebas

README.md

@@ -35,6 +35,19 @@ and optional GitHub Actions deployment. It creates `config.js`, `package.json`,
 `.gitignore`, and a local Git repository. Choose a new or empty directory;
 existing project files are never overwritten.
 
+For scripts, use `--yes` (`-y`) to skip all prompts. Omitted values default to
+the `statusboard` directory, built-in labels, no organizations or repositories,
+no GitHub Actions workflow, and Git initialization enabled. Override these with
+`--orgs`, `--repositories`, `--labels`, `--github-actions`, and `--no-git`:
+
+```sh
+npx @pkgjs/statusboard create my-statusboard --yes --orgs pkgjs,nodejs \
+  --repositories expressjs/express --labels "help wanted,bug" --github-actions --no-git
+```
+
+These options also work interactively: only unspecified settings are prompted.
+Use `--labels ""` for no issue labels or `--no-github-actions` to skip the workflow.
+
 Set `GITHUB_TOKEN` in your environment or in a local `.env` file, then run:
 
 ```sh

lib/cli.js

@@ -85,8 +85,15 @@ module.exports = (create, builder, argv) => {
     .command('create [directory]', 'Create a StatusBoard', (cli) => cli.positional('directory', {
       description: 'Directory for the new project',
       type: 'string'
+    }).options({
+      yes: { alias: 'y', type: 'boolean', default: false, description: 'Use defaults without prompting' },
+      orgs: { type: 'string', description: 'Comma-separated organizations' },
+      repositories: { type: 'string', description: 'Comma-separated owner/repo names' },
+      labels: { type: 'string', description: 'Comma-separated issue labels (default: built-in labels)' },
+      'github-actions': { type: 'boolean', description: 'Generate a GitHub Pages workflow' },
+      git: { type: 'boolean', default: true, description: 'Initialize Git (disable with --no-git)' }
     }), async (argv) => {
-      await initStatusboard(argv)
+      await initStatusboard({ ...argv, githubActions: argv['github-actions'] })
     })
 
     .command('build', 'Index and build board', SHARED_OPTIONS, async (argv) => {

lib/commands/create.js

@@ -6,61 +6,83 @@ const { gitInit } = require('../git')
 const packageJson = require('../../package.json')
 
 async function create (opts = {}) {
-  const answers = await inquirer.prompt([
-    {
-      type: 'input',
-      name: 'path',
-      message: 'Where would you like to create your project?',
-      default: 'statusboard',
-      when: () => !opts.directory,
-      validate: value => value.trim().length > 0 || 'Enter a project directory.'
-    },
-    {
-      type: 'confirm',
-      name: 'defaultLabels',
-      message: 'Do you want to use the default labels?',
-      default: true
-    },
-    {
-      type: 'input',
-      name: 'labels',
-      message: 'What labels do you want to use (use commas to separate)?',
-      when: answers => !answers.defaultLabels
-    },
-    {
-      type: 'input',
-      name: 'orgs',
-      message: 'What organizations do you want to include (use commas to separate)?'
-    },
-    {
-      type: 'input',
-      name: 'repositories',
-      message: 'What repositories do you want to include (owner/repo, separated by commas)?',
-      validate: value => transformUserInput(value).every(repo => /^[\w.-]+\/[\w.-]+$/.test(repo)) || 'Use owner/repo for each repository.'
-    },
-    {
-      type: 'confirm',
-      name: 'githubActions',
-      message: 'Do you want to deploy with GitHub Actions?',
-      default: false
-    }
-  ])
+  let directory = opts.directory
+  if (directory === undefined) {
+    directory = opts.yes
+      ? 'statusboard'
+      : (await inquirer.prompt([{
+          type: 'input',
+          name: 'path',
+          message: 'Where would you like to create your project?',
+          default: 'statusboard',
+          validate: async value => {
+            try {
+              await validateDirectory(value)
+              return true
+            } catch (error) {
+              return error.message
+            }
+          }
+        }])).path
+  }
+  const appPath = await validateDirectory(directory)
+  if (opts.repositories !== undefined && !validRepositories(opts.repositories)) {
+    throw new Error('Use owner/repo for each repository.')
+  }
 
-  const directory = (opts.directory || answers.path || '').trim()
-  if (!directory) throw new Error('Enter a project directory.')
-  const appPath = path.resolve(directory)
+  const answers = opts.yes
+    ? {}
+    : await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'defaultLabels',
+        message: 'Do you want to use the default labels?',
+        default: true,
+        when: () => opts.labels === undefined
+      },
+      {
+        type: 'input',
+        name: 'labels',
+        message: 'What labels do you want to use (use commas to separate)?',
+        when: answers => opts.labels === undefined && !answers.defaultLabels
+      },
+      {
+        type: 'input',
+        name: 'orgs',
+        message: 'What organizations do you want to include (use commas to separate)?',
+        when: () => opts.orgs === undefined
+      },
+      {
+        type: 'input',
+        name: 'repositories',
+        message: 'What repositories do you want to include (owner/repo, separated by commas)?',
+        when: () => opts.repositories === undefined,
+        validate: value => validRepositories(value) || 'Use owner/repo for each repository.'
+      },
+      {
+        type: 'confirm',
+        name: 'githubActions',
+        message: 'Do you want to deploy with GitHub Actions?',
+        default: false,
+        when: () => opts.githubActions === undefined
+      }
+    ])
+
+  const repositories = opts.repositories ?? answers.repositories
+  if (!validRepositories(repositories)) throw new Error('Use owner/repo for each repository.')
+  // Recheck after prompting in case the destination changed while waiting.
+  await validateDirectory(appPath)
   await fs.mkdir(appPath, { recursive: true })
-  if ((await fs.readdir(appPath)).length) {
-    throw new Error(`Directory is not empty: ${appPath}`)
-  }
 
   const config = {
     path: appPath,
     name: path.basename(appPath),
-    labels: answers.defaultLabels ? undefined : transformUserInput(answers.labels),
-    orgs: transformUserInput(answers.orgs),
-    projects: transformUserInput(answers.repositories),
-    githubActions: answers.githubActions
+    labels: opts.labels !== undefined
+      ? transformUserInput(opts.labels)
+      : answers.defaultLabels === false ? transformUserInput(answers.labels) : undefined,
+    orgs: transformUserInput(opts.orgs ?? answers.orgs),
+    projects: transformUserInput(repositories),
+    githubActions: opts.githubActions ?? answers.githubActions ?? false
   }
 
   if (config.githubActions) await createBuildAction(config)
@@ -86,7 +108,7 @@ async function create (opts = {}) {
   }
   await fs.writeFile(path.join(appPath, 'package.json'), `${JSON.stringify(manifest, null, 2)}\n`, { flag: 'wx' })
 
-  if (!gitInit(appPath)) {
+  if (opts.git !== false && !gitInit(appPath)) {
     console.warn('Could not create the initial Git commit. Project files are ready; check Git installation and user configuration.')
   }
   console.log(`Created Statusboard in ${appPath}. Run npm install there, set GITHUB_TOKEN, then run npm run build.`)
@@ -95,6 +117,21 @@ async function create (opts = {}) {
   }
 }
 
+async function validateDirectory (directory) {
+  if (typeof directory !== 'string' || !directory.trim()) throw new Error('Enter a project directory.')
+  const appPath = path.resolve(directory.trim())
+  try {
+    if ((await fs.readdir(appPath)).length) throw new Error(`Directory is not empty: ${appPath}`)
+  } catch (error) {
+    if (error.code !== 'ENOENT') throw error
+  }
+  return appPath
+}
+
+function validRepositories (input) {
+  return transformUserInput(input).every(repo => /^[\w.-]+\/[\w.-]+$/.test(repo))
+}
+
 async function createConfigFile (config) {
   const fields = {
     ...(config.labels === undefined ? {} : { issueLabels: config.labels }),
@@ -114,7 +151,7 @@ async function createConfigFile (config) {
 }
 
 function transformUserInput (input = '') {
-  return input.split(',').map(value => value.trim()).filter(Boolean)
+  return [input].flat().flatMap(value => value.split(',')).map(value => value.trim()).filter(Boolean)
 }
 
 async function createBuildAction (config) {

test/create.js

@@ -86,6 +86,7 @@ suite('Create command', () => {
 
   test('preserves an existing nonempty directory', async () => {
     await fs.writeFile(path.join(directory, 'config.js'), 'original')
+    inquirer.prompt = async () => { throw new Error('Must reject the destination before prompting') }
     await assert.rejects(create({ directory }), /Directory is not empty/)
     assert.equal(await fs.readFile(path.join(directory, 'config.js'), 'utf8'), 'original')
     assert.deepEqual(await fs.readdir(directory), ['config.js'])
@@ -96,6 +97,58 @@ suite('Create command', () => {
     await assert.rejects(create(), /Enter a project directory/)
   })
 
+  test('creates without prompts using CLI settings and --no-git', async () => {
+    inquirer.prompt = async () => { throw new Error('Must not prompt with --yes') }
+    const app = path.join(directory, 'automated')
+    await cli(() => {}).parseAsync([
+      'create', app, '--yes', '--no-git', '--orgs', 'pkgjs,nodejs',
+      '--repositories', 'expressjs/express, pkgjs/statusboard',
+      '--labels', 'bug, help wanted', '--github-actions'
+    ])
+    const config = require(path.join(app, 'config.js'))
+    assert.deepEqual(config.orgs, ['pkgjs', 'nodejs'])
+    assert.deepEqual(config.projects, ['expressjs/express', 'pkgjs/statusboard'])
+    assert.deepEqual(config.issueLabels, ['bug', 'help wanted'])
+    assert.ok((await fs.stat(path.join(app, '.github', 'workflows', 'build.yml'))).isFile())
+    await assert.rejects(fs.stat(path.join(app, '.git')), { code: 'ENOENT' })
+  })
+
+  test('uses default values without a terminal or directory argument', async () => {
+    execFileSync(process.execPath, [require.resolve('../bin/statusboard'), 'create', '-y', '--no-git'], {
+      cwd: directory,
+      stdio: ['ignore', 'pipe', 'pipe'],
+      timeout: 10000
+    })
+    const app = path.join(directory, 'statusboard')
+    const config = require(path.join(app, 'config.js'))
+    assert.deepEqual(config.orgs, [])
+    assert.deepEqual(config.projects, [])
+    assert.equal(Object.hasOwn(config, 'issueLabels'), false)
+    await assert.rejects(fs.stat(path.join(app, '.github')), { code: 'ENOENT' })
+    await assert.rejects(fs.stat(path.join(app, '.git')), { code: 'ENOENT' })
+  })
+
+  test('prompts only for missing interactive settings and preserves explicit empty labels', async () => {
+    inquirer.prompt = async questions => {
+      const asked = questions.filter(question => !question.when || question.when({})).map(question => question.name)
+      assert.deepEqual(asked, ['repositories'])
+      return { repositories: 'pkgjs/statusboard' }
+    }
+    const app = path.join(directory, 'interactive')
+    await cli(() => {}).parseAsync(['create', app, '--no-git', '--orgs', 'pkgjs', '--labels', '', '--no-github-actions'])
+    const config = require(path.join(app, 'config.js'))
+    assert.deepEqual(config.issueLabels, [])
+    assert.deepEqual(config.projects, ['pkgjs/statusboard'])
+    await assert.rejects(fs.stat(path.join(app, '.github')), { code: 'ENOENT' })
+  })
+
+  test('rejects invalid repository options before prompting or creating files', async () => {
+    inquirer.prompt = async () => { throw new Error('Must validate supplied options first') }
+    const app = path.join(directory, 'invalid')
+    await assert.rejects(create({ directory: app, repositories: 'missing-owner' }), /Use owner\/repo/)
+    await assert.rejects(fs.stat(app), { code: 'ENOENT' })
+  })
+
   test('keeps generated files and the repository if the initial commit fails', async () => {
     process.env.GIT_AUTHOR_NAME = ''
     const app = path.join(directory, 'no-identity')