@form8ion/project 21.1.1 → 22.0.0-beta.10

package/src/dependency-updater/scaffolder.test.js

@@ -1,32 +1,28 @@
-import {afterEach, describe, expect, it, vi} from 'vitest';
+import {describe, expect, it, vi} from 'vitest';
 import any from '@travi/any';
 import {when} from 'vitest-when';
 
-import * as prompt from './prompt.js';
+import {promptForDependencyUpdaterChoice} from './prompt.js';
 import scaffoldUpdater from './scaffolder.js';
 import {questionNames} from '../index.js';
-import {promptForDependencyUpdaterChoice} from './prompt.js';
 
-vi.mock('./prompt');
+vi.mock('./prompt.js');
 
 describe('dependency-updater scaffolder', () => {
-  afterEach(() => {
-    vi.clearAllMocks();
-  });
+  const prompt = () => undefined;
 
   it('should execute the chosen scaffolder with the appropriate options', async () => {
-    const decisions = any.simpleObject();
     const options = any.simpleObject();
     const chosenUpdater = any.word();
     const chosenUpdaterScaffolder = vi.fn();
     const plugins = {...any.simpleObject(), [chosenUpdater]: {scaffold: chosenUpdaterScaffolder}};
     const scaffolderResult = any.simpleObject();
-    when(prompt.promptForDependencyUpdaterChoice)
-      .calledWith(plugins, decisions)
+    when(promptForDependencyUpdaterChoice)
+      .calledWith(plugins, {prompt})
       .thenResolve({[questionNames.DEPENDENCY_UPDATER]: chosenUpdater});
     when(chosenUpdaterScaffolder).calledWith(options).thenResolve(scaffolderResult);
 
-    expect(await scaffoldUpdater(plugins, decisions, options)).toEqual(scaffolderResult);
+    expect(await scaffoldUpdater(plugins, options, {prompt})).toEqual(scaffolderResult);
   });
 
   it('should not present a prompt if no updaters are registered', async () => {

package/src/index.js

@@ -1,9 +1,7 @@
-import {questionNames as coreQuestionNames} from '@form8ion/core';
-import {questionNames as projectScaffolderQuestionNames} from './prompts/question-names.js';
+import {ids} from './prompts/index.js';
 
 export * from './scaffolder.js';
 export {default as lift} from './lift.js';
-export const questionNames = {
-  ...coreQuestionNames,
-  ...projectScaffolderQuestionNames
-};
+export const promptConstants = {ids};
+
+export {questionNames} from './prompts/index.js';

package/src/language/prompt.js

@@ -1,12 +1,15 @@
-import {prompt} from '@form8ion/overridable-prompts';
-
 import {questionNames} from '../prompts/question-names.js';
 
-export default function (languages, decisions) {
-  return prompt([{
-    name: questionNames.PROJECT_LANGUAGE,
-    type: 'list',
-    message: 'What type of project is this?',
-    choices: [...Object.keys(languages), 'Other']
-  }], decisions);
+export const PROJECT_LANGUAGE_PROMPT_ID = 'PROJECT_LANGUAGE';
+
+export default function promptForProjectLanguage(languages, {prompt}) {
+  return prompt({
+    id: PROJECT_LANGUAGE_PROMPT_ID,
+    questions: [{
+      name: questionNames.PROJECT_LANGUAGE,
+      type: 'list',
+      message: 'What type of project is this?',
+      choices: [...Object.keys(languages), 'Other']
+    }]
+  });
 }

package/src/language/prompt.test.js

@@ -1,30 +1,27 @@
-import {prompt} from '@form8ion/overridable-prompts';
-
-import {afterEach, describe, expect, it, vi} from 'vitest';
+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 promptForLanguageDetails from './prompt.js';
+import promptForLanguageDetails, {PROJECT_LANGUAGE_PROMPT_ID} from './prompt.js';
 
 vi.mock('@form8ion/overridable-prompts');
 
 describe('language prompt', () => {
-  afterEach(() => {
-    vi.clearAllMocks();
-  });
-
   it('should prompt for the language details', async () => {
+    const prompt = vi.fn();
     const answers = any.simpleObject();
-    const decisions = any.simpleObject();
     const languages = any.simpleObject();
-    when(prompt).calledWith([{
-      name: questionNames.PROJECT_LANGUAGE,
-      type: 'list',
-      message: 'What type of project is this?',
-      choices: [...Object.keys(languages), 'Other']
-    }], decisions).thenResolve(answers);
+    when(prompt).calledWith({
+      id: PROJECT_LANGUAGE_PROMPT_ID,
+      questions: [{
+        name: questionNames.PROJECT_LANGUAGE,
+        type: 'list',
+        message: 'What type of project is this?',
+        choices: [...Object.keys(languages), 'Other']
+      }]
+    }).thenResolve(answers);
 
-    expect(await promptForLanguageDetails(languages, decisions)).toEqual(answers);
+    expect(await promptForLanguageDetails(languages, {prompt})).toEqual(answers);
   });
 });

package/src/language/scaffolder.js

@@ -1,8 +1,8 @@
 import {questionNames} from '../prompts/question-names.js';
 import promptForLanguageDetails from './prompt.js';
 
-export default async function (languagePlugins, decisions, options) {
-  const {[questionNames.PROJECT_LANGUAGE]: chosenLanguage} = await promptForLanguageDetails(languagePlugins, decisions);
+export default async function (languagePlugins, options, {prompt}) {
+  const {[questionNames.PROJECT_LANGUAGE]: chosenLanguage} = await promptForLanguageDetails(languagePlugins, {prompt});
 
   const plugin = languagePlugins[chosenLanguage];
 

package/src/language/scaffolder.test.js

@@ -13,15 +13,15 @@ describe('language scaffolder', () => {
     const options = any.simpleObject();
     const chosenLanguage = any.word();
     const scaffolderResult = any.simpleObject();
-    const decisions = any.simpleObject();
+    const prompt = () => undefined;
     const chosenLanguageScaffolder = vi.fn();
     const plugins = {...any.simpleObject(), [chosenLanguage]: {scaffold: chosenLanguageScaffolder}};
     when(languagePrompt.default)
-      .calledWith(plugins, decisions)
+      .calledWith(plugins, {prompt})
       .thenResolve({[questionNames.PROJECT_LANGUAGE]: chosenLanguage});
     when(chosenLanguageScaffolder).calledWith(options).thenResolve(scaffolderResult);
 
-    expect(await scaffold(plugins, decisions, options)).toEqual(scaffolderResult);
+    expect(await scaffold(plugins, options, {prompt})).toEqual(scaffolderResult);
   });
 
   it('should not result in an error when choosing a language without a defined scaffolder', async () => {

package/src/options-validator.js

@@ -4,11 +4,9 @@ import joi from 'joi';
 import languagePluginsSchema from './language/schema.js';
 import vcsHostPluginsSchema from './vcs/host/schema.js';
 import dependencyUpdaterPluginsSchema from './dependency-updater/schema.js';
-import {decisionsSchema} from './options-schemas.js';
 
 export function validate(options) {
   return validateOptions(joi.object({
-    decisions: decisionsSchema,
     plugins: joi.object({
       dependencyUpdaters: dependencyUpdaterPluginsSchema,
       languages: languagePluginsSchema,

package/src/options-validator.test.js

@@ -6,7 +6,6 @@ import any from '@travi/any';
 import {when} from 'vitest-when';
 
 import languagePluginsSchema from './language/schema.js';
-import {decisionsSchema} from './options-schemas.js';
 import vcsHostPluginsSchema from './vcs/host/schema.js';
 import dependencyUpdaterPluginsSchema from './dependency-updater/schema.js';
 import {validate} from './options-validator.js';
@@ -39,10 +38,7 @@ describe('options validator', () => {
         vcsHosts: vcsHostPluginsSchema
       })
       .thenReturn(pluginsSchema);
-    when(joi.object).calledWith({
-      decisions: decisionsSchema,
-      plugins: pluginsSchema
-    }).thenReturn(fullSchema);
+    when(joi.object).calledWith({plugins: pluginsSchema}).thenReturn(fullSchema);
     when(core.validateOptions).calledWith(fullSchema, options).thenReturn(validatedOptions);
 
     expect(validate(options)).toEqual(validatedOptions);

package/src/prompts/index.js

@@ -0,0 +1,21 @@
+import {questionNames as coreQuestionNames} from '@form8ion/core';
+
+import {BASE_DETAILS_PROMPT_ID} from './questions.js';
+import {GIT_REPOSITORY_PROMPT_ID} from '../vcs/prompt.js';
+import {PROJECT_LANGUAGE_PROMPT_ID} from '../language/prompt.js';
+import {REPOSITORY_HOST_PROMPT_ID} from '../vcs/host/prompt.js';
+import {DEPENDENCY_UPDATER_PROMPT_ID} from '../dependency-updater/prompt.js';
+import {questionNames as projectScaffolderQuestionNames} from './question-names.js';
+
+export const ids = {
+  BASE_DETAILS: BASE_DETAILS_PROMPT_ID,
+  GIT_REPOSITORY: GIT_REPOSITORY_PROMPT_ID,
+  REPOSITORY_HOST: REPOSITORY_HOST_PROMPT_ID,
+  PROJECT_LANGUAGE: PROJECT_LANGUAGE_PROMPT_ID,
+  DEPENDENCY_UPDATER: DEPENDENCY_UPDATER_PROMPT_ID
+};
+
+export const questionNames = {
+  ...coreQuestionNames,
+  ...projectScaffolderQuestionNames
+};

package/src/prompts/questions.js

@@ -1,6 +1,10 @@
 import {questionsForBaseDetails} from '@form8ion/core';
-import {prompt} from '@form8ion/overridable-prompts';
 
-export function promptForBaseDetails(projectRoot, decisions) {
-  return prompt(questionsForBaseDetails(decisions, projectRoot), decisions);
+export const BASE_DETAILS_PROMPT_ID = 'BASE_DETAILS';
+
+export function promptForBaseDetails(projectRoot, {prompt}) {
+  return prompt({
+    id: BASE_DETAILS_PROMPT_ID,
+    questions: questionsForBaseDetails(projectRoot)
+  });
 }

package/src/prompts/questions.test.js

@@ -1,11 +1,10 @@
 import * as core from '@form8ion/core';
-import * as prompts from '@form8ion/overridable-prompts';
 
 import {describe, expect, it, vi} from 'vitest';
 import any from '@travi/any';
 import {when} from 'vitest-when';
 
-import {promptForBaseDetails} from './questions.js';
+import {promptForBaseDetails, BASE_DETAILS_PROMPT_ID} from './questions.js';
 
 vi.mock('@form8ion/core');
 vi.mock('@form8ion/overridable-prompts');
@@ -13,13 +12,13 @@ vi.mock('@form8ion/overridable-prompts');
 describe('base details prompt', () => {
   const projectPath = any.string();
   const answers = any.simpleObject();
-  const decisions = any.simpleObject();
   const questions = any.listOf(any.simpleObject);
+  const prompt = vi.fn();
 
   it('should prompt for the necessary details', async () => {
-    when(core.questionsForBaseDetails).calledWith(decisions, projectPath).thenReturn(questions);
-    when(prompts.prompt).calledWith(questions, decisions).thenResolve(answers);
+    when(core.questionsForBaseDetails).calledWith(projectPath).thenReturn(questions);
+    when(prompt).calledWith({id: BASE_DETAILS_PROMPT_ID, questions}).thenResolve(answers);
 
-    expect(await promptForBaseDetails(projectPath, decisions)).toEqual(answers);
+    expect(await promptForBaseDetails(projectPath, {prompt})).toEqual(answers);
   });
 });

package/src/scaffolder.js

@@ -1,7 +1,6 @@
 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';
 
@@ -15,9 +14,9 @@ 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) {
+export async function scaffold(options, {prompt}) {
   const projectRoot = process.cwd();
-  const {decisions, plugins: {dependencyUpdaters, languages, vcsHosts = {}}} = validate(options);
+  const {plugins: {dependencyUpdaters, languages, vcsHosts = {}}} = validate(options);
 
   const {
     [coreQuestionNames.PROJECT_NAME]: projectName,
@@ -26,11 +25,11 @@ export async function scaffold(options) {
     [coreQuestionNames.DESCRIPTION]: description,
     [coreQuestionNames.COPYRIGHT_YEAR]: copyrightYear,
     [coreQuestionNames.COPYRIGHT_HOLDER]: copyHolder
-  } = await promptForBaseDetails(projectRoot, decisions);
+  } = await promptForBaseDetails(projectRoot, {prompt});
   const copyright = {year: copyrightYear, holder: copyHolder};
 
   const [vcsResults, contributing, license] = await Promise.all([
-    scaffoldVcs({projectRoot, projectName, decisions, vcsHosts, visibility, description}),
+    scaffoldVcs({projectRoot, projectName, vcsHosts, visibility, description}, {prompt}),
     scaffoldContributing({visibility}),
     scaffoldLicense({projectRoot, license: chosenLicense, copyright}),
     scaffoldReadme({projectName, projectRoot, description}),
@@ -39,14 +38,14 @@ export async function scaffold(options) {
 
   const dependencyUpdaterResults = vcsResults.vcs && await scaffoldDependencyUpdater(
     dependencyUpdaters,
-    decisions,
-    {projectRoot, vcs: vcsResults.vcs}
+    {projectRoot},
+    {prompt}
   );
 
   const language = await scaffoldLanguage(
     languages,
-    decisions,
-    {projectRoot, projectName, vcs: vcsResults.vcs, visibility, license: chosenLicense || 'UNLICENSED', description}
+    {projectRoot, projectName, vcs: vcsResults.vcs, visibility, license: chosenLicense || 'UNLICENSED', description},
+    {prompt}
   );
 
   const mergedResults = deepmerge.all([
@@ -72,5 +71,5 @@ export async function scaffold(options) {
     await subprocess;
   }
 
-  reportResults(mergedResults);
+  return mergedResults;
 }

package/src/scaffolder.test.js

@@ -2,7 +2,6 @@ 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';
@@ -52,7 +51,7 @@ describe('project scaffolder', () => {
   const tags = any.listOf(any.word);
   const visibility = any.word();
   const vcsIgnore = any.simpleObject();
-  const decisions = any.simpleObject();
+  const prompt = () => undefined;
 
   beforeEach(() => {
     process.cwd = vi.fn();
@@ -95,9 +94,9 @@ describe('project scaffolder', () => {
     ]);
     when(optionsValidator.validate)
       .calledWith(options)
-      .thenReturn({decisions, plugins: {dependencyUpdaters, languages, vcsHosts}});
+      .thenReturn({plugins: {dependencyUpdaters, languages, vcsHosts}});
     when(prompts.promptForBaseDetails)
-      .calledWith(projectPath, decisions)
+      .calledWith(projectPath, {prompt})
       .thenResolve({
         [coreQuestionNames.PROJECT_NAME]: projectName,
         [coreQuestionNames.LICENSE]: license,
@@ -107,25 +106,20 @@ describe('project scaffolder', () => {
         [coreQuestionNames.VISIBILITY]: visibility
       });
     when(scaffoldVcs)
-      .calledWith({projectRoot: projectPath, projectName, decisions, vcsHosts, visibility, description})
+      .calledWith({projectRoot: projectPath, projectName, vcsHosts, visibility, description}, {prompt})
       .thenResolve(vcsResults);
     when(licenseScaffolder.default)
       .calledWith({projectRoot: projectPath, license, copyright})
       .thenResolve(licenseResults);
     scaffoldLanguage.mockResolvedValue(languageResults);
     when(dependencyUpdaterScaffolder.default)
-      .calledWith(dependencyUpdaters, decisions, {projectRoot: projectPath, vcs})
+      .calledWith(dependencyUpdaters, {projectRoot: projectPath}, {prompt})
       .thenResolve(dependencyUpdaterResults);
     when(scaffoldContributing).calledWith({visibility}).thenReturn(contributingResults);
 
-    await scaffold(options);
+    expect(await scaffold(options, {prompt})).toEqual(mergedResults);
 
     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,
@@ -133,7 +127,6 @@ describe('project scaffolder', () => {
       results: mergedResults,
       enhancers: {...dependencyUpdaters, ...vcsHosts, ...languages}
     });
-    expect(resultsReporter.reportResults).toHaveBeenCalledWith(mergedResults);
   });
 
   it('should pass the lists of badges from contributors to the readme', async () => {
@@ -160,7 +153,7 @@ describe('project scaffolder', () => {
     const languageResults = {badges: languageBadges, vcsIgnore, documentation};
     when(optionsValidator.validate).calledWith(options).thenReturn({plugins: {vcsHosts}});
     when(prompts.promptForBaseDetails)
-      .calledWith(projectPath, undefined)
+      .calledWith(projectPath, {prompt})
       .thenResolve({
         [coreQuestionNames.DESCRIPTION]: description,
         [questionNames.GIT_REPO]: true,
@@ -173,7 +166,7 @@ describe('project scaffolder', () => {
     licenseScaffolder.default.mockResolvedValue({badges: licenseBadges});
     scaffoldVcs.mockResolvedValue(vcsResults);
 
-    await scaffold(options);
+    await scaffold(options, {prompt});
 
     expect(scaffoldReadme).toHaveBeenCalledWith({projectName, projectRoot: projectPath, description});
   });
@@ -184,7 +177,7 @@ describe('project scaffolder', () => {
     scaffoldReadme.mockResolvedValue();
     scaffoldVcs.mockResolvedValue({});
 
-    await scaffold(options);
+    await scaffold(options, {prompt});
 
     expect(dependencyUpdaterScaffolder.default).not.toHaveBeenCalled();
   });
@@ -209,9 +202,7 @@ describe('project scaffolder', () => {
       nextSteps: languageNextSteps,
       tags
     };
-    when(optionsValidator.validate)
-      .calledWith(options)
-      .thenReturn({decisions, plugins: {languages, vcsHosts}});
+    when(optionsValidator.validate).calledWith(options).thenReturn({plugins: {languages, vcsHosts}});
     scaffoldVcs.mockResolvedValue(vcsResults);
     prompts.promptForBaseDetails.mockResolvedValue({
       [coreQuestionNames.PROJECT_NAME]: projectName,
@@ -220,30 +211,29 @@ describe('project scaffolder', () => {
       [coreQuestionNames.LICENSE]: license,
       [coreQuestionNames.DESCRIPTION]: description
     });
-    when(scaffoldLanguage).calledWith(languages, decisions, {
+    when(scaffoldLanguage).calledWith(languages, {
       projectName,
       projectRoot: projectPath,
       visibility,
       license,
       vcs,
       description
-    }).thenResolve(languageResults);
+    }, {prompt}).thenResolve(languageResults);
     when(execa).calledWith(verificationCommand, {shell: true}).thenReturn({stdout: {pipe: execaPipe}});
     dependencyUpdaterScaffolder.default.mockResolvedValue({});
     licenseScaffolder.default.mockResolvedValue({});
     scaffoldContributing.mockResolvedValue({});
 
-    await scaffold(options);
+    await scaffold(options, {prompt});
 
     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}});
+      .thenReturn({vcsHosts, plugins: {languages}});
     scaffoldVcs.mockResolvedValue(vcsResults);
     prompts.promptForBaseDetails.mockResolvedValue({
       [coreQuestionNames.PROJECT_NAME]: projectName,
@@ -257,22 +247,21 @@ describe('project scaffolder', () => {
     licenseScaffolder.default.mockResolvedValue({});
     scaffoldContributing.mockResolvedValue({});
 
-    await scaffold(options);
+    await scaffold(options, {prompt});
 
     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});
+    when(optionsValidator.validate).calledWith(options).thenReturn({plugins: {languages}});
     prompts.promptForBaseDetails.mockResolvedValue({});
     scaffoldVcs.mockResolvedValue(vcsResults);
 
-    await scaffold(options);
+    await scaffold(options, {prompt});
 
     expect(scaffoldLanguage).toHaveBeenCalledWith(
       languages,
-      decisions,
       {
         license: 'UNLICENSED',
         description: undefined,
@@ -280,7 +269,8 @@ describe('project scaffolder', () => {
         projectRoot: projectPath,
         vcs,
         visibility: undefined
-      }
+      },
+      {prompt}
     );
   });
 
@@ -290,7 +280,7 @@ describe('project scaffolder', () => {
     scaffoldVcs.mockResolvedValue({});
     scaffoldLanguage.mockResolvedValue({badges: {}, projectDetails: {}});
 
-    await scaffold(options);
+    await scaffold(options, {prompt});
 
     expect(execa).not.toHaveBeenCalled();
   });

package/src/vcs/host/prompt.js

@@ -1,14 +1,17 @@
-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);
+export const REPOSITORY_HOST_PROMPT_ID = 'REPOSITORY_HOST';
+
+export default async function promptForVcsHostChoice(hosts, {prompt}) {
+  const answers = await prompt({
+    id: REPOSITORY_HOST_PROMPT_ID,
+    questions: [{
+      name: questionNames.REPO_HOST,
+      type: 'list',
+      message: 'Where will the repository be hosted?',
+      choices: Object.keys(hosts)
+    }]
+  });
   const host = hosts[answers[questionNames.REPO_HOST]];
 
   return {...answers, ...host};

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

@@ -1,21 +1,19 @@
-import * as prompts from '@form8ion/overridable-prompts';
-
-import {afterEach, describe, expect, it, vi} from 'vitest';
+import {beforeEach, 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';
+import promptForVcsHostDetails, {REPOSITORY_HOST_PROMPT_ID} from './prompt.js';
 
 vi.mock('@form8ion/overridable-prompts');
 vi.mock('../../prompts/conditionals');
 
 describe('vcs host details prompt', () => {
+  let prompt;
   const answers = any.simpleObject();
-  const decisions = any.simpleObject();
 
-  afterEach(() => {
-    vi.clearAllMocks();
+  beforeEach(() => {
+    prompt = vi.fn();
   });
 
   it('should prompt for the vcs hosting details', async () => {
@@ -23,25 +21,31 @@ describe('vcs host details prompt', () => {
     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);
+    when(prompt).calledWith({
+      id: REPOSITORY_HOST_PROMPT_ID,
+      questions: [{
+        name: questionNames.REPO_HOST,
+        type: 'list',
+        message: 'Where will the repository be hosted?',
+        choices: hostNames
+      }]
+    }).thenResolve(answersWithHostChoice);
+
+    expect(await promptForVcsHostDetails(hosts, {prompt})).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);
+    when(prompt).calledWith({
+      id: REPOSITORY_HOST_PROMPT_ID,
+      questions: [{
+        name: questionNames.REPO_HOST,
+        type: 'list',
+        message: 'Where will the repository be hosted?',
+        choices: []
+      }]
+    }).thenResolve(answersWithHostChoice);
+
+    expect(await promptForVcsHostDetails({}, {prompt})).toEqual(answersWithHostChoice);
   });
 });

package/src/vcs/host/scaffolder.js

@@ -1,16 +1,15 @@
 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);
+export default async function scaffoldVcsHost(hosts, options, {prompt}) {
+  const {[questionNames.REPO_HOST]: chosenHost} = await promptForVcsHostDetails(hosts, {prompt});
 
   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)});
+  if (host) return host.scaffold(options);
 
   return {vcs: {}};
 }