@form8ion/project 21.0.1 → 21.0.3

package/src/scaffolder.js

@@ -0,0 +1,76 @@
+import deepmerge from 'deepmerge';
+import {execa} from 'execa';
+import {questionNames as coreQuestionNames} from '@form8ion/core';
+import {reportResults} from '@form8ion/results-reporter';
+import {scaffold as scaffoldReadme} from '@form8ion/readme';
+import {info} from '@travi/cli-messages';
+
+import {scaffold as scaffoldLanguage} from './language/index.js';
+import {scaffold as scaffoldVcs} from './vcs/index.js';
+import {scaffold as scaffoldLicense} from './license/index.js';
+import scaffoldDependencyUpdater from './dependency-updater/scaffolder.js';
+import {promptForBaseDetails} from './prompts/questions.js';
+import {validate} from './options-validator.js';
+import {scaffold as scaffoldEditorConfig} from './editorconfig/index.js';
+import {scaffold as scaffoldContributing} from './contributing/index.js';
+import lift from './lift.js';
+
+export async function scaffold(options) {
+  const projectRoot = process.cwd();
+  const {decisions, plugins: {dependencyUpdaters, languages, vcsHosts = {}}} = validate(options);
+
+  const {
+    [coreQuestionNames.PROJECT_NAME]: projectName,
+    [coreQuestionNames.LICENSE]: chosenLicense,
+    [coreQuestionNames.VISIBILITY]: visibility,
+    [coreQuestionNames.DESCRIPTION]: description,
+    [coreQuestionNames.COPYRIGHT_YEAR]: copyrightYear,
+    [coreQuestionNames.COPYRIGHT_HOLDER]: copyHolder
+  } = await promptForBaseDetails(projectRoot, decisions);
+  const copyright = {year: copyrightYear, holder: copyHolder};
+
+  const [vcsResults, contributing, license] = await Promise.all([
+    scaffoldVcs({projectRoot, projectName, decisions, vcsHosts, visibility, description}),
+    scaffoldContributing({visibility}),
+    scaffoldLicense({projectRoot, license: chosenLicense, copyright}),
+    scaffoldReadme({projectName, projectRoot, description}),
+    scaffoldEditorConfig({projectRoot})
+  ]);
+
+  const dependencyUpdaterResults = vcsResults.vcs && await scaffoldDependencyUpdater(
+    dependencyUpdaters,
+    decisions,
+    {projectRoot, vcs: vcsResults.vcs}
+  );
+
+  const language = await scaffoldLanguage(
+    languages,
+    decisions,
+    {projectRoot, projectName, vcs: vcsResults.vcs, visibility, license: chosenLicense || 'UNLICENSED', description}
+  );
+
+  const mergedResults = deepmerge.all([
+    license,
+    language,
+    dependencyUpdaterResults,
+    contributing,
+    vcsResults
+  ].filter(Boolean));
+
+  await lift({
+    projectRoot,
+    vcs: vcsResults.vcs,
+    results: mergedResults,
+    enhancers: {...dependencyUpdaters, ...languages, ...vcsHosts}
+  });
+
+  if (language && language.verificationCommand) {
+    info('Verifying the generated project');
+
+    const subprocess = execa(language.verificationCommand, {shell: true});
+    subprocess.stdout.pipe(process.stdout);
+    await subprocess;
+  }
+
+  reportResults(mergedResults);
+}

package/src/scaffolder.test.js

@@ -0,0 +1,297 @@
+import deepmerge from 'deepmerge';
+import {execa} from 'execa';
+import {questionNames as coreQuestionNames} from '@form8ion/core';
+import {scaffold as scaffoldReadme} from '@form8ion/readme';
+import * as resultsReporter from '@form8ion/results-reporter';
+
+import {afterEach, beforeEach, describe, expect, it, vi} from 'vitest';
+import any from '@travi/any';
+import {when} from 'vitest-when';
+
+import {scaffold as scaffoldVcs} from './vcs/index.js';
+import * as licenseScaffolder from './license/scaffolder.js';
+import scaffoldLanguage from './language/scaffolder.js';
+import * as dependencyUpdaterScaffolder from './dependency-updater/scaffolder.js';
+import * as optionsValidator from './options-validator.js';
+import * as prompts from './prompts/questions.js';
+import {questionNames} from './prompts/question-names.js';
+import {scaffold as scaffoldEditorconfig} from './editorconfig/index.js';
+import {scaffold as scaffoldContributing} from './contributing/index.js';
+import lift from './lift.js';
+import {scaffold} from './scaffolder.js';
+
+vi.mock('execa');
+vi.mock('@form8ion/readme');
+vi.mock('@form8ion/results-reporter');
+vi.mock('./readme');
+vi.mock('./vcs/index.js');
+vi.mock('./license/scaffolder');
+vi.mock('./language/scaffolder');
+vi.mock('./dependency-updater/scaffolder');
+vi.mock('./options-validator');
+vi.mock('./prompts/questions');
+vi.mock('./editorconfig');
+vi.mock('./contributing');
+vi.mock('./lift.js');
+
+describe('project scaffolder', () => {
+  const originalProcessCwd = process.cwd;
+  const options = any.simpleObject();
+  const projectPath = any.string();
+  const projectName = any.string();
+  const description = any.string();
+  const homepage = any.url();
+  const license = any.string();
+  const licenseBadge = any.url();
+  const languages = any.simpleObject();
+  const vcsHosts = any.simpleObject();
+  const documentation = any.simpleObject();
+  const vcs = any.simpleObject();
+  const gitNextSteps = any.listOf(any.simpleObject);
+  const vcsResults = {...any.simpleObject(), vcs, nextSteps: gitNextSteps};
+  const tags = any.listOf(any.word);
+  const visibility = any.word();
+  const vcsIgnore = any.simpleObject();
+  const decisions = any.simpleObject();
+
+  beforeEach(() => {
+    process.cwd = vi.fn();
+    process.cwd.mockReturnValue(projectPath);
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+
+    process.cwd = originalProcessCwd;
+  });
+
+  it('should generate the project files', async () => {
+    const ciBadge = any.url();
+    const year = any.word();
+    const holder = any.sentence();
+    const copyright = {year, holder};
+    const dependencyUpdaters = any.simpleObject();
+    const dependencyUpdaterNextSteps = any.listOf(any.simpleObject);
+    const dependencyUpdaterContributionBadges = any.simpleObject();
+    const dependencyUpdaterResults = {
+      badges: {contribution: dependencyUpdaterContributionBadges},
+      nextSteps: dependencyUpdaterNextSteps
+    };
+    const languageResults = {
+      badges: {status: {ci: ciBadge}},
+      vcsIgnore,
+      projectDetails: {},
+      documentation,
+      tags
+    };
+    const licenseResults = {badges: {consumer: {license: licenseBadge}}};
+    const contributingResults = any.simpleObject();
+    const mergedResults = deepmerge.all([
+      licenseResults,
+      languageResults,
+      dependencyUpdaterResults,
+      contributingResults,
+      vcsResults
+    ]);
+    when(optionsValidator.validate)
+      .calledWith(options)
+      .thenReturn({decisions, plugins: {dependencyUpdaters, languages, vcsHosts}});
+    when(prompts.promptForBaseDetails)
+      .calledWith(projectPath, decisions)
+      .thenResolve({
+        [coreQuestionNames.PROJECT_NAME]: projectName,
+        [coreQuestionNames.LICENSE]: license,
+        [coreQuestionNames.DESCRIPTION]: description,
+        [coreQuestionNames.COPYRIGHT_HOLDER]: holder,
+        [coreQuestionNames.COPYRIGHT_YEAR]: year,
+        [coreQuestionNames.VISIBILITY]: visibility
+      });
+    when(scaffoldVcs)
+      .calledWith({projectRoot: projectPath, projectName, decisions, vcsHosts, visibility, description})
+      .thenResolve(vcsResults);
+    when(licenseScaffolder.default)
+      .calledWith({projectRoot: projectPath, license, copyright})
+      .thenResolve(licenseResults);
+    scaffoldLanguage.mockResolvedValue(languageResults);
+    when(dependencyUpdaterScaffolder.default)
+      .calledWith(dependencyUpdaters, decisions, {projectRoot: projectPath, vcs})
+      .thenResolve(dependencyUpdaterResults);
+    when(scaffoldContributing).calledWith({visibility}).thenReturn(contributingResults);
+
+    await scaffold(options);
+
+    expect(scaffoldReadme).toHaveBeenCalledWith({projectName, projectRoot: projectPath, description});
+    expect(dependencyUpdaterScaffolder.default).toHaveBeenCalledWith(
+      dependencyUpdaters,
+      decisions,
+      {projectRoot: projectPath, vcs}
+    );
+    expect(scaffoldEditorconfig).toHaveBeenCalledWith({projectRoot: projectPath});
+    expect(lift).toHaveBeenCalledWith({
+      projectRoot: projectPath,
+      vcs,
+      results: mergedResults,
+      enhancers: {...dependencyUpdaters, ...vcsHosts, ...languages}
+    });
+    expect(resultsReporter.reportResults).toHaveBeenCalledWith(mergedResults);
+  });
+
+  it('should pass the lists of badges from contributors to the readme', async () => {
+    const contributingBadges = {
+      consumer: any.simpleObject(),
+      status: any.simpleObject(),
+      contribution: any.simpleObject()
+    };
+    const languageBadges = {
+      consumer: any.simpleObject(),
+      status: any.simpleObject(),
+      contribution: any.simpleObject()
+    };
+    const dependencyUpdaterBadges = {
+      consumer: any.simpleObject(),
+      status: any.simpleObject(),
+      contribution: any.simpleObject()
+    };
+    const licenseBadges = {
+      consumer: any.simpleObject(),
+      status: any.simpleObject(),
+      contribution: any.simpleObject()
+    };
+    const languageResults = {badges: languageBadges, vcsIgnore, documentation};
+    when(optionsValidator.validate).calledWith(options).thenReturn({plugins: {vcsHosts}});
+    when(prompts.promptForBaseDetails)
+      .calledWith(projectPath, undefined)
+      .thenResolve({
+        [coreQuestionNames.DESCRIPTION]: description,
+        [questionNames.GIT_REPO]: true,
+        [coreQuestionNames.PROJECT_NAME]: projectName,
+        [coreQuestionNames.VISIBILITY]: visibility
+      });
+    when(scaffoldContributing).calledWith({visibility}).thenReturn({badges: contributingBadges});
+    scaffoldLanguage.mockResolvedValue(languageResults);
+    dependencyUpdaterScaffolder.default.mockResolvedValue({badges: dependencyUpdaterBadges});
+    licenseScaffolder.default.mockResolvedValue({badges: licenseBadges});
+    scaffoldVcs.mockResolvedValue(vcsResults);
+
+    await scaffold(options);
+
+    expect(scaffoldReadme).toHaveBeenCalledWith({projectName, projectRoot: projectPath, description});
+  });
+
+  it('should not scaffold the git repo if not requested', async () => {
+    when(optionsValidator.validate).calledWith(options).thenReturn({plugins: {}});
+    prompts.promptForBaseDetails.mockResolvedValue({[questionNames.GIT_REPO]: false});
+    scaffoldReadme.mockResolvedValue();
+    scaffoldVcs.mockResolvedValue({});
+
+    await scaffold(options);
+
+    expect(dependencyUpdaterScaffolder.default).not.toHaveBeenCalled();
+  });
+
+  it('should scaffold the details of the chosen language plugin', async () => {
+    const languageConsumerBadges = any.simpleObject();
+    const languageContributionBadges = any.simpleObject();
+    const languageStatusBadges = any.simpleObject();
+    const languageNextSteps = any.listOf(any.simpleObject);
+    const verificationCommand = any.string();
+    const execaPipe = vi.fn();
+    const languageResults = {
+      vcsIgnore,
+      badges: {
+        consumer: languageConsumerBadges,
+        contribution: languageContributionBadges,
+        status: languageStatusBadges
+      },
+      documentation,
+      verificationCommand,
+      projectDetails: {homepage},
+      nextSteps: languageNextSteps,
+      tags
+    };
+    when(optionsValidator.validate)
+      .calledWith(options)
+      .thenReturn({decisions, plugins: {languages, vcsHosts}});
+    scaffoldVcs.mockResolvedValue(vcsResults);
+    prompts.promptForBaseDetails.mockResolvedValue({
+      [coreQuestionNames.PROJECT_NAME]: projectName,
+      [coreQuestionNames.VISIBILITY]: visibility,
+      [questionNames.GIT_REPO]: true,
+      [coreQuestionNames.LICENSE]: license,
+      [coreQuestionNames.DESCRIPTION]: description
+    });
+    when(scaffoldLanguage).calledWith(languages, decisions, {
+      projectName,
+      projectRoot: projectPath,
+      visibility,
+      license,
+      vcs,
+      description
+    }).thenResolve(languageResults);
+    when(execa).calledWith(verificationCommand, {shell: true}).thenReturn({stdout: {pipe: execaPipe}});
+    dependencyUpdaterScaffolder.default.mockResolvedValue({});
+    licenseScaffolder.default.mockResolvedValue({});
+    scaffoldContributing.mockResolvedValue({});
+
+    await scaffold(options);
+
+    expect(scaffoldReadme).toHaveBeenCalledWith({projectName, projectRoot: projectPath, description});
+    expect(execaPipe).toHaveBeenCalledWith(process.stdout);
+    expect(resultsReporter.reportResults).toHaveBeenCalledWith(deepmerge.all([languageResults, vcsResults]));
+  });
+
+  it('should consider the language details to be optional', async () => {
+    when(optionsValidator.validate)
+      .calledWith(options)
+      .thenReturn({vcsHosts, decisions, plugins: {languages}});
+    scaffoldVcs.mockResolvedValue(vcsResults);
+    prompts.promptForBaseDetails.mockResolvedValue({
+      [coreQuestionNames.PROJECT_NAME]: projectName,
+      [coreQuestionNames.VISIBILITY]: visibility,
+      [questionNames.GIT_REPO]: true,
+      [coreQuestionNames.LICENSE]: license,
+      [coreQuestionNames.DESCRIPTION]: description
+    });
+    scaffoldLanguage.mockResolvedValue({});
+    dependencyUpdaterScaffolder.default.mockResolvedValue({});
+    licenseScaffolder.default.mockResolvedValue({});
+    scaffoldContributing.mockResolvedValue({});
+
+    await scaffold(options);
+
+    expect(scaffoldReadme).toHaveBeenCalledWith({projectName, projectRoot: projectPath, description});
+    expect(execa).not.toHaveBeenCalled();
+  });
+
+  it('should pass the license to the language scaffolder as `UNLICENSED` when no license was chosen', async () => {
+    when(optionsValidator.validate).calledWith(options).thenReturn({plugins: {languages}, decisions});
+    prompts.promptForBaseDetails.mockResolvedValue({});
+    scaffoldVcs.mockResolvedValue(vcsResults);
+
+    await scaffold(options);
+
+    expect(scaffoldLanguage).toHaveBeenCalledWith(
+      languages,
+      decisions,
+      {
+        license: 'UNLICENSED',
+        description: undefined,
+        projectName: undefined,
+        projectRoot: projectPath,
+        vcs,
+        visibility: undefined
+      }
+    );
+  });
+
+  it('should not run a verification command when one is not provided', async () => {
+    when(optionsValidator.validate).calledWith(options).thenReturn({plugins: {}});
+    prompts.promptForBaseDetails.mockResolvedValue({});
+    scaffoldVcs.mockResolvedValue({});
+    scaffoldLanguage.mockResolvedValue({badges: {}, projectDetails: {}});
+
+    await scaffold(options);
+
+    expect(execa).not.toHaveBeenCalled();
+  });
+});

package/src/template-path.js

@@ -0,0 +1,8 @@
+import {resolve} from 'path';
+import filedirname from 'filedirname';
+
+export default function (fileName) {
+  const [, __dirname] = filedirname();
+
+  return resolve(__dirname, '..', 'templates', fileName);
+}

package/src/template-path.test.js

@@ -0,0 +1,14 @@
+import {resolve} from 'node:path';
+
+import {describe, expect, it} from 'vitest';
+import any from '@travi/any';
+
+import determinePathToTemplateFile from './template-path.js';
+
+describe('path to templates', () => {
+  it('should provide the proper path to a template file', () => {
+    const fileName = any.string();
+
+    expect(determinePathToTemplateFile(fileName)).toEqual(resolve(__dirname, '..', 'templates', fileName));
+  });
+});

package/src/vcs/git/index.js

@@ -0,0 +1 @@
+export * from './remotes.js';

package/src/vcs/git/remotes.js

@@ -0,0 +1,51 @@
+import {simpleGit} from 'simple-git';
+import hostedGitInfo from 'hosted-git-info';
+import {warn} from '@travi/cli-messages';
+
+async function getExistingRemotes(git) {
+  try {
+    return await git.listRemote();
+  } catch (e) {
+    if ('fatal: No remote configured to list refs from.\n' === e.message) {
+      return [];
+    }
+
+    throw e;
+  }
+}
+
+export async function determineExistingVcsDetails({projectRoot}) {
+  const git = simpleGit({baseDir: projectRoot});
+  const remoteOrigin = await git.remote(['get-url', 'origin']);
+  const {user, project, type} = hostedGitInfo.fromUrl(remoteOrigin);
+
+  return {vcs: {owner: user, name: project, host: type}};
+}
+
+export async function defineRemoteOrigin(projectRoot, sshUrl) {
+  if (!sshUrl) {
+    warn('URL not available to configure remote `origin`');
+
+    return {nextSteps: []};
+  }
+
+  const git = simpleGit({baseDir: projectRoot});
+  const existingRemotes = await getExistingRemotes(git);
+
+  if (existingRemotes.includes('origin')) {
+    warn('The `origin` remote is already defined for this repository');
+
+    return {nextSteps: []};
+  }
+
+  // info('Setting the local `master` branch to track `origin/master`');
+  //
+  // await gitBranch.setUpstream(
+  //   await gitBranch.lookup(repository, 'master', gitBranch.BRANCH.LOCAL),
+  //   'origin/master'
+  // );
+
+  await git.addRemote('origin', sshUrl);
+
+  return {nextSteps: [{summary: 'Set local `master` branch to track upstream `origin/master`'}]};
+}

package/src/vcs/git/remotes.test.js

@@ -0,0 +1,86 @@
+import {simpleGit} from 'simple-git';
+import hostedGitInfo from 'hosted-git-info';
+
+import {describe, vi, it, expect} from 'vitest';
+import {when} from 'vitest-when';
+import any from '@travi/any';
+
+import {determineExistingVcsDetails, defineRemoteOrigin} from './remotes.js';
+
+vi.mock('simple-git');
+vi.mock('hosted-git-info');
+
+describe('Git remote', () => {
+  const projectRoot = any.string();
+
+  describe('determine', () => {
+    it('should determine existing vcs details from the remote origin definition of the local repository', async () => {
+      const remote = vi.fn();
+      const remoteOrigin = any.url();
+      const repoName = any.word();
+      const vcsHost = `F${any.word()})O${any.word()}O`;
+      const vcsHostAccount = any.word();
+      when(simpleGit).calledWith({baseDir: projectRoot}).thenReturn({remote});
+      when(remote).calledWith(['get-url', 'origin']).thenResolve(remoteOrigin);
+      when(hostedGitInfo.fromUrl)
+        .calledWith(remoteOrigin)
+        .thenReturn({user: vcsHostAccount, project: repoName, type: vcsHost.toLowerCase()});
+
+      const {vcs: hostDetails} = await determineExistingVcsDetails({projectRoot});
+
+      expect(hostDetails).toEqual({host: vcsHost.toLowerCase(), owner: vcsHostAccount, name: repoName});
+    });
+  });
+
+  describe('define', () => {
+    const sshUrl = any.url();
+
+    it('should define the remote origin', async () => {
+      const listRemote = vi.fn();
+      const addRemote = vi.fn();
+      when(simpleGit).calledWith({baseDir: projectRoot}).thenReturn({listRemote, addRemote});
+      when(listRemote).calledWith().thenResolve(any.listOf(any.word));
+
+      const {nextSteps} = await defineRemoteOrigin(projectRoot, sshUrl);
+
+      expect(addRemote).toHaveBeenCalledWith('origin', sshUrl);
+      expect(nextSteps).toEqual([{summary: 'Set local `master` branch to track upstream `origin/master`'}]);
+    });
+
+    it('should define the remote origin when no remotes are defined', async () => {
+      const listRemote = vi.fn();
+      const addRemote = vi.fn();
+      when(simpleGit).calledWith({baseDir: projectRoot}).thenReturn({listRemote, addRemote});
+      when(listRemote).calledWith().thenThrow(new Error('fatal: No remote configured to list refs from.\n'));
+
+      const {nextSteps} = await defineRemoteOrigin(projectRoot, sshUrl);
+
+      expect(nextSteps).toEqual([{summary: 'Set local `master` branch to track upstream `origin/master`'}]);
+    });
+
+    it('should throw git errors that are not a lack of defined remotes', async () => {
+      const error = new Error(any.sentence());
+      const listRemote = vi.fn();
+      when(simpleGit).calledWith({baseDir: projectRoot}).thenReturn({listRemote});
+      when(listRemote).calledWith().thenThrow(error);
+
+      await expect(defineRemoteOrigin(projectRoot, sshUrl)).rejects.toThrow(error);
+    });
+
+    it('should return no next-steps when the remote origin is already defined', async () => {
+      const listRemote = vi.fn();
+      when(simpleGit).calledWith({baseDir: projectRoot}).thenReturn({listRemote});
+      when(listRemote).calledWith().thenResolve([...any.listOf(any.word), 'origin', ...any.listOf(any.word)]);
+
+      const {nextSteps} = await defineRemoteOrigin(projectRoot, sshUrl);
+
+      expect(nextSteps).toEqual([]);
+    });
+
+    it('should return no next-steps when no `sshUrl` is provided', async () => {
+      const {nextSteps} = await defineRemoteOrigin(projectRoot);
+
+      expect(nextSteps).toEqual([]);
+    });
+  });
+});

package/src/vcs/host/index.js

@@ -0,0 +1 @@
+export {default as scaffold} from './scaffolder.js';

package/src/vcs/host/prompt.js

@@ -0,0 +1,15 @@
+import {prompt} from '@form8ion/overridable-prompts';
+
+import {questionNames} from '../../prompts/question-names.js';
+
+export default async function (hosts, decisions) {
+  const answers = await prompt([{
+    name: questionNames.REPO_HOST,
+    type: 'list',
+    message: 'Where will the repository be hosted?',
+    choices: Object.keys(hosts)
+  }], decisions);
+  const host = hosts[answers[questionNames.REPO_HOST]];
+
+  return {...answers, ...host};
+}

package/src/vcs/host/prompt.test.js

@@ -0,0 +1,47 @@
+import * as prompts from '@form8ion/overridable-prompts';
+
+import {afterEach, describe, expect, it, vi} from 'vitest';
+import any from '@travi/any';
+import {when} from 'vitest-when';
+
+import {questionNames} from '../../prompts/question-names.js';
+import promptForVcsHostDetails from './prompt.js';
+
+vi.mock('@form8ion/overridable-prompts');
+vi.mock('../../prompts/conditionals');
+
+describe('vcs host details prompt', () => {
+  const answers = any.simpleObject();
+  const decisions = any.simpleObject();
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('should prompt for the vcs hosting details', async () => {
+    const host = any.string();
+    const hostNames = [...any.listOf(any.string), host];
+    const hosts = any.objectWithKeys(hostNames, {factory: () => ({})});
+    const answersWithHostChoice = {...answers, [questionNames.REPO_HOST]: host};
+    when(prompts.prompt).calledWith([{
+      name: questionNames.REPO_HOST,
+      type: 'list',
+      message: 'Where will the repository be hosted?',
+      choices: hostNames
+    }], decisions).thenResolve(answersWithHostChoice);
+
+    expect(await promptForVcsHostDetails(hosts, decisions)).toEqual(answersWithHostChoice);
+  });
+
+  it('should not throw an error when `Other` is chosen as the host', async () => {
+    const answersWithHostChoice = {...answers, [questionNames.REPO_HOST]: 'Other'};
+    when(prompts.prompt).calledWith([{
+      name: questionNames.REPO_HOST,
+      type: 'list',
+      message: 'Where will the repository be hosted?',
+      choices: []
+    }], decisions).thenResolve(answersWithHostChoice);
+
+    expect(await promptForVcsHostDetails({}, decisions)).toEqual(answersWithHostChoice);
+  });
+});

package/src/vcs/host/scaffolder.js

@@ -0,0 +1,16 @@
+import {questionNames} from '../../prompts/question-names.js';
+import terminalPromptFactory from '../../prompts/terminal-prompt.js';
+import promptForVcsHostDetails from './prompt.js';
+
+export default async function scaffoldVcsHost(hosts, decisions, options) {
+  const {[questionNames.REPO_HOST]: chosenHost} = await promptForVcsHostDetails(hosts, decisions);
+
+  const lowercasedHosts = Object.fromEntries(
+    Object.entries(hosts).map(([name, details]) => [name.toLowerCase(), details])
+  );
+  const host = lowercasedHosts[chosenHost.toLowerCase()];
+
+  if (host) return host.scaffold(options, {prompt: terminalPromptFactory(decisions)});
+
+  return {vcs: {}};
+}

package/src/vcs/host/scaffolder.test.js

@@ -0,0 +1,41 @@
+import {describe, expect, it, vi} from 'vitest';
+import any from '@travi/any';
+import {when} from 'vitest-when';
+
+import {questionNames} from '../../prompts/question-names.js';
+import terminalPromptFactory from '../../prompts/terminal-prompt.js';
+import promptForVcsHostDetails from './prompt.js';
+import scaffoldVcsHost from './scaffolder.js';
+
+vi.mock('../../prompts/terminal-prompt.js');
+vi.mock('./prompt');
+
+describe('vcs host scaffolder', () => {
+  const options = any.simpleObject();
+  const decisions = any.simpleObject();
+
+  it('should scaffold the chosen vcs host', async () => {
+    const chosenHost = `${any.word()}CAPITAL${any.word()}`;
+    const results = any.simpleObject();
+    const chosenHostScaffolder = vi.fn();
+    const hostPlugins = {...any.simpleObject(), [chosenHost.toLowerCase()]: {scaffold: chosenHostScaffolder}};
+    const owner = any.word;
+    const terminalPrompt = () => undefined;
+    when(terminalPromptFactory).calledWith(decisions).thenReturn(terminalPrompt);
+    when(promptForVcsHostDetails)
+      .calledWith(hostPlugins, decisions)
+      .thenResolve({[questionNames.REPO_HOST]: chosenHost, [questionNames.REPO_OWNER]: owner});
+    when(chosenHostScaffolder).calledWith(options, {prompt: terminalPrompt}).thenResolve(results);
+
+    expect(await scaffoldVcsHost(hostPlugins, decisions, options)).toEqual(results);
+  });
+
+  it('should return empty `vcs` results when no matching host is available', async () => {
+    const hostPlugins = any.simpleObject();
+    when(promptForVcsHostDetails)
+      .calledWith(hostPlugins, decisions)
+      .thenResolve({[questionNames.REPO_HOST]: any.word()});
+
+    expect(await scaffoldVcsHost(hostPlugins, decisions, options)).toEqual({vcs: {}});
+  });
+});

package/src/vcs/host/schema.js

@@ -0,0 +1,4 @@
+import joi from 'joi';
+import {optionsSchemas} from '@form8ion/core';
+
+export default joi.object().pattern(/^/, optionsSchemas.form8ionPlugin);