@form8ion/project 22.0.0-beta.2 → 22.0.0-beta.20

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';
@@ -12,6 +11,7 @@ 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 {scaffold as scaffoldCiProvider} from './ci-provider/index.js';
 import * as optionsValidator from './options-validator.js';
 import * as prompts from './prompts/questions.js';
 import {questionNames} from './prompts/question-names.js';
@@ -28,12 +28,15 @@ vi.mock('./vcs/index.js');
 vi.mock('./license/scaffolder');
 vi.mock('./language/scaffolder');
 vi.mock('./dependency-updater/scaffolder');
+vi.mock('./ci-provider/index.js');
 vi.mock('./options-validator');
 vi.mock('./prompts/questions');
 vi.mock('./editorconfig');
 vi.mock('./contributing');
 vi.mock('./lift.js');
 
+const {GIT_REPO} = questionNames.GIT_REPOSITORY;
+
 describe('project scaffolder', () => {
   const originalProcessCwd = process.cwd;
   const options = any.simpleObject();
@@ -52,7 +55,9 @@ describe('project scaffolder', () => {
   const tags = any.listOf(any.word);
   const visibility = any.word();
   const vcsIgnore = any.simpleObject();
-  const decisions = any.simpleObject();
+  const prompt = () => undefined;
+  const logger = {info: () => {}};
+  const dependencies = {prompt, logger};
 
   beforeEach(() => {
     process.cwd = vi.fn();
@@ -71,6 +76,7 @@ describe('project scaffolder', () => {
     const holder = any.sentence();
     const copyright = {year, holder};
     const dependencyUpdaters = any.simpleObject();
+    const ciProviders = any.simpleObject();
     const dependencyUpdaterNextSteps = any.listOf(any.simpleObject);
     const dependencyUpdaterContributionBadges = any.simpleObject();
     const dependencyUpdaterResults = {
@@ -95,9 +101,9 @@ describe('project scaffolder', () => {
     ]);
     when(optionsValidator.validate)
       .calledWith(options)
-      .thenReturn({decisions, plugins: {dependencyUpdaters, languages, vcsHosts}});
+      .thenReturn({plugins: {dependencyUpdaters, ciProviders, languages, vcsHosts}});
     when(prompts.promptForBaseDetails)
-      .calledWith(projectPath, decisions)
+      .calledWith(projectPath, {prompt})
       .thenResolve({
         [coreQuestionNames.PROJECT_NAME]: projectName,
         [coreQuestionNames.LICENSE]: license,
@@ -107,28 +113,32 @@ describe('project scaffolder', () => {
         [coreQuestionNames.VISIBILITY]: visibility
       });
     when(scaffoldVcs)
-      .calledWith({projectRoot: projectPath, projectName, decisions, vcsHosts, visibility, description})
+      .calledWith({projectRoot: projectPath, projectName, vcsHosts, visibility, description}, {prompt, logger})
       .thenResolve(vcsResults);
     when(licenseScaffolder.default)
-      .calledWith({projectRoot: projectPath, license, copyright})
+      .calledWith({projectRoot: projectPath, license, copyright}, {logger})
       .thenResolve(licenseResults);
     scaffoldLanguage.mockResolvedValue(languageResults);
     when(dependencyUpdaterScaffolder.default)
-      .calledWith(dependencyUpdaters, decisions, {projectRoot: projectPath})
+      .calledWith(dependencyUpdaters, {projectRoot: projectPath}, {prompt})
       .thenResolve(dependencyUpdaterResults);
     when(scaffoldContributing).calledWith({visibility}).thenReturn(contributingResults);
 
-    await scaffold(options);
+    expect(await scaffold(options, dependencies)).toEqual(mergedResults);
 
     expect(scaffoldReadme).toHaveBeenCalledWith({projectName, projectRoot: projectPath, description});
     expect(scaffoldEditorconfig).toHaveBeenCalledWith({projectRoot: projectPath});
+    expect(scaffoldCiProvider).toHaveBeenCalledWith(
+      ciProviders,
+      {projectRoot: projectPath},
+      {prompt}
+    );
     expect(lift).toHaveBeenCalledWith({
       projectRoot: projectPath,
       vcs,
       results: mergedResults,
       enhancers: {...dependencyUpdaters, ...vcsHosts, ...languages}
-    });
-    expect(resultsReporter.reportResults).toHaveBeenCalledWith(mergedResults);
+    }, dependencies);
   });
 
   it('should pass the lists of badges from contributors to the readme', async () => {
@@ -155,10 +165,10 @@ 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,
+        [GIT_REPO]: true,
         [coreQuestionNames.PROJECT_NAME]: projectName,
         [coreQuestionNames.VISIBILITY]: visibility
       });
@@ -168,20 +178,21 @@ 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});
   });
 
   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});
+    prompts.promptForBaseDetails.mockResolvedValue({[GIT_REPO]: false});
     scaffoldReadme.mockResolvedValue();
     scaffoldVcs.mockResolvedValue({});
 
-    await scaffold(options);
+    await scaffold(options, {prompt});
 
     expect(dependencyUpdaterScaffolder.default).not.toHaveBeenCalled();
+    expect(scaffoldCiProvider).not.toHaveBeenCalled();
   });
 
   it('should scaffold the details of the chosen language plugin', async () => {
@@ -204,46 +215,43 @@ 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,
       [coreQuestionNames.VISIBILITY]: visibility,
-      [questionNames.GIT_REPO]: true,
+      [GIT_REPO]: true,
       [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, dependencies);
 
     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,
       [coreQuestionNames.VISIBILITY]: visibility,
-      [questionNames.GIT_REPO]: true,
+      [GIT_REPO]: true,
       [coreQuestionNames.LICENSE]: license,
       [coreQuestionNames.DESCRIPTION]: description
     });
@@ -252,22 +260,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,
@@ -275,7 +282,8 @@ describe('project scaffolder', () => {
         projectRoot: projectPath,
         vcs,
         visibility: undefined
-      }
+      },
+      {prompt}
     );
   });
 
@@ -285,7 +293,7 @@ describe('project scaffolder', () => {
     scaffoldVcs.mockResolvedValue({});
     scaffoldLanguage.mockResolvedValue({badges: {}, projectDetails: {}});
 
-    await scaffold(options);
+    await scaffold(options, {prompt});
 
     expect(execa).not.toHaveBeenCalled();
   });

package/src/template-path.js

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

package/src/vcs/git/remotes.js

@@ -1,6 +1,5 @@
 import {simpleGit} from 'simple-git';
-import hostedGitInfo from 'hosted-git-info';
-import {warn} from '@travi/cli-messages';
+import parseGitUrl from 'git-url-parse';
 
 async function getExistingRemotes(git) {
   try {
@@ -17,14 +16,14 @@ async function getExistingRemotes(git) {
 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);
+  const {owner, name, host} = parseGitUrl(remoteOrigin.trimEnd());
 
-  return {vcs: {owner: user, name: project, host: type}};
+  return {vcs: {owner, name, host}};
 }
 
-export async function defineRemoteOrigin(projectRoot, sshUrl) {
+export async function defineRemoteOrigin(projectRoot, sshUrl, {logger}) {
   if (!sshUrl) {
-    warn('URL not available to configure remote `origin`');
+    logger.warn('URL not available to configure remote `origin`');
 
     return {nextSteps: []};
   }
@@ -33,7 +32,7 @@ export async function defineRemoteOrigin(projectRoot, sshUrl) {
   const existingRemotes = await getExistingRemotes(git);
 
   if (existingRemotes.includes('origin')) {
-    warn('The `origin` remote is already defined for this repository');
+    logger.warn('The `origin` remote is already defined for this repository');
 
     return {nextSteps: []};
   }

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

@@ -1,30 +1,34 @@
 import {simpleGit} from 'simple-git';
-import hostedGitInfo from 'hosted-git-info';
+import parseGitUrl from 'git-url-parse';
 
-import {describe, vi, it, expect} from 'vitest';
+import {describe, vi, it, expect, beforeEach} 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');
+vi.mock('git-url-parse');
 
 describe('Git remote', () => {
   const projectRoot = any.string();
 
   describe('determine', () => {
+    const remote = vi.fn();
+    const remoteOrigin = any.url();
+    const repoName = any.word();
+    const vcsHostAccount = any.word();
+
+    beforeEach(() => {
+      when(simpleGit).calledWith({baseDir: projectRoot}).thenReturn({remote});
+    });
+
     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)
+      when(remote).calledWith(['get-url', 'origin']).thenResolve(`${remoteOrigin}\n`);
+      when(parseGitUrl)
         .calledWith(remoteOrigin)
-        .thenReturn({user: vcsHostAccount, project: repoName, type: vcsHost.toLowerCase()});
+        .thenReturn({owner: vcsHostAccount, name: repoName, host: vcsHost.toLowerCase()});
 
       const {vcs: hostDetails} = await determineExistingVcsDetails({projectRoot});
 
@@ -34,6 +38,7 @@ describe('Git remote', () => {
 
   describe('define', () => {
     const sshUrl = any.url();
+    const logger = {warn: () => {}};
 
     it('should define the remote origin', async () => {
       const listRemote = vi.fn();
@@ -41,7 +46,7 @@ describe('Git remote', () => {
       when(simpleGit).calledWith({baseDir: projectRoot}).thenReturn({listRemote, addRemote});
       when(listRemote).calledWith().thenResolve(any.listOf(any.word));
 
-      const {nextSteps} = await defineRemoteOrigin(projectRoot, sshUrl);
+      const {nextSteps} = await defineRemoteOrigin(projectRoot, sshUrl, {logger});
 
       expect(addRemote).toHaveBeenCalledWith('origin', sshUrl);
       expect(nextSteps).toEqual([{summary: 'Set local `master` branch to track upstream `origin/master`'}]);
@@ -53,7 +58,7 @@ describe('Git remote', () => {
       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);
+      const {nextSteps} = await defineRemoteOrigin(projectRoot, sshUrl, {logger});
 
       expect(nextSteps).toEqual([{summary: 'Set local `master` branch to track upstream `origin/master`'}]);
     });
@@ -64,7 +69,7 @@ describe('Git remote', () => {
       when(simpleGit).calledWith({baseDir: projectRoot}).thenReturn({listRemote});
       when(listRemote).calledWith().thenThrow(error);
 
-      await expect(defineRemoteOrigin(projectRoot, sshUrl)).rejects.toThrow(error);
+      await expect(defineRemoteOrigin(projectRoot, sshUrl, {logger})).rejects.toThrow(error);
     });
 
     it('should return no next-steps when the remote origin is already defined', async () => {
@@ -72,13 +77,13 @@ describe('Git remote', () => {
       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);
+      const {nextSteps} = await defineRemoteOrigin(projectRoot, sshUrl, {logger});
 
       expect(nextSteps).toEqual([]);
     });
 
     it('should return no next-steps when no `sshUrl` is provided', async () => {
-      const {nextSteps} = await defineRemoteOrigin(projectRoot);
+      const {nextSteps} = await defineRemoteOrigin(projectRoot, undefined, {logger});
 
       expect(nextSteps).toEqual([]);
     });

package/src/vcs/host/prompt.js

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

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

@@ -1,47 +1,53 @@
-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');
 
+const {REPO_HOST} = questionNames.REPOSITORY_HOST;
+
 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 () => {
     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);
+    const answersWithHostChoice = {...answers, [REPO_HOST]: host};
+    when(prompt).calledWith({
+      id: REPOSITORY_HOST_PROMPT_ID,
+      questions: [{
+        name: 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);
+    const answersWithHostChoice = {...answers, [REPO_HOST]: 'Other'};
+    when(prompt).calledWith({
+      id: REPOSITORY_HOST_PROMPT_ID,
+      questions: [{
+        name: 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,8 +1,10 @@
 import {questionNames} from '../../prompts/question-names.js';
 import promptForVcsHostDetails from './prompt.js';
 
-export default async function scaffoldVcsHost(hosts, decisions, options) {
-  const {[questionNames.REPO_HOST]: chosenHost} = await promptForVcsHostDetails(hosts, decisions);
+const {REPO_HOST} = questionNames.REPOSITORY_HOST;
+
+export default async function scaffoldVcsHost(hosts, options, {prompt}) {
+  const {[REPO_HOST]: chosenHost} = await promptForVcsHostDetails(hosts, {prompt});
 
   const lowercasedHosts = Object.fromEntries(
     Object.entries(hosts).map(([name, details]) => [name.toLowerCase(), details])

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

@@ -8,9 +8,11 @@ import scaffoldVcsHost from './scaffolder.js';
 
 vi.mock('./prompt');
 
+const {REPO_HOST, REPO_OWNER} = questionNames.REPOSITORY_HOST;
+
 describe('vcs host scaffolder', () => {
   const options = any.simpleObject();
-  const decisions = any.simpleObject();
+  const prompt = () => undefined;
 
   it('should scaffold the chosen vcs host', async () => {
     const chosenHost = `${any.word()}CAPITAL${any.word()}`;
@@ -19,19 +21,19 @@ describe('vcs host scaffolder', () => {
     const hostPlugins = {...any.simpleObject(), [chosenHost.toLowerCase()]: {scaffold: chosenHostScaffolder}};
     const owner = any.word;
     when(promptForVcsHostDetails)
-      .calledWith(hostPlugins, decisions)
-      .thenResolve({[questionNames.REPO_HOST]: chosenHost, [questionNames.REPO_OWNER]: owner});
+      .calledWith(hostPlugins, {prompt})
+      .thenResolve({[REPO_HOST]: chosenHost, [REPO_OWNER]: owner});
     when(chosenHostScaffolder).calledWith(options).thenResolve(results);
 
-    expect(await scaffoldVcsHost(hostPlugins, decisions, options)).toEqual(results);
+    expect(await scaffoldVcsHost(hostPlugins, options, {prompt})).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()});
+      .calledWith(hostPlugins, {prompt})
+      .thenResolve({[REPO_HOST]: any.word()});
 
-    expect(await scaffoldVcsHost(hostPlugins, decisions, options)).toEqual({vcs: {}});
+    expect(await scaffoldVcsHost(hostPlugins, options, {prompt})).toEqual({vcs: {}});
   });
 });

package/src/vcs/prompt.js

@@ -1,17 +1,19 @@
-import {prompt} from '@form8ion/overridable-prompts';
-
 import {questionNames} from '../prompts/question-names.js';
 
-export default async function promptForRepoCreation(decisions) {
-  const {[questionNames.GIT_REPO]: gitRepoShouldBeCreated} = await prompt(
-    [{
-      name: questionNames.GIT_REPO,
+export const GIT_REPOSITORY_PROMPT_ID = 'GIT_REPOSITORY';
+
+const {GIT_REPO} = questionNames.GIT_REPOSITORY;
+
+export default async function promptForRepoCreation({prompt}) {
+  const {[GIT_REPO]: gitRepoShouldBeCreated} = await prompt({
+    id: GIT_REPOSITORY_PROMPT_ID,
+    questions: [{
+      name: GIT_REPO,
       type: 'confirm',
       default: true,
       message: 'Should a git repository be initialized?'
-    }],
-    decisions
-  );
+    }]
+  });
 
   return gitRepoShouldBeCreated;
 }

package/src/vcs/prompt.test.js

@@ -1,27 +1,30 @@
-import {prompt} from '@form8ion/overridable-prompts';
-
 import {describe, vi, it, expect} from 'vitest';
 import {when} from 'vitest-when';
 import any from '@travi/any';
 
 import {questionNames} from '../prompts/question-names.js';
-import promptForRepoCreation from './prompt.js';
+import promptForRepoCreation, {GIT_REPOSITORY_PROMPT_ID} from './prompt.js';
 
 vi.mock('@form8ion/overridable-prompts');
 
+const {GIT_REPO} = questionNames.GIT_REPOSITORY;
+
 describe('git prompt', () => {
   it('should ask whether a repository should be created', async () => {
-    const decisions = any.simpleObject();
+    const prompt = vi.fn();
     const repoShouldBeCreated = any.boolean();
     when(prompt)
-      .calledWith([{
-        name: questionNames.GIT_REPO,
-        type: 'confirm',
-        default: true,
-        message: 'Should a git repository be initialized?'
-      }], decisions)
-      .thenResolve({[questionNames.GIT_REPO]: repoShouldBeCreated});
+      .calledWith({
+        id: GIT_REPOSITORY_PROMPT_ID,
+        questions: [{
+          name: GIT_REPO,
+          type: 'confirm',
+          default: true,
+          message: 'Should a git repository be initialized?'
+        }]
+      })
+      .thenResolve({[GIT_REPO]: repoShouldBeCreated});
 
-    expect(await promptForRepoCreation(decisions)).toBe(repoShouldBeCreated);
+    expect(await promptForRepoCreation({prompt})).toBe(repoShouldBeCreated);
   });
 });

package/src/vcs/scaffolder.js

@@ -1,28 +1,26 @@
-import {info} from '@travi/cli-messages';
 import {scaffold as scaffoldGit, test as alreadyVersionedByGit} from '@form8ion/git';
 
 import repositoryShouldBeCreated from './prompt.js';
 import {determineExistingVcsDetails, defineRemoteOrigin} from './git/index.js';
 import {scaffold as scaffoldVcsHost} from './host/index.js';
 
-export default async function scaffoldVcs({projectRoot, projectName, decisions, vcsHosts, visibility, description}) {
-  if (await repositoryShouldBeCreated(decisions)) {
+export default async function scaffoldVcs(
+  {projectRoot, projectName, vcsHosts, visibility, description},
+  {prompt, logger}
+) {
+  if (await repositoryShouldBeCreated({prompt})) {
     if (await alreadyVersionedByGit({projectRoot})) {
-      info('Git repository already exists');
+      logger.info('Git repository already exists');
 
-      return {vcs: await determineExistingVcsDetails({projectRoot})};
+      return determineExistingVcsDetails({projectRoot});
     }
 
     const [{vcs: {host, owner, name, sshUrl}}] = await Promise.all([
-      scaffoldVcsHost(
-        vcsHosts,
-        decisions,
-        {projectName, projectRoot, description, visibility}
-      ),
+      scaffoldVcsHost(vcsHosts, {projectName, projectRoot, description, visibility}, {prompt}),
       scaffoldGit({projectRoot})
     ]);
 
-    const remoteOriginResults = await defineRemoteOrigin(projectRoot, sshUrl);
+    const remoteOriginResults = await defineRemoteOrigin(projectRoot, sshUrl, {logger});
 
     return {
       vcs: {host, owner, name},