@cbnventures/nova 0.17.0 → 0.18.0

package/build/src/cli/utility/initialize.js

@@ -3,15 +3,15 @@ import { join, relative, sep } from 'path';
 import chalk from 'chalk';
 import prompts from 'prompts';
 import { libItemAllowedPoliciesByRole, libItemAllowedRecipes, libItemSyncRoles, libItemValidEntityRoles, } from '../../lib/item.js';
-import { LibNovaConfig } from '../../lib/nova-config.js';
+import { Runner as LibNovaConfig } from '../../lib/nova-config.js';
 import { LIB_REGEX_PATTERN_EMAIL_SIMPLE, LIB_REGEX_PATTERN_SLUG_SCOPED, LIB_REGEX_PATTERN_SLUG_SIMPLE, LIB_REGEX_PATTERN_YML_EXTENSION, } from '../../lib/regex.js';
 import { discoverPathsWithFile, pathExists, resolveTemplatePath } from '../../lib/utility.js';
 import { libWorkflowTemplatesMetadata } from '../../lib/workflow-templates.js';
 import { Logger } from '../../toolkit/index.js';
-export class CliUtilityInitialize {
+export class Runner {
     static async run(options) {
         const currentDirectory = process.cwd();
-        const isProjectRoot = await CliUtilityInitialize.checkPath(currentDirectory);
+        const isProjectRoot = await Runner.checkPath(currentDirectory);
         if (isProjectRoot !== true) {
             process.exitCode = 1;
             return;
@@ -20,23 +20,23 @@ export class CliUtilityInitialize {
         const isReplaceFile = options['replaceFile'] === true;
         if (isDryRun === true) {
             Logger.customize({
-                name: 'CliUtilityInitialize.run',
+                name: 'Runner.run',
                 purpose: 'options',
             }).warn('Dry run enabled. File changes will not be made in this session.');
         }
         if (isReplaceFile === true) {
             const replaceFileNotice = (isDryRun === true) ? 'This option has no effect during a dry run session.' : 'Backup file will not be created.';
             Logger.customize({
-                name: 'CliUtilityInitialize.run',
+                name: 'Runner.run',
                 purpose: 'options',
             }).warn(`Replace file enabled. ${replaceFileNotice}`);
         }
         const novaConfig = new LibNovaConfig();
         const workingFile = await novaConfig.load();
-        const promptFlowResult = await CliUtilityInitialize.promptFlow(workingFile);
+        const promptFlowResult = await Runner.promptFlow(workingFile);
         if (promptFlowResult === 'cancel') {
             Logger.customize({
-                name: 'CliUtilityInitialize.run',
+                name: 'Runner.run',
                 purpose: 'promptFlow',
             }).debug('Prompt flow exited without saving.');
             return;
@@ -44,7 +44,7 @@ export class CliUtilityInitialize {
         novaConfig.set(workingFile);
         if (isDryRun === true) {
             Logger.customize({
-                name: 'CliUtilityInitialize.run',
+                name: 'Runner.run',
                 purpose: 'promptFlow',
             }).debug('Dry run enabled. Skipping save operation.');
             return;
@@ -52,37 +52,48 @@ export class CliUtilityInitialize {
         await novaConfig.save(isReplaceFile);
         return;
     }
+    static isNonEmptyLiteralInput(value) {
+        if (typeof value === 'string' && value.trim() !== '') {
+            return true;
+        }
+        return 'This field is required.';
+    }
     static async promptFlow(config) {
         const category = {
             project: {
                 label: 'Project',
                 description: 'Configure project metadata (name, description, keywords).',
-                handler: CliUtilityInitialize['promptProject'],
+                handler: Runner['promptProject'],
             },
             entities: {
                 label: 'Entities',
                 description: 'Manage entities, their roles, and contact information.',
-                handler: CliUtilityInitialize['promptEntities'],
+                handler: Runner['promptEntities'],
             },
             emails: {
                 label: 'Emails',
                 description: 'Configure project emails (bugs, etc.).',
-                handler: CliUtilityInitialize['promptEmails'],
+                handler: Runner['promptEmails'],
+            },
+            github: {
+                label: 'GitHub',
+                description: 'Configure GitHub repository settings, recipes, and policies.',
+                handler: Runner['promptGithub'],
             },
             workflows: {
                 label: 'Workflows',
                 description: 'Configure workflow templates and settings.',
-                handler: CliUtilityInitialize['promptWorkflows'],
+                handler: Runner['promptWorkflows'],
             },
             urls: {
                 label: 'URLs',
                 description: 'Configure project URLs (homepage, repository, fund sources, etc.).',
-                handler: CliUtilityInitialize['promptUrls'],
+                handler: Runner['promptUrls'],
             },
             workspaces: {
                 label: 'Workspaces',
                 description: 'Review workspace packages, assigning roles and policies.',
-                handler: CliUtilityInitialize['promptWorkspaces'],
+                handler: Runner['promptWorkspaces'],
             },
         };
         while (true) {
@@ -102,7 +113,7 @@ export class CliUtilityInitialize {
                 description: 'Exit without persisting any changes.',
                 value: 'cancel',
             });
-            const menuOutput = await CliUtilityInitialize.promptWithCancel({
+            const menuOutput = await Runner.promptWithCancel({
                 type: 'select',
                 name: 'action',
                 message: 'Select a Nova configuration category to edit.',
@@ -138,52 +149,67 @@ export class CliUtilityInitialize {
         const projectName = (existingProjectName !== undefined) ? { ...existingProjectName } : {};
         const projectDescription = (existingProjectDescription !== undefined) ? { ...existingProjectDescription } : {};
         const projectKeywords = (existingProjectKeywords !== undefined) ? [...existingProjectKeywords] : [];
-        const questionsOutput = await CliUtilityInitialize.promptWithCancel([
+        const validateProjectNameTitle = (projectNameTitleValue) => {
+            return Runner.normalizeText(projectNameTitleValue, Infinity)['result'];
+        };
+        const validateProjectNameSlug = (projectNameSlugValue) => {
+            return Runner.normalizeProjectSlug(projectNameSlugValue)['result'];
+        };
+        const validateProjectDescriptionShort = (projectDescriptionShortValue) => {
+            return Runner.normalizeText(projectDescriptionShortValue, Infinity)['result'];
+        };
+        const validateProjectDescriptionLong = (projectDescriptionLongValue) => {
+            return Runner.normalizeText(projectDescriptionLongValue, Infinity)['result'];
+        };
+        const validateProjectKeywords = (projectKeywordsValue) => {
+            return Runner.normalizeTextArray(projectKeywordsValue, 50)['result'];
+        };
+        const questionsOutput = await Runner.promptWithCancel([
             {
                 type: 'text',
                 name: 'projectNameTitle',
                 message: 'Project title (display name)',
                 initial: projectName['title'] ?? '',
-                validate: (value) => CliUtilityInitialize.normalizeText(value, Infinity)['result'],
+                validate: validateProjectNameTitle,
             },
             {
                 type: 'text',
                 name: 'projectNameSlug',
                 message: 'Project slug (package name)',
                 initial: projectName['slug'] ?? '',
-                validate: (value) => CliUtilityInitialize.normalizeProjectSlug(value)['result'],
+                validate: validateProjectNameSlug,
             },
             {
                 type: 'text',
                 name: 'projectDescriptionShort',
                 message: 'Short description',
                 initial: projectDescription['short'] ?? '',
-                validate: (value) => CliUtilityInitialize.normalizeText(value, Infinity)['result'],
+                validate: validateProjectDescriptionShort,
             },
             {
                 type: 'text',
                 name: 'projectDescriptionLong',
                 message: 'Long description',
                 initial: projectDescription['long'] ?? '',
-                validate: (value) => CliUtilityInitialize.normalizeText(value, Infinity)['result'],
+                validate: validateProjectDescriptionLong,
             },
             {
                 type: 'text',
                 name: 'projectKeywords',
                 message: 'Keywords (comma separated)',
                 initial: (projectKeywords.length > 0) ? projectKeywords.join(', ') : '',
-                validate: (value) => CliUtilityInitialize.normalizeTextArray(value, 50)['result'],
+                validate: validateProjectKeywords,
             },
         ]);
         if (questionsOutput['cancelled'] === true) {
             return 'back';
         }
-        const questionsOutputResult = questionsOutput['result'];
-        const projectNameTitleInput = CliUtilityInitialize.normalizeText(questionsOutputResult.projectNameTitle, Infinity)['sanitized'];
-        const projectNameSlugInput = CliUtilityInitialize.normalizeProjectSlug(questionsOutputResult.projectNameSlug)['sanitized'];
-        const projectDescriptionShortInput = CliUtilityInitialize.normalizeText(questionsOutputResult.projectDescriptionShort, Infinity)['sanitized'];
-        const projectDescriptionLongInput = CliUtilityInitialize.normalizeText(questionsOutputResult.projectDescriptionLong, Infinity)['sanitized'];
-        const projectKeywordsInput = CliUtilityInitialize.normalizeTextArray(questionsOutputResult.projectKeywords, 50)['sanitized'];
+        const questionsOutputResultValue = questionsOutput['result'];
+        const projectNameTitleInput = Runner.normalizeText(questionsOutputResultValue.projectNameTitle, Infinity)['sanitized'];
+        const projectNameSlugInput = Runner.normalizeProjectSlug(questionsOutputResultValue.projectNameSlug)['sanitized'];
+        const projectDescriptionShortInput = Runner.normalizeText(questionsOutputResultValue.projectDescriptionShort, Infinity)['sanitized'];
+        const projectDescriptionLongInput = Runner.normalizeText(questionsOutputResultValue.projectDescriptionLong, Infinity)['sanitized'];
+        const projectKeywordsInput = Runner.normalizeTextArray(questionsOutputResultValue.projectKeywords, 50)['sanitized'];
         if (projectNameTitleInput !== undefined) {
             projectName.title = projectNameTitleInput;
         }
@@ -226,7 +252,7 @@ export class CliUtilityInitialize {
         else {
             Reflect.deleteProperty(project, 'keywords');
         }
-        const legalNameOutput = await CliUtilityInitialize.promptWithCancel({
+        const legalNameOutput = await Runner.promptWithCancel({
             type: 'text',
             name: 'projectLegalName',
             message: 'Legal name (for licenses and copyright notices)',
@@ -235,14 +261,14 @@ export class CliUtilityInitialize {
         if (legalNameOutput['cancelled'] === true) {
             return 'back';
         }
-        const projectLegalNameInput = CliUtilityInitialize.normalizeText(legalNameOutput['result'].projectLegalName, Infinity)['sanitized'];
+        const projectLegalNameInput = Runner.normalizeText(legalNameOutput['result'].projectLegalName, Infinity)['sanitized'];
         if (projectLegalNameInput !== undefined) {
             project.legalName = projectLegalNameInput;
         }
         else {
             Reflect.deleteProperty(project, 'legalName');
         }
-        const pronounsOutput = await CliUtilityInitialize.promptWithCancel({
+        const pronounsOutput = await Runner.promptWithCancel({
             type: 'select',
             name: 'projectPronouns',
             message: 'Pronouns',
@@ -325,7 +351,7 @@ export class CliUtilityInitialize {
                 selected: existingProjectPlatforms !== undefined && existingProjectPlatforms.includes('windows') === true,
             },
         ];
-        const platformsOutput = await CliUtilityInitialize.promptWithCancel({
+        const platformsOutput = await Runner.promptWithCancel({
             type: 'multiselect',
             name: 'projectPlatforms',
             message: 'Supported platforms',
@@ -341,24 +367,25 @@ export class CliUtilityInitialize {
         else {
             Reflect.deleteProperty(project, 'platforms');
         }
-        const startingYearOutput = await CliUtilityInitialize.promptWithCancel({
+        const validateProjectStartingYear = (projectStartingYearValue) => {
+            const trimmed = String(projectStartingYearValue ?? '').trim();
+            if (trimmed === '') {
+                return true;
+            }
+            const parsed = Number(trimmed);
+            if (Number.isNaN(parsed) === true
+                || Number.isInteger(parsed) === false
+                || parsed < 1970) {
+                return 'Must be an integer >= 1970';
+            }
+            return true;
+        };
+        const startingYearOutput = await Runner.promptWithCancel({
             type: 'text',
             name: 'projectStartingYear',
             message: 'Starting year (e.g. 2025)',
             initial: (existingProjectStartingYear !== undefined) ? String(existingProjectStartingYear) : '',
-            validate: (value) => {
-                const trimmed = String(value ?? '').trim();
-                if (trimmed === '') {
-                    return true;
-                }
-                const parsed = Number(trimmed);
-                if (Number.isNaN(parsed) === true
-                    || Number.isInteger(parsed) === false
-                    || parsed < 1970) {
-                    return 'Must be an integer >= 1970';
-                }
-                return true;
-            },
+            validate: validateProjectStartingYear,
         });
         if (startingYearOutput['cancelled'] === true) {
             return 'back';
@@ -432,7 +459,7 @@ export class CliUtilityInitialize {
             },
         ];
         const licenseInitialIndex = licenseChoices.findIndex((choice) => choice['value'] === existingProjectLicense);
-        const licenseOutput = await CliUtilityInitialize.promptWithCancel({
+        const licenseOutput = await Runner.promptWithCancel({
             type: 'select',
             name: 'projectLicense',
             message: 'License',
@@ -464,7 +491,7 @@ export class CliUtilityInitialize {
             const previousLabel = (previousSlug !== '') ? previousSlug : '(unset)';
             const currentLabel = (currentSlug !== '') ? currentSlug : '(unset)';
             Logger.customize({
-                name: 'CliUtilityInitialize.promptProject',
+                name: 'Runner.promptProject',
                 purpose: 'updated',
                 padTop: 1,
             }).info(`Project slug updated from "${previousLabel}" to "${currentLabel}".`);
@@ -483,13 +510,13 @@ export class CliUtilityInitialize {
                     workspace.name = name.replace(slugPrefix, `${currentSlug}-`);
                 }
                 Logger.customize({
-                    name: 'CliUtilityInitialize.promptProject',
+                    name: 'Runner.promptProject',
                     purpose: 'updated',
                 }).info(`Workspace name updated from "${name}" to "${workspace['name']}".`);
             }
         }
         Logger.customize({
-            name: 'CliUtilityInitialize.promptProject',
+            name: 'Runner.promptProject',
             purpose: 'updated',
             padTop: (slugChanged === true && config['workspaces'] !== undefined) ? 0 : 1,
             padBottom: 1,
@@ -602,7 +629,7 @@ export class CliUtilityInitialize {
                     kind: 'back',
                 },
             });
-            const menuOutput = await CliUtilityInitialize.promptWithCancel({
+            const menuOutput = await Runner.promptWithCancel({
                 type: 'select',
                 name: 'action',
                 message: (entities.length > 0) ? 'Select an entity to manage.' : 'No entities found. Choose an option.',
@@ -611,73 +638,73 @@ export class CliUtilityInitialize {
             if (menuOutput['cancelled'] === true) {
                 return 'back';
             }
-            const menuOutputResult = menuOutput['result'];
-            if (menuOutputResult.action === undefined
-                || menuOutputResult.action['kind'] === 'back') {
+            const menuOutputResultValue = menuOutput['result'];
+            if (menuOutputResultValue.action === undefined
+                || menuOutputResultValue.action['kind'] === 'back') {
                 sync();
                 return 'back';
             }
-            if (menuOutputResult.action['kind'] === 'add') {
-                const result = await CliUtilityInitialize.promptEntitiesForm(undefined, 'create');
+            if (menuOutputResultValue.action['kind'] === 'add') {
+                const result = await Runner.promptEntitiesForm(undefined, 'create');
                 if (result['action'] === 'back') {
                     continue;
                 }
                 entities.push(result['entity']);
                 sync();
                 Logger.customize({
-                    name: 'CliUtilityInitialize.promptEntities',
+                    name: 'Runner.promptEntities',
                     purpose: 'add',
                     padTop: 1,
                     padBottom: 1,
                 }).info('Added new entity.');
                 continue;
             }
-            if (menuOutputResult.action['kind'] === 'edit') {
-                const entityIndex = menuOutputResult.action['index'];
+            if (menuOutputResultValue.action['kind'] === 'edit') {
+                const entityIndex = menuOutputResultValue.action['index'];
                 if (entityIndex < 0 || entityIndex >= entities.length) {
                     continue;
                 }
                 const entityToEdit = entities[entityIndex];
-                const entityResult = await CliUtilityInitialize.promptEntitiesForm(entityToEdit, 'update');
+                const entityResult = await Runner.promptEntitiesForm(entityToEdit, 'update');
                 if (entityResult['action'] === 'back') {
                     continue;
                 }
                 Reflect.set(entities, entityIndex, entityResult['entity']);
                 sync();
                 Logger.customize({
-                    name: 'CliUtilityInitialize.promptEntities',
+                    name: 'Runner.promptEntities',
                     purpose: 'edit',
                     padTop: 1,
                     padBottom: 1,
                 }).info('Updated entity.');
                 continue;
             }
-            if (menuOutputResult.action['kind'] === 'remove') {
-                const entityIndex = menuOutputResult.action['index'];
-                if (entityIndex < 0 || entityIndex >= entities.length) {
+            if (menuOutputResultValue.action['kind'] === 'remove') {
+                const removeEntityIndex = menuOutputResultValue.action['index'];
+                if (removeEntityIndex < 0 || removeEntityIndex >= entities.length) {
                     continue;
                 }
-                const entityToRemove = entities[entityIndex];
+                const entityToRemove = entities[removeEntityIndex];
                 if (entityToRemove === undefined) {
                     continue;
                 }
-                const entityName = (typeof entityToRemove['name'] === 'string') ? entityToRemove['name'].trim() : '';
-                const entityEmail = (typeof entityToRemove['email'] === 'string') ? entityToRemove['email'].trim() : '';
-                let entityLabel = `Entity ${entityIndex + 1}`;
-                if (entityName !== '') {
-                    entityLabel = entityName;
+                const removeEntityName = (typeof entityToRemove['name'] === 'string') ? entityToRemove['name'].trim() : '';
+                const removeEntityEmail = (typeof entityToRemove['email'] === 'string') ? entityToRemove['email'].trim() : '';
+                let entityLabel = `Entity ${removeEntityIndex + 1}`;
+                if (removeEntityName !== '') {
+                    entityLabel = removeEntityName;
                 }
-                else if (entityEmail !== '') {
-                    entityLabel = entityEmail;
+                else if (removeEntityEmail !== '') {
+                    entityLabel = removeEntityEmail;
                 }
-                const shouldRemove = await CliUtilityInitialize.promptEntitiesDeleteForm(entityLabel);
+                const shouldRemove = await Runner.promptEntitiesDeleteForm(entityLabel);
                 if (shouldRemove !== true) {
                     continue;
                 }
-                entities.splice(entityIndex, 1);
+                entities.splice(removeEntityIndex, 1);
                 sync();
                 Logger.customize({
-                    name: 'CliUtilityInitialize.promptEntities',
+                    name: 'Runner.promptEntities',
                     purpose: 'remove',
                     padTop: 1,
                     padBottom: 1,
@@ -694,27 +721,36 @@ export class CliUtilityInitialize {
         if (entity !== undefined && Array.isArray(entity['roles']) === true) {
             existingRoles = entity['roles'].filter((role) => validRoles.includes(role));
         }
-        const questionsOutput = await CliUtilityInitialize.promptWithCancel([
+        const validateEntityName = (entityNameValue) => {
+            return Runner.normalizeText(entityNameValue, Infinity)['result'];
+        };
+        const validateEntityEmail = (entityEmailValue) => {
+            return Runner.normalizeEmail(entityEmailValue)['result'];
+        };
+        const validateEntityUrl = (entityUrlValue) => {
+            return Runner.normalizeUrl(entityUrlValue, 'generic')['result'];
+        };
+        const questionsOutput = await Runner.promptWithCancel([
             {
                 type: 'text',
                 name: 'entityName',
                 message: 'Entity name',
                 initial: existingName,
-                validate: (value) => CliUtilityInitialize.normalizeText(value, Infinity)['result'],
+                validate: validateEntityName,
             },
             {
                 type: 'text',
                 name: 'entityEmail',
                 message: 'Entity email address',
                 initial: existingEmail,
-                validate: (value) => CliUtilityInitialize.normalizeEmail(value)['result'],
+                validate: validateEntityEmail,
             },
             {
                 type: 'text',
                 name: 'entityUrl',
                 message: 'Entity website',
                 initial: existingUrl,
-                validate: (value) => CliUtilityInitialize.normalizeUrl(value, 'generic')['result'],
+                validate: validateEntityUrl,
             },
             {
                 type: 'multiselect',
@@ -733,9 +769,9 @@ export class CliUtilityInitialize {
             };
         }
         const questionsOutputResult = questionsOutput['result'];
-        const entityNameInput = CliUtilityInitialize.normalizeText(questionsOutputResult.entityName, Infinity)['sanitized'];
-        const entityEmailInput = CliUtilityInitialize.normalizeEmail(questionsOutputResult.entityEmail)['sanitized'];
-        const entityUrlInput = CliUtilityInitialize.normalizeUrl(questionsOutputResult.entityUrl, 'generic')['sanitized'];
+        const entityNameInput = Runner.normalizeText(questionsOutputResult.entityName, Infinity)['sanitized'];
+        const entityEmailInput = Runner.normalizeEmail(questionsOutputResult.entityEmail)['sanitized'];
+        const entityUrlInput = Runner.normalizeUrl(questionsOutputResult.entityUrl, 'generic')['sanitized'];
         const entityRolesInput = (Array.isArray(questionsOutputResult.entityRoles) === true) ? [...questionsOutputResult.entityRoles] : [];
         const resolvedEntity = {};
         if (entityNameInput !== undefined) {
@@ -761,7 +797,7 @@ export class CliUtilityInitialize {
         };
     }
     static async promptEntitiesDeleteForm(label) {
-        const confirmOutput = await CliUtilityInitialize.promptWithCancel({
+        const confirmOutput = await Runner.promptWithCancel({
             type: 'confirm',
             name: 'confirm',
             message: `Remove entity "${label}"?`,
@@ -776,18 +812,21 @@ export class CliUtilityInitialize {
     static async promptEmails(config) {
         const existingEmails = config['emails'];
         const emails = (existingEmails !== undefined) ? { ...existingEmails } : {};
-        const questionsOutput = await CliUtilityInitialize.promptWithCancel([{
+        const validateEmailsBugs = (emailsBugsValue) => {
+            return Runner.normalizeEmail(emailsBugsValue)['result'];
+        };
+        const questionsOutput = await Runner.promptWithCancel([{
                 type: 'text',
                 name: 'emailsBugs',
                 message: 'Issue tracker email',
                 initial: emails['bugs'] ?? '',
-                validate: (value) => CliUtilityInitialize.normalizeEmail(value)['result'],
+                validate: validateEmailsBugs,
             }]);
         if (questionsOutput['cancelled'] === true) {
             return 'back';
         }
         const questionsOutputResult = questionsOutput['result'];
-        const emailsBugsInput = CliUtilityInitialize.normalizeEmail(questionsOutputResult.emailsBugs)['sanitized'];
+        const emailsBugsInput = Runner.normalizeEmail(questionsOutputResult.emailsBugs)['sanitized'];
         if (emailsBugsInput !== undefined) {
             emails.bugs = emailsBugsInput;
         }
@@ -801,118 +840,610 @@ export class CliUtilityInitialize {
             Reflect.deleteProperty(config, 'emails');
         }
         Logger.customize({
-            name: 'CliUtilityInitialize.promptEmails',
+            name: 'Runner.promptEmails',
             purpose: 'updated',
             padTop: 1,
             padBottom: 1,
         }).info('Email references updated.');
         return 'back';
     }
+    static async promptGithub(config) {
+        const existingGithub = config['github'];
+        const github = (existingGithub !== undefined) ? { ...existingGithub } : {};
+        const validateGithubOwner = (githubOwnerValue) => {
+            const trimmed = (typeof githubOwnerValue === 'string') ? githubOwnerValue.trim() : '';
+            if (trimmed === '') {
+                return 'Owner is required.';
+            }
+            return true;
+        };
+        const ownerOutput = await Runner.promptWithCancel({
+            type: 'text',
+            name: 'githubOwner',
+            message: 'GitHub owner (organization or user)',
+            initial: (github['owner'] !== undefined) ? github['owner'] : '',
+            validate: validateGithubOwner,
+        });
+        if (ownerOutput['cancelled'] === true) {
+            return 'back';
+        }
+        const ownerOutputResult = ownerOutput['result'];
+        const githubOwnerInput = ownerOutputResult.githubOwner.trim();
+        const validateGithubRepo = (githubRepoValue) => {
+            const trimmed = (typeof githubRepoValue === 'string') ? githubRepoValue.trim() : '';
+            if (trimmed === '') {
+                return 'Repository name is required.';
+            }
+            return true;
+        };
+        const repoOutput = await Runner.promptWithCancel({
+            type: 'text',
+            name: 'githubRepo',
+            message: 'GitHub repository name',
+            initial: (github['repo'] !== undefined) ? github['repo'] : '',
+            validate: validateGithubRepo,
+        });
+        if (repoOutput['cancelled'] === true) {
+            return 'back';
+        }
+        const repoOutputResult = repoOutput['result'];
+        const githubRepoInput = repoOutputResult.githubRepo.trim();
+        const existingRecipes = github['recipes'];
+        const syncIdentityInitial = (existingRecipes !== undefined && existingRecipes['sync-identity'] !== undefined) ? existingRecipes['sync-identity'] : true;
+        const syncFeaturesInitial = (existingRecipes !== undefined && existingRecipes['sync-features'] !== undefined) ? existingRecipes['sync-features'] : false;
+        const syncPoliciesInitial = (existingRecipes !== undefined && existingRecipes['sync-policies'] !== undefined) ? existingRecipes['sync-policies'] : false;
+        const recipesOutput = await Runner.promptWithCancel([
+            {
+                type: 'confirm',
+                name: 'githubRecipeSyncIdentity',
+                message: 'Enable sync-identity recipe?',
+                initial: syncIdentityInitial,
+            },
+            {
+                type: 'confirm',
+                name: 'githubRecipeSyncFeatures',
+                message: 'Enable sync-features recipe?',
+                initial: syncFeaturesInitial,
+            },
+            {
+                type: 'confirm',
+                name: 'githubRecipeSyncPolicies',
+                message: 'Enable sync-policies recipe?',
+                initial: syncPoliciesInitial,
+            },
+        ]);
+        if (recipesOutput['cancelled'] === true) {
+            return 'back';
+        }
+        const recipesOutputResult = recipesOutput['result'];
+        const githubRecipesInput = {
+            'sync-identity': recipesOutputResult.githubRecipeSyncIdentity,
+            'sync-features': recipesOutputResult.githubRecipeSyncFeatures,
+            'sync-policies': recipesOutputResult.githubRecipeSyncPolicies,
+        };
+        const existingTopics = github['topics'];
+        const topicsHasExisting = (existingTopics !== undefined) && existingTopics.length > 0;
+        const topicsTitle = (existingTopics !== undefined && topicsHasExisting === true) ? `Keep existing: ${existingTopics.join(', ')}` : 'Enter topics (comma-separated)';
+        const topicsValue = (existingTopics !== undefined) ? existingTopics : [];
+        const topicsInitial = (existingTopics !== undefined) ? 1 : 0;
+        const topicsOutput = await Runner.promptWithCancel({
+            type: 'select',
+            name: 'githubTopics',
+            message: 'GitHub topics (sync this field?)',
+            choices: [
+                {
+                    title: 'Skip (don\'t sync this field)',
+                    value: 'skip',
+                },
+                {
+                    title: topicsTitle,
+                    value: topicsValue,
+                },
+            ],
+            initial: topicsInitial,
+        });
+        if (topicsOutput['cancelled'] === true) {
+            return 'back';
+        }
+        const topicsOutputResult = topicsOutput['result'];
+        let githubTopicsInput = undefined;
+        if (topicsOutputResult.githubTopics !== 'skip') {
+            if (existingTopics !== undefined && existingTopics.length > 0) {
+                githubTopicsInput = existingTopics;
+            }
+            else {
+                const topicsTextOutput = await Runner.promptWithCancel({
+                    type: 'text',
+                    name: 'githubOwner',
+                    message: 'Topics (comma-separated)',
+                    initial: '',
+                });
+                if (topicsTextOutput['cancelled'] === true) {
+                    return 'back';
+                }
+                const rawTopics = topicsTextOutput['result'].githubOwner;
+                const parsedTopics = rawTopics.split(',').map((t) => t.trim()).filter((t) => t !== '');
+                if (parsedTopics.length > 0) {
+                    githubTopicsInput = parsedTopics;
+                }
+            }
+        }
+        const existingFeatures = github['features'];
+        let featuresIssuesInitial = 0;
+        if (existingFeatures !== undefined && existingFeatures['issues'] !== undefined) {
+            featuresIssuesInitial = (existingFeatures['issues'] === true) ? 1 : 2;
+        }
+        let featuresWikiInitial = 0;
+        if (existingFeatures !== undefined && existingFeatures['wiki'] !== undefined) {
+            featuresWikiInitial = (existingFeatures['wiki'] === true) ? 1 : 2;
+        }
+        let featuresProjectsInitial = 0;
+        if (existingFeatures !== undefined && existingFeatures['projects'] !== undefined) {
+            featuresProjectsInitial = (existingFeatures['projects'] === true) ? 1 : 2;
+        }
+        let featuresDiscussionsInitial = 0;
+        if (existingFeatures !== undefined && existingFeatures['discussions'] !== undefined) {
+            featuresDiscussionsInitial = (existingFeatures['discussions'] === true) ? 1 : 2;
+        }
+        const featuresOutput = await Runner.promptWithCancel([
+            {
+                type: 'select',
+                name: 'githubFeaturesIssues',
+                message: 'GitHub features.issues (sync this field?)',
+                choices: [
+                    {
+                        title: 'Skip (don\'t sync this field)',
+                        value: 'skip',
+                    },
+                    {
+                        title: 'Enable',
+                        value: true,
+                    },
+                    {
+                        title: 'Disable',
+                        value: false,
+                    },
+                ],
+                initial: featuresIssuesInitial,
+            },
+            {
+                type: 'select',
+                name: 'githubFeaturesWiki',
+                message: 'GitHub features.wiki (sync this field?)',
+                choices: [
+                    {
+                        title: 'Skip (don\'t sync this field)',
+                        value: 'skip',
+                    },
+                    {
+                        title: 'Enable',
+                        value: true,
+                    },
+                    {
+                        title: 'Disable',
+                        value: false,
+                    },
+                ],
+                initial: featuresWikiInitial,
+            },
+            {
+                type: 'select',
+                name: 'githubFeaturesProjects',
+                message: 'GitHub features.projects (sync this field?)',
+                choices: [
+                    {
+                        title: 'Skip (don\'t sync this field)',
+                        value: 'skip',
+                    },
+                    {
+                        title: 'Enable',
+                        value: true,
+                    },
+                    {
+                        title: 'Disable',
+                        value: false,
+                    },
+                ],
+                initial: featuresProjectsInitial,
+            },
+            {
+                type: 'select',
+                name: 'githubFeaturesDiscussions',
+                message: 'GitHub features.discussions (sync this field?)',
+                choices: [
+                    {
+                        title: 'Skip (don\'t sync this field)',
+                        value: 'skip',
+                    },
+                    {
+                        title: 'Enable',
+                        value: true,
+                    },
+                    {
+                        title: 'Disable',
+                        value: false,
+                    },
+                ],
+                initial: featuresDiscussionsInitial,
+            },
+        ]);
+        if (featuresOutput['cancelled'] === true) {
+            return 'back';
+        }
+        const featuresOutputResult = featuresOutput['result'];
+        let githubFeaturesInput = undefined;
+        const featuresIssuesValue = featuresOutputResult.githubFeaturesIssues;
+        const featuresWikiValue = featuresOutputResult.githubFeaturesWiki;
+        const featuresProjectsValue = featuresOutputResult.githubFeaturesProjects;
+        const featuresDiscussionsValue = featuresOutputResult.githubFeaturesDiscussions;
+        if (featuresIssuesValue !== 'skip'
+            || featuresWikiValue !== 'skip'
+            || featuresProjectsValue !== 'skip'
+            || featuresDiscussionsValue !== 'skip') {
+            githubFeaturesInput = {
+                ...((featuresIssuesValue !== 'skip') ? { issues: featuresIssuesValue } : {}),
+                ...((featuresWikiValue !== 'skip') ? { wiki: featuresWikiValue } : {}),
+                ...((featuresProjectsValue !== 'skip') ? { projects: featuresProjectsValue } : {}),
+                ...((featuresDiscussionsValue !== 'skip') ? { discussions: featuresDiscussionsValue } : {}),
+            };
+        }
+        const existingPolicies = github['policies'];
+        const existingVisibility = (existingPolicies !== undefined) ? existingPolicies['visibility'] : undefined;
+        const visibilityOrder = [
+            'public',
+            'private',
+            'internal',
+        ];
+        const visibilityInitial = (existingVisibility !== undefined) ? (visibilityOrder.indexOf(existingVisibility) + 1) : 0;
+        const visibilityOutput = await Runner.promptWithCancel({
+            type: 'select',
+            name: 'githubPoliciesVisibility',
+            message: 'GitHub policies.visibility (sync this field?)',
+            choices: [
+                {
+                    title: 'Skip (don\'t sync this field)',
+                    value: 'skip',
+                },
+                {
+                    title: 'Public',
+                    value: 'public',
+                },
+                {
+                    title: 'Private',
+                    value: 'private',
+                },
+                {
+                    title: 'Internal',
+                    value: 'internal',
+                },
+            ],
+            initial: visibilityInitial,
+        });
+        if (visibilityOutput['cancelled'] === true) {
+            return 'back';
+        }
+        const visibilityOutputResult = visibilityOutput['result'];
+        const githubPoliciesVisibilityValue = visibilityOutputResult.githubPoliciesVisibility;
+        const existingDefaultBranch = (existingPolicies !== undefined) ? existingPolicies['defaultBranch'] : undefined;
+        const defaultBranchTitle = (existingDefaultBranch !== undefined) ? `Keep existing: ${existingDefaultBranch}` : 'Enter default branch name';
+        const defaultBranchChoiceValue = (existingDefaultBranch !== undefined) ? existingDefaultBranch : 'enter';
+        const defaultBranchInitial = (existingDefaultBranch !== undefined) ? 1 : 0;
+        const defaultBranchOutput = await Runner.promptWithCancel({
+            type: 'select',
+            name: 'githubPoliciesDefaultBranch',
+            message: 'GitHub policies.defaultBranch (sync this field?)',
+            choices: [
+                {
+                    title: 'Skip (don\'t sync this field)',
+                    value: 'skip',
+                },
+                {
+                    title: defaultBranchTitle,
+                    value: defaultBranchChoiceValue,
+                },
+            ],
+            initial: defaultBranchInitial,
+        });
+        if (defaultBranchOutput['cancelled'] === true) {
+            return 'back';
+        }
+        const defaultBranchOutputResult = defaultBranchOutput['result'];
+        let githubPoliciesDefaultBranchValue = defaultBranchOutputResult.githubPoliciesDefaultBranch;
+        if (githubPoliciesDefaultBranchValue === 'enter') {
+            const defaultBranchTextOutput = await Runner.promptWithCancel({
+                type: 'text',
+                name: 'githubRepo',
+                message: 'Default branch name',
+                initial: '',
+            });
+            if (defaultBranchTextOutput['cancelled'] === true) {
+                return 'back';
+            }
+            const rawDefaultBranch = defaultBranchTextOutput['result'].githubRepo.trim();
+            githubPoliciesDefaultBranchValue = (rawDefaultBranch !== '') ? rawDefaultBranch : 'skip';
+        }
+        const existingMergeMethods = github['policies'];
+        const existingMergeMethodsObj = (existingMergeMethods !== undefined) ? existingMergeMethods['mergeMethods'] : undefined;
+        let mergeInitial = 0;
+        if (existingMergeMethodsObj !== undefined && existingMergeMethodsObj['merge'] !== undefined) {
+            mergeInitial = (existingMergeMethodsObj['merge'] === true) ? 1 : 2;
+        }
+        let squashInitial = 0;
+        if (existingMergeMethodsObj !== undefined && existingMergeMethodsObj['squash'] !== undefined) {
+            squashInitial = (existingMergeMethodsObj['squash'] === true) ? 1 : 2;
+        }
+        let rebaseInitial = 0;
+        if (existingMergeMethodsObj !== undefined && existingMergeMethodsObj['rebase'] !== undefined) {
+            rebaseInitial = (existingMergeMethodsObj['rebase'] === true) ? 1 : 2;
+        }
+        const mergeMethodsOutput = await Runner.promptWithCancel([
+            {
+                type: 'select',
+                name: 'githubPoliciesMergeMethodsMerge',
+                message: 'GitHub policies.mergeMethods.merge (sync this field?)',
+                choices: [
+                    {
+                        title: 'Skip (don\'t sync this field)',
+                        value: 'skip',
+                    },
+                    {
+                        title: 'Enable',
+                        value: true,
+                    },
+                    {
+                        title: 'Disable',
+                        value: false,
+                    },
+                ],
+                initial: mergeInitial,
+            },
+            {
+                type: 'select',
+                name: 'githubPoliciesMergeMethodsSquash',
+                message: 'GitHub policies.mergeMethods.squash (sync this field?)',
+                choices: [
+                    {
+                        title: 'Skip (don\'t sync this field)',
+                        value: 'skip',
+                    },
+                    {
+                        title: 'Enable',
+                        value: true,
+                    },
+                    {
+                        title: 'Disable',
+                        value: false,
+                    },
+                ],
+                initial: squashInitial,
+            },
+            {
+                type: 'select',
+                name: 'githubPoliciesMergeMethodsRebase',
+                message: 'GitHub policies.mergeMethods.rebase (sync this field?)',
+                choices: [
+                    {
+                        title: 'Skip (don\'t sync this field)',
+                        value: 'skip',
+                    },
+                    {
+                        title: 'Enable',
+                        value: true,
+                    },
+                    {
+                        title: 'Disable',
+                        value: false,
+                    },
+                ],
+                initial: rebaseInitial,
+            },
+        ]);
+        if (mergeMethodsOutput['cancelled'] === true) {
+            return 'back';
+        }
+        const mergeMethodsOutputResult = mergeMethodsOutput['result'];
+        let githubPoliciesMergeMethodsInput = undefined;
+        const mergeMethodsMergeValue = mergeMethodsOutputResult.githubPoliciesMergeMethodsMerge;
+        const mergeMethodsSquashValue = mergeMethodsOutputResult.githubPoliciesMergeMethodsSquash;
+        const mergeMethodsRebaseValue = mergeMethodsOutputResult.githubPoliciesMergeMethodsRebase;
+        if (mergeMethodsMergeValue !== 'skip'
+            || mergeMethodsSquashValue !== 'skip'
+            || mergeMethodsRebaseValue !== 'skip') {
+            githubPoliciesMergeMethodsInput = {
+                ...((mergeMethodsMergeValue !== 'skip') ? { merge: mergeMethodsMergeValue } : {}),
+                ...((mergeMethodsSquashValue !== 'skip') ? { squash: mergeMethodsSquashValue } : {}),
+                ...((mergeMethodsRebaseValue !== 'skip') ? { rebase: mergeMethodsRebaseValue } : {}),
+            };
+        }
+        const existingAutoDelete = (existingPolicies !== undefined) ? existingPolicies['autoDeleteHeadBranch'] : undefined;
+        let autoDeleteInitial = 0;
+        if (existingAutoDelete !== undefined) {
+            autoDeleteInitial = (existingAutoDelete === true) ? 1 : 2;
+        }
+        const autoDeleteOutput = await Runner.promptWithCancel({
+            type: 'select',
+            name: 'githubPoliciesAutoDeleteHeadBranch',
+            message: 'GitHub policies.autoDeleteHeadBranch (sync this field?)',
+            choices: [
+                {
+                    title: 'Skip (don\'t sync this field)',
+                    value: 'skip',
+                },
+                {
+                    title: 'Enable',
+                    value: true,
+                },
+                {
+                    title: 'Disable',
+                    value: false,
+                },
+            ],
+            initial: autoDeleteInitial,
+        });
+        if (autoDeleteOutput['cancelled'] === true) {
+            return 'back';
+        }
+        const autoDeleteOutputResult = autoDeleteOutput['result'];
+        const githubPoliciesAutoDeleteValue = autoDeleteOutputResult.githubPoliciesAutoDeleteHeadBranch;
+        let githubPoliciesInput = undefined;
+        if (githubPoliciesVisibilityValue !== 'skip'
+            || githubPoliciesDefaultBranchValue !== 'skip'
+            || githubPoliciesMergeMethodsInput !== undefined
+            || githubPoliciesAutoDeleteValue !== 'skip') {
+            githubPoliciesInput = {
+                ...((githubPoliciesVisibilityValue !== 'skip') ? { visibility: githubPoliciesVisibilityValue } : {}),
+                ...((githubPoliciesDefaultBranchValue !== 'skip') ? { defaultBranch: githubPoliciesDefaultBranchValue } : {}),
+                ...(githubPoliciesMergeMethodsInput !== undefined ? { mergeMethods: githubPoliciesMergeMethodsInput } : {}),
+                ...((githubPoliciesAutoDeleteValue !== 'skip') ? { autoDeleteHeadBranch: githubPoliciesAutoDeleteValue } : {}),
+            };
+        }
+        const githubConfig = {
+            owner: githubOwnerInput,
+            repo: githubRepoInput,
+            recipes: githubRecipesInput,
+            ...(githubTopicsInput !== undefined ? { topics: githubTopicsInput } : {}),
+            ...(githubFeaturesInput !== undefined ? { features: githubFeaturesInput } : {}),
+            ...(githubPoliciesInput !== undefined ? { policies: githubPoliciesInput } : {}),
+        };
+        Object.assign(config, { github: githubConfig });
+        Logger.customize({
+            name: 'Runner.promptGithub',
+            purpose: 'updated',
+            padTop: 1,
+            padBottom: 1,
+        }).info('GitHub settings updated.');
+        return 'back';
+    }
     static async promptUrls(config) {
         const existingUrls = config['urls'];
         const urls = (existingUrls !== undefined) ? { ...existingUrls } : {};
-        const questionsOutput = await CliUtilityInitialize.promptWithCancel([
+        const validateUrlsHomepage = (urlsHomepageValue) => {
+            return Runner.normalizeUrl(urlsHomepageValue, 'generic')['result'];
+        };
+        const validateUrlsRepository = (urlsRepositoryValue) => {
+            return Runner.normalizeUrl(urlsRepositoryValue, 'repository')['result'];
+        };
+        const validateUrlsBugs = (urlsBugsValue) => {
+            return Runner.normalizeUrl(urlsBugsValue, 'generic')['result'];
+        };
+        const validateUrlsLicense = (urlsLicenseValue) => {
+            return Runner.normalizeUrl(urlsLicenseValue, 'generic')['result'];
+        };
+        const validateUrlsLogo = (urlsLogoValue) => {
+            return Runner.normalizeUrl(urlsLogoValue, 'generic')['result'];
+        };
+        const validateUrlsDocumentation = (urlsDocumentationValue) => {
+            return Runner.normalizeUrl(urlsDocumentationValue, 'generic')['result'];
+        };
+        const validateUrlsNpm = (urlsNpmValue) => {
+            return Runner.normalizeUrl(urlsNpmValue, 'generic')['result'];
+        };
+        const validateUrlsDocker = (urlsDockerValue) => {
+            return Runner.normalizeUrl(urlsDockerValue, 'generic')['result'];
+        };
+        const validateUrlsFundSources = (urlsFundSourcesValue) => {
+            return Runner.normalizeUrlArray(urlsFundSourcesValue, 'generic')['result'];
+        };
+        const validateUrlsPrivacyPolicy = (urlsPrivacyPolicyValue) => {
+            return Runner.normalizeUrl(urlsPrivacyPolicyValue, 'generic')['result'];
+        };
+        const validateUrlsTermsOfUse = (urlsTermsOfUseValue) => {
+            return Runner.normalizeUrl(urlsTermsOfUseValue, 'generic')['result'];
+        };
+        const questionsOutput = await Runner.promptWithCancel([
             {
                 type: 'text',
                 name: 'urlsHomepage',
                 message: 'Homepage URL',
                 initial: urls['homepage'] ?? '',
-                validate: (value) => CliUtilityInitialize.normalizeUrl(value, 'generic')['result'],
+                validate: validateUrlsHomepage,
             },
             {
                 type: 'text',
                 name: 'urlsRepository',
                 message: 'Repository URL',
                 initial: urls['repository'] ?? '',
-                validate: (value) => CliUtilityInitialize.normalizeUrl(value, 'repository')['result'],
+                validate: validateUrlsRepository,
             },
             {
                 type: 'text',
                 name: 'urlsBugs',
                 message: 'Issue tracker URL',
                 initial: urls['bugs'] ?? '',
-                validate: (value) => CliUtilityInitialize.normalizeUrl(value, 'generic')['result'],
+                validate: validateUrlsBugs,
             },
             {
                 type: 'text',
                 name: 'urlsLicense',
                 message: 'License URL',
                 initial: urls['license'] ?? '',
-                validate: (value) => CliUtilityInitialize.normalizeUrl(value, 'generic')['result'],
+                validate: validateUrlsLicense,
             },
             {
                 type: 'text',
                 name: 'urlsLogo',
                 message: 'Logo URL',
                 initial: urls['logo'] ?? '',
-                validate: (value) => CliUtilityInitialize.normalizeUrl(value, 'generic')['result'],
+                validate: validateUrlsLogo,
             },
             {
                 type: 'text',
                 name: 'urlsDocumentation',
                 message: 'Documentation URL',
                 initial: urls['documentation'] ?? '',
-                validate: (value) => CliUtilityInitialize.normalizeUrl(value, 'generic')['result'],
-            },
-            {
-                type: 'text',
-                name: 'urlsGithub',
-                message: 'GitHub URL',
-                initial: urls['github'] ?? '',
-                validate: (value) => CliUtilityInitialize.normalizeUrl(value, 'generic')['result'],
+                validate: validateUrlsDocumentation,
             },
             {
                 type: 'text',
                 name: 'urlsNpm',
                 message: 'npm package URL',
                 initial: urls['npm'] ?? '',
-                validate: (value) => CliUtilityInitialize.normalizeUrl(value, 'generic')['result'],
+                validate: validateUrlsNpm,
             },
             {
                 type: 'text',
                 name: 'urlsDocker',
                 message: 'Docker Hub URL',
                 initial: urls['docker'] ?? '',
-                validate: (value) => CliUtilityInitialize.normalizeUrl(value, 'generic')['result'],
+                validate: validateUrlsDocker,
             },
             {
                 type: 'text',
                 name: 'urlsFundSources',
                 message: 'Funding URLs (comma separated)',
                 initial: (Array.isArray(urls['fundSources']) === true) ? urls['fundSources'].join(', ') : '',
-                validate: (value) => CliUtilityInitialize.normalizeUrlArray(value, 'generic')['result'],
+                validate: validateUrlsFundSources,
             },
             {
                 type: 'text',
                 name: 'urlsPrivacyPolicy',
                 message: 'Privacy policy URL',
                 initial: urls['privacyPolicy'] ?? '',
-                validate: (value) => CliUtilityInitialize.normalizeUrl(value, 'generic')['result'],
+                validate: validateUrlsPrivacyPolicy,
             },
             {
                 type: 'text',
                 name: 'urlsTermsOfUse',
                 message: 'Terms of use URL',
                 initial: urls['termsOfUse'] ?? '',
-                validate: (value) => CliUtilityInitialize.normalizeUrl(value, 'generic')['result'],
+                validate: validateUrlsTermsOfUse,
             },
         ]);
         if (questionsOutput['cancelled'] === true) {
             return 'back';
         }
         const questionsOutputResult = questionsOutput['result'];
-        const urlsHomepageInput = CliUtilityInitialize.normalizeUrl(questionsOutputResult.urlsHomepage, 'generic')['sanitized'];
-        const urlsRepositoryInput = CliUtilityInitialize.normalizeUrl(questionsOutputResult.urlsRepository, 'repository')['sanitized'];
-        const urlsBugsInput = CliUtilityInitialize.normalizeUrl(questionsOutputResult.urlsBugs, 'generic')['sanitized'];
-        const urlsLicenseInput = CliUtilityInitialize.normalizeUrl(questionsOutputResult.urlsLicense, 'generic')['sanitized'];
-        const urlsLogoInput = CliUtilityInitialize.normalizeUrl(questionsOutputResult.urlsLogo, 'generic')['sanitized'];
-        const urlsDocumentationInput = CliUtilityInitialize.normalizeUrl(questionsOutputResult.urlsDocumentation, 'generic')['sanitized'];
-        const urlsGithubInput = CliUtilityInitialize.normalizeUrl(questionsOutputResult.urlsGithub, 'generic')['sanitized'];
-        const urlsNpmInput = CliUtilityInitialize.normalizeUrl(questionsOutputResult.urlsNpm, 'generic')['sanitized'];
-        const urlsDockerInput = CliUtilityInitialize.normalizeUrl(questionsOutputResult.urlsDocker, 'generic')['sanitized'];
-        const urlsFundSourcesInput = CliUtilityInitialize.normalizeUrlArray(questionsOutputResult.urlsFundSources, 'generic')['sanitized'];
-        const urlsPrivacyPolicyInput = CliUtilityInitialize.normalizeUrl(questionsOutputResult.urlsPrivacyPolicy, 'generic')['sanitized'];
-        const urlsTermsOfUseInput = CliUtilityInitialize.normalizeUrl(questionsOutputResult.urlsTermsOfUse, 'generic')['sanitized'];
+        const urlsHomepageInput = Runner.normalizeUrl(questionsOutputResult.urlsHomepage, 'generic')['sanitized'];
+        const urlsRepositoryInput = Runner.normalizeUrl(questionsOutputResult.urlsRepository, 'repository')['sanitized'];
+        const urlsBugsInput = Runner.normalizeUrl(questionsOutputResult.urlsBugs, 'generic')['sanitized'];
+        const urlsLicenseInput = Runner.normalizeUrl(questionsOutputResult.urlsLicense, 'generic')['sanitized'];
+        const urlsLogoInput = Runner.normalizeUrl(questionsOutputResult.urlsLogo, 'generic')['sanitized'];
+        const urlsDocumentationInput = Runner.normalizeUrl(questionsOutputResult.urlsDocumentation, 'generic')['sanitized'];
+        const urlsNpmInput = Runner.normalizeUrl(questionsOutputResult.urlsNpm, 'generic')['sanitized'];
+        const urlsDockerInput = Runner.normalizeUrl(questionsOutputResult.urlsDocker, 'generic')['sanitized'];
+        const urlsFundSourcesInput = Runner.normalizeUrlArray(questionsOutputResult.urlsFundSources, 'generic')['sanitized'];
+        const urlsPrivacyPolicyInput = Runner.normalizeUrl(questionsOutputResult.urlsPrivacyPolicy, 'generic')['sanitized'];
+        const urlsTermsOfUseInput = Runner.normalizeUrl(questionsOutputResult.urlsTermsOfUse, 'generic')['sanitized'];
         if (urlsHomepageInput !== undefined) {
             urls.homepage = urlsHomepageInput;
         }
@@ -949,12 +1480,6 @@ export class CliUtilityInitialize {
         else {
             Reflect.deleteProperty(urls, 'documentation');
         }
-        if (urlsGithubInput !== undefined) {
-            urls.github = urlsGithubInput;
-        }
-        else {
-            Reflect.deleteProperty(urls, 'github');
-        }
         if (urlsNpmInput !== undefined) {
             urls.npm = urlsNpmInput;
         }
@@ -992,7 +1517,7 @@ export class CliUtilityInitialize {
             Reflect.deleteProperty(config, 'urls');
         }
         Logger.customize({
-            name: 'CliUtilityInitialize.promptUrls',
+            name: 'Runner.promptUrls',
             purpose: 'updated',
             padTop: 1,
             padBottom: 1,
@@ -1106,7 +1631,7 @@ export class CliUtilityInitialize {
                     kind: 'back',
                 },
             });
-            const menuOutput = await CliUtilityInitialize.promptWithCancel({
+            const menuOutput = await Runner.promptWithCancel({
                 type: 'select',
                 name: 'action',
                 message: (workflows.length > 0) ? 'Select a workflow to manage.' : 'No workflows found. Choose an option.',
@@ -1115,73 +1640,73 @@ export class CliUtilityInitialize {
             if (menuOutput['cancelled'] === true) {
                 return 'back';
             }
-            const menuOutputResult = menuOutput['result'];
-            if (menuOutputResult.action === undefined
-                || menuOutputResult.action['kind'] === 'back') {
+            const menuOutputResultValue = menuOutput['result'];
+            if (menuOutputResultValue.action === undefined
+                || menuOutputResultValue.action['kind'] === 'back') {
                 sync();
                 return 'back';
             }
-            if (menuOutputResult.action['kind'] === 'add') {
-                const result = await CliUtilityInitialize.promptWorkflowsForm(undefined, 'create', workflows, config);
+            if (menuOutputResultValue.action['kind'] === 'add') {
+                const result = await Runner.promptWorkflowsForm(undefined, 'create', workflows, config);
                 if (result['action'] === 'back') {
                     continue;
                 }
                 workflows.push(result['workflow']);
                 sync();
                 Logger.customize({
-                    name: 'CliUtilityInitialize.promptWorkflows',
+                    name: 'Runner.promptWorkflows',
                     purpose: 'add',
                     padTop: 1,
                     padBottom: 1,
                 }).info('Added new workflow.');
                 continue;
             }
-            if (menuOutputResult.action['kind'] === 'edit') {
-                const workflowIndex = menuOutputResult.action['index'];
+            if (menuOutputResultValue.action['kind'] === 'edit') {
+                const workflowIndex = menuOutputResultValue.action['index'];
                 if (workflowIndex < 0 || workflowIndex >= workflows.length) {
                     continue;
                 }
                 const workflowToEdit = workflows[workflowIndex];
-                const workflowResult = await CliUtilityInitialize.promptWorkflowsForm(workflowToEdit, 'update', workflows, config);
+                const workflowResult = await Runner.promptWorkflowsForm(workflowToEdit, 'update', workflows, config);
                 if (workflowResult['action'] === 'back') {
                     continue;
                 }
                 Reflect.set(workflows, workflowIndex, workflowResult['workflow']);
                 sync();
                 Logger.customize({
-                    name: 'CliUtilityInitialize.promptWorkflows',
+                    name: 'Runner.promptWorkflows',
                     purpose: 'edit',
                     padTop: 1,
                     padBottom: 1,
                 }).info('Updated workflow.');
                 continue;
             }
-            if (menuOutputResult.action['kind'] === 'remove') {
-                const workflowIndex = menuOutputResult.action['index'];
-                if (workflowIndex < 0 || workflowIndex >= workflows.length) {
+            if (menuOutputResultValue.action['kind'] === 'remove') {
+                const removeWorkflowIndex = menuOutputResultValue.action['index'];
+                if (removeWorkflowIndex < 0 || removeWorkflowIndex >= workflows.length) {
                     continue;
                 }
-                const workflowToRemove = workflows[workflowIndex];
+                const workflowToRemove = workflows[removeWorkflowIndex];
                 if (workflowToRemove === undefined) {
                     continue;
                 }
-                const template = (typeof workflowToRemove['template'] === 'string') ? workflowToRemove['template'].trim() : '';
-                const suffix = (typeof workflowToRemove['suffix'] === 'string') ? workflowToRemove['suffix'].trim() : '';
-                let workflowLabel = `Workflow ${workflowIndex + 1}`;
-                if (template !== '' && suffix !== '') {
-                    workflowLabel = `${template}-${suffix}`;
+                const removeTemplate = (typeof workflowToRemove['template'] === 'string') ? workflowToRemove['template'].trim() : '';
+                const removeSuffix = (typeof workflowToRemove['suffix'] === 'string') ? workflowToRemove['suffix'].trim() : '';
+                let workflowLabel = `Workflow ${removeWorkflowIndex + 1}`;
+                if (removeTemplate !== '' && removeSuffix !== '') {
+                    workflowLabel = `${removeTemplate}-${removeSuffix}`;
                 }
-                else if (template !== '') {
-                    workflowLabel = template;
+                else if (removeTemplate !== '') {
+                    workflowLabel = removeTemplate;
                 }
-                const shouldRemove = await CliUtilityInitialize.promptWorkflowsDeleteForm(workflowLabel);
+                const shouldRemove = await Runner.promptWorkflowsDeleteForm(workflowLabel);
                 if (shouldRemove !== true) {
                     continue;
                 }
-                workflows.splice(workflowIndex, 1);
+                workflows.splice(removeWorkflowIndex, 1);
                 sync();
                 Logger.customize({
-                    name: 'CliUtilityInitialize.promptWorkflows',
+                    name: 'Runner.promptWorkflows',
                     purpose: 'remove',
                     padTop: 1,
                     padBottom: 1,
@@ -1208,7 +1733,7 @@ export class CliUtilityInitialize {
                 templateInitialIndex = foundIndex;
             }
         }
-        const templateOutput = await CliUtilityInitialize.promptWithCancel({
+        const templateOutput = await Runner.promptWithCancel({
             type: 'select',
             name: 'template',
             message: 'Select a workflow template.',
@@ -1220,9 +1745,9 @@ export class CliUtilityInitialize {
                 action: 'back',
             };
         }
-        const templateOutputResult = templateOutput['result'];
-        const selectedTemplate = templateOutputResult.template;
-        const suffixOutput = await CliUtilityInitialize.promptWithCancel({
+        const templateOutputResultValue = templateOutput['result'];
+        const selectedTemplate = templateOutputResultValue.template;
+        const suffixOutput = await Runner.promptWithCancel({
             type: 'text',
             name: 'suffix',
             message: 'Workflow suffix (used in filename and workflow name)',
@@ -1252,8 +1777,8 @@ export class CliUtilityInitialize {
                 action: 'back',
             };
         }
-        const suffixOutputResult = suffixOutput['result'];
-        const selectedSuffix = (typeof suffixOutputResult.suffix === 'string') ? suffixOutputResult.suffix.trim() : '';
+        const suffixOutputResultValue = suffixOutput['result'];
+        const selectedSuffix = (typeof suffixOutputResultValue.suffix === 'string') ? suffixOutputResultValue.suffix.trim() : '';
         const triggersDir = join(resolveTemplatePath(import.meta.url, 'generators/github/workflows'), selectedTemplate, 'triggers');
         const triggersDirExists = await pathExists(triggersDir);
         let selectedTriggers = [];
@@ -1267,7 +1792,7 @@ export class CliUtilityInitialize {
                     selected: existingTriggers.includes(triggerName),
                 };
             });
-            const triggersOutput = await CliUtilityInitialize.promptWithCancel({
+            const triggersOutput = await Runner.promptWithCancel({
                 type: 'multiselect',
                 name: 'triggers',
                 message: 'Select triggers for this workflow.',
@@ -1278,12 +1803,12 @@ export class CliUtilityInitialize {
                     action: 'back',
                 };
             }
-            const triggersOutputResult = triggersOutput['result'];
-            selectedTriggers = (Array.isArray(triggersOutputResult.triggers) === true) ? triggersOutputResult.triggers : [];
+            const triggersOutputResultValue = triggersOutput['result'];
+            selectedTriggers = (Array.isArray(triggersOutputResultValue.triggers) === true) ? triggersOutputResultValue.triggers : [];
             const scheduleVariants = selectedTriggers.filter((trigger) => trigger.startsWith('schedule-'));
             if (scheduleVariants.length > 1) {
                 Logger.customize({
-                    name: 'CliUtilityInitialize.promptWorkflowsForm',
+                    name: 'Runner.promptWorkflowsForm',
                     purpose: 'validation',
                     padTop: 1,
                     padBottom: 1,
@@ -1300,15 +1825,15 @@ export class CliUtilityInitialize {
                 && typeof w['template'] === 'string'
                 && w['template'].trim() !== '')
                 .map((w) => {
-                const compositeKey = (typeof w['suffix'] === 'string' && w['suffix'].trim() !== '') ? `${w['template']}-${w['suffix']}` : w['template'];
+                const dependsOnKey = (typeof w['suffix'] === 'string' && w['suffix'].trim() !== '') ? `${w['template']}-${w['suffix']}` : w['template'];
                 return {
-                    title: compositeKey,
-                    value: compositeKey,
-                    selected: existingDependsOn.includes(compositeKey),
+                    title: dependsOnKey,
+                    value: dependsOnKey,
+                    selected: existingDependsOn.includes(dependsOnKey),
                 };
             });
             if (dependsOnChoices.length > 0) {
-                const dependsOnOutput = await CliUtilityInitialize.promptWithCancel({
+                const dependsOnOutput = await Runner.promptWithCancel({
                     type: 'multiselect',
                     name: 'dependsOn',
                     message: 'Select the workflows this depends on.',
@@ -1319,8 +1844,8 @@ export class CliUtilityInitialize {
                         action: 'back',
                     };
                 }
-                const dependsOnOutputResult = dependsOnOutput['result'];
-                selectedDependsOn = (Array.isArray(dependsOnOutputResult.dependsOn) === true && dependsOnOutputResult.dependsOn.length > 0) ? dependsOnOutputResult.dependsOn : undefined;
+                const dependsOnOutputResultValue = dependsOnOutput['result'];
+                selectedDependsOn = (Array.isArray(dependsOnOutputResultValue.dependsOn) === true && dependsOnOutputResultValue.dependsOn.length > 0) ? dependsOnOutputResultValue.dependsOn : undefined;
             }
         }
         const matchedMetadata = libWorkflowTemplatesMetadata.find((entry) => entry['name'] === selectedTemplate);
@@ -1365,7 +1890,7 @@ export class CliUtilityInitialize {
                         kind: 'done',
                     },
                 });
-                const targetMenuOutput = await CliUtilityInitialize.promptWithCancel({
+                const targetMenuOutput = await Runner.promptWithCancel({
                     type: 'select',
                     name: 'targetAction',
                     message: (selectedTargets.length > 0) ? 'Select a target to manage.' : 'No targets added yet. Choose an option.',
@@ -1376,8 +1901,8 @@ export class CliUtilityInitialize {
                         action: 'back',
                     };
                 }
-                const targetMenuOutputResult = targetMenuOutput['result'];
-                const targetMenuAction = targetMenuOutputResult.targetAction;
+                const targetMenuOutputResultValue = targetMenuOutput['result'];
+                const targetMenuAction = targetMenuOutputResultValue.targetAction;
                 if (targetMenuAction['kind'] === 'done') {
                     break;
                 }
@@ -1396,7 +1921,7 @@ export class CliUtilityInitialize {
                         title: availableTargetType,
                         value: availableTargetType,
                     }));
-                    const targetTypeOutput = await CliUtilityInitialize.promptWithCancel({
+                    const targetTypeOutput = await Runner.promptWithCancel({
                         type: 'select',
                         name: 'targetType',
                         message: 'Select a target type.',
@@ -1406,14 +1931,14 @@ export class CliUtilityInitialize {
                     if (targetTypeOutput['cancelled'] === true) {
                         continue;
                     }
-                    const targetTypeOutputResult = targetTypeOutput['result'];
-                    const selectedTargetType = targetTypeOutputResult.targetType;
+                    const targetTypeOutputResultValue = targetTypeOutput['result'];
+                    const selectedTargetType = targetTypeOutputResultValue.targetType;
                     const targetWorkingDirInitial = (targetToEdit !== undefined) ? workspaceKeys.indexOf(targetToEdit['workingDir']) : 0;
                     const targetWorkingDirChoices = workspaceKeys.map((workspaceKey) => ({
                         title: workspaceKey,
                         value: workspaceKey,
                     }));
-                    const targetWorkingDirOutput = await CliUtilityInitialize.promptWithCancel({
+                    const targetWorkingDirOutput = await Runner.promptWithCancel({
                         type: 'select',
                         name: 'targetWorkingDir',
                         message: 'Select a working directory.',
@@ -1423,8 +1948,8 @@ export class CliUtilityInitialize {
                     if (targetWorkingDirOutput['cancelled'] === true) {
                         continue;
                     }
-                    const targetWorkingDirOutputResult = targetWorkingDirOutput['result'];
-                    const selectedTargetWorkingDir = targetWorkingDirOutputResult.targetWorkingDir;
+                    const targetWorkingDirOutputResultValue = targetWorkingDirOutput['result'];
+                    const selectedTargetWorkingDir = targetWorkingDirOutputResultValue.targetWorkingDir;
                     const targetIsDuplicate = selectedTargets.some((selectedTarget, selectedTargetIndex) => {
                         if (selectedTargetIndex === targetEditIndex) {
                             return false;
@@ -1433,7 +1958,7 @@ export class CliUtilityInitialize {
                     });
                     if (targetIsDuplicate === true) {
                         Logger.customize({
-                            name: 'CliUtilityInitialize.promptWorkflowsForm',
+                            name: 'Runner.promptWorkflowsForm',
                             purpose: 'validation',
                             padTop: 1,
                             padBottom: 1,
@@ -1454,7 +1979,7 @@ export class CliUtilityInitialize {
                         selected: targetToEditExistingNeeds.includes(candidate['workingDir']),
                     }));
                     if (targetNeedsChoices.length > 0) {
-                        const targetNeedsOutput = await CliUtilityInitialize.promptWithCancel({
+                        const targetNeedsOutput = await Runner.promptWithCancel({
                             type: 'multiselect',
                             name: 'targetNeeds',
                             message: 'Select targets this must wait for before publishing (optional).',
@@ -1463,8 +1988,8 @@ export class CliUtilityInitialize {
                         if (targetNeedsOutput['cancelled'] === true) {
                             continue;
                         }
-                        const targetNeedsOutputResult = targetNeedsOutput['result'];
-                        selectedTargetNeeds = (Array.isArray(targetNeedsOutputResult.targetNeeds) === true && targetNeedsOutputResult.targetNeeds.length > 0) ? targetNeedsOutputResult.targetNeeds : undefined;
+                        const targetNeedsOutputResultValue = targetNeedsOutput['result'];
+                        selectedTargetNeeds = (Array.isArray(targetNeedsOutputResultValue.targetNeeds) === true && targetNeedsOutputResultValue.targetNeeds.length > 0) ? targetNeedsOutputResultValue.targetNeeds : undefined;
                     }
                     const newTarget = {
                         type: selectedTargetType,
@@ -1494,7 +2019,7 @@ export class CliUtilityInitialize {
                     value: workspaceKey,
                     selected: existingScopes.includes(workspaceKey),
                 }));
-                const scopesOutput = await CliUtilityInitialize.promptWithCancel({
+                const scopesOutput = await Runner.promptWithCancel({
                     type: 'multiselect',
                     name: 'scopes',
                     message: 'Select any EXTRA workspaces to check and build for this workflow.',
@@ -1505,8 +2030,8 @@ export class CliUtilityInitialize {
                         action: 'back',
                     };
                 }
-                const scopesOutputResult = scopesOutput['result'];
-                const extraScopes = (Array.isArray(scopesOutputResult.scopes) === true) ? scopesOutputResult.scopes : [];
+                const scopesOutputResultValue = scopesOutput['result'];
+                const extraScopes = (Array.isArray(scopesOutputResultValue.scopes) === true) ? scopesOutputResultValue.scopes : [];
                 for (const extraScope of extraScopes) {
                     if (selectedScopes.includes(extraScope) === false) {
                         selectedScopes.push(extraScope);
@@ -1517,8 +2042,10 @@ export class CliUtilityInitialize {
         const settings = {};
         if (matchedMetadata !== undefined) {
             const mergedVariables = { ...matchedMetadata['variables'] };
+            const variableNameToTargetWorkingDir = {};
             for (const selectedTarget of selectedTargets) {
                 const targetType = selectedTarget['type'];
+                const targetWorkingDir = selectedTarget['workingDir'];
                 const targetMetadata = matchedMetadata['targets'] ?? {};
                 const targetVariables = (targetMetadata[targetType] !== undefined) ? targetMetadata[targetType]['variables'] : {};
                 const targetVarEntries = Object.entries(targetVariables);
@@ -1529,6 +2056,13 @@ export class CliUtilityInitialize {
                         Reflect.set(mergedVariables, targetVarKey, targetVarValue);
                     }
                 }
+                const targetVariableNames = Object.keys(targetVariables);
+                for (const targetVariableName of targetVariableNames) {
+                    const targetVariableNameKey = targetVariableName;
+                    if (variableNameToTargetWorkingDir[targetVariableNameKey] === undefined) {
+                        Reflect.set(variableNameToTargetWorkingDir, targetVariableNameKey, targetWorkingDir);
+                    }
+                }
             }
             const variableEntries = Object.entries(mergedVariables);
             for (const variableEntry of variableEntries) {
@@ -1551,8 +2085,14 @@ export class CliUtilityInitialize {
                 if (typeof variableConfig['description'] === 'string') {
                     parts.push(variableConfig['description']);
                 }
-                if (typeof variableConfig['example'] === 'string') {
-                    parts.push(`e.g. ${variableConfig['example']}`);
+                const exampleRaw = variableConfig['example'];
+                const exampleWorkingDir = variableNameToTargetWorkingDir[variableName];
+                let exampleResolved = exampleRaw;
+                if (typeof exampleResolved === 'string' && typeof exampleWorkingDir === 'string') {
+                    exampleResolved = exampleResolved.replaceAll('{workingDir}', exampleWorkingDir);
+                }
+                if (typeof exampleResolved === 'string') {
+                    parts.push(`e.g. ${exampleResolved}`);
                 }
                 if (parts.length > 0) {
                     promptMessage = `${promptMessage} (${parts.join(', ')})`;
@@ -1562,19 +2102,20 @@ export class CliUtilityInitialize {
                     && typeof workflow['settings'][variableName] === 'string') {
                     initialValue = workflow['settings'][variableName];
                 }
-                const settingsOutput = await CliUtilityInitialize.promptWithCancel({
+                const settingsOutput = await Runner.promptWithCancel({
                     type: 'text',
                     name: 'settingValue',
                     message: promptMessage,
                     initial: initialValue,
+                    validate: (variableConfig['format'] === 'literal') ? Runner['isNonEmptyLiteralInput'] : undefined,
                 });
                 if (settingsOutput['cancelled'] === true) {
                     return {
                         action: 'back',
                     };
                 }
-                const settingsOutputResult = settingsOutput['result'];
-                const settingValue = (typeof settingsOutputResult.settingValue === 'string') ? settingsOutputResult.settingValue.trim().replaceAll('\\n', '\n') : '';
+                const settingsOutputResultValue = settingsOutput['result'];
+                const settingValue = (typeof settingsOutputResultValue.settingValue === 'string') ? settingsOutputResultValue.settingValue.trim().replaceAll('\\n', '\n') : '';
                 if (settingValue !== '') {
                     Reflect.set(settings, variableName, settingValue);
                 }
@@ -1608,7 +2149,7 @@ export class CliUtilityInitialize {
         };
     }
     static async promptWorkflowsDeleteForm(label) {
-        const confirmOutput = await CliUtilityInitialize.promptWithCancel({
+        const confirmOutput = await Runner.promptWithCancel({
             type: 'confirm',
             name: 'confirm',
             message: `Remove workflow "${label}"?`,
@@ -1632,7 +2173,7 @@ export class CliUtilityInitialize {
             return `./${relativePath.split(sep).join('/')}`;
         });
         Logger.customize({
-            name: 'CliUtilityInitialize.promptWorkspaces',
+            name: 'Runner.promptWorkspaces',
             purpose: 'paths',
         }).debug(workspacePaths);
         while (true) {
@@ -1659,7 +2200,7 @@ export class CliUtilityInitialize {
                 description: 'Return to the category selection.',
                 value: 'back',
             });
-            const menuOutput = await CliUtilityInitialize.promptWithCancel({
+            const menuOutput = await Runner.promptWithCancel({
                 type: 'select',
                 name: 'workspacePath',
                 message: 'Select a workspace to configure.',
@@ -1674,7 +2215,7 @@ export class CliUtilityInitialize {
                 return 'back';
             }
             const workspacePath = menuOutputResult.workspacePath;
-            const formResult = await CliUtilityInitialize.promptWorkspacesForm({
+            const formResult = await Runner.promptWorkspacesForm({
                 workspacePath,
                 existingWorkspace: workspaces[workspacePath],
                 projectSlug: (config['project'] !== undefined && config['project']['name'] !== undefined) ? config['project']['name']['slug'] : undefined,
@@ -1685,7 +2226,7 @@ export class CliUtilityInitialize {
             Reflect.set(workspaces, workspacePath, formResult['workspace']);
             Object.assign(config, { workspaces });
             Logger.customize({
-                name: 'CliUtilityInitialize.promptWorkspaces',
+                name: 'Runner.promptWorkspaces',
                 purpose: 'updated',
                 padTop: 1,
                 padBottom: 1,
@@ -1752,20 +2293,23 @@ export class CliUtilityInitialize {
                 return `${options['projectSlug']}-${role}`;
             }
             const base = (options['projectSlug'] !== undefined) ? `${options['projectSlug']}-${role}` : role;
-            const namePrompt = await CliUtilityInitialize.promptWithCancel({
+            const validateWorkspaceName = (workspaceNameValue) => {
+                return Runner.normalizeWorkspaceName(workspaceNameValue, role, base)['result'];
+            };
+            const namePrompt = await Runner.promptWithCancel({
                 type: 'text',
                 name: 'workspaceName',
                 message: 'Workspace package name',
                 initial: (options['existingWorkspace'] !== undefined) ? options['existingWorkspace']['name'] ?? '' : '',
-                validate: (value) => CliUtilityInitialize.normalizeWorkspaceName(value, role, base)['result'],
+                validate: validateWorkspaceName,
             });
             if (namePrompt['cancelled'] === true) {
                 return undefined;
             }
-            return CliUtilityInitialize.normalizeWorkspaceName(namePrompt['result'].workspaceName, role, base)['sanitized'];
+            return Runner.normalizeWorkspaceName(namePrompt['result'].workspaceName, role, base)['sanitized'];
         };
         const existingRoleIndex = allowedRoles.findIndex((allowedRole) => options['existingWorkspace'] !== undefined && allowedRole['value'] === options['existingWorkspace']['role']);
-        const rolePrompt = await CliUtilityInitialize.promptWithCancel({
+        const rolePrompt = await Runner.promptWithCancel({
             type: 'select',
             name: 'workspaceRole',
             message: `Select a role for "${options['workspacePath']}"`,
@@ -1786,7 +2330,7 @@ export class CliUtilityInitialize {
         const selectedRole = rolePrompt['result'].workspaceRole;
         const allowedPolicies = libItemAllowedPoliciesByRole[selectedRole];
         const existingPolicyIndex = allowedPolicies.findIndex((allowedPolicy) => options['existingWorkspace'] !== undefined && allowedPolicy === options['existingWorkspace']['policy']);
-        const policyPrompt = await CliUtilityInitialize.promptWithCancel({
+        const policyPrompt = await Runner.promptWithCancel({
             type: 'select',
             name: 'workspacePolicy',
             message: 'Select a policy',
@@ -1812,8 +2356,24 @@ export class CliUtilityInitialize {
                 action: 'back',
             };
         }
+        const validateWorkspaceDisplayName = (workspaceDisplayNameValue) => {
+            return Runner.normalizeText(workspaceDisplayNameValue, Infinity)['result'];
+        };
+        const displayNamePrompt = await Runner.promptWithCancel({
+            type: 'text',
+            name: 'workspaceDisplayName',
+            message: 'Workspace display name (optional)',
+            initial: (options['existingWorkspace'] !== undefined) ? options['existingWorkspace']['displayName'] ?? '' : '',
+            validate: validateWorkspaceDisplayName,
+        });
+        if (displayNamePrompt['cancelled'] === true) {
+            return {
+                action: 'back',
+            };
+        }
+        const workspaceDisplayNameInput = Runner.normalizeText(displayNamePrompt['result'].workspaceDisplayName, Infinity)['sanitized'];
         const existingRecipes = (options['existingWorkspace'] !== undefined && options['existingWorkspace']['recipes'] !== undefined) ? options['existingWorkspace']['recipes'] : undefined;
-        const recipesPrompt = await CliUtilityInitialize.promptWithCancel({
+        const recipesPrompt = await Runner.promptWithCancel({
             type: 'multiselect',
             name: 'workspaceRecipes',
             message: 'Select recipes to enable',
@@ -1841,7 +2401,7 @@ export class CliUtilityInitialize {
             const existingTuple = (Array.isArray(existingTupleRaw) === true) ? existingTupleRaw : undefined;
             const existingSettings = (existingTuple !== undefined && existingTuple.length > 1) ? existingTuple[1] : undefined;
             if (recipe === 'sync-identity' && selectedPolicy === 'distributable') {
-                const settingsPrompt = await CliUtilityInitialize.promptWithCancel({
+                const identitySettingsPrompt = await Runner.promptWithCancel({
                     type: 'multiselect',
                     name: 'workspaceRecipeSettings',
                     message: 'sync-identity: Select properties to sync',
@@ -1858,20 +2418,20 @@ export class CliUtilityInitialize {
                         },
                     ],
                 });
-                if (settingsPrompt['cancelled'] === true) {
+                if (identitySettingsPrompt['cancelled'] === true) {
                     return {
                         action: 'back',
                     };
                 }
-                const selectedSettings = settingsPrompt['result'].workspaceRecipeSettings;
-                if (selectedSettings.length > 0) {
-                    const settings = {};
-                    for (const setting of selectedSettings) {
-                        Reflect.set(settings, setting, true);
+                const identitySelectedSettings = identitySettingsPrompt['result'].workspaceRecipeSettings;
+                if (identitySelectedSettings.length > 0) {
+                    const identitySettings = {};
+                    for (const setting of identitySelectedSettings) {
+                        Reflect.set(identitySettings, setting, true);
                     }
                     Reflect.set(recipes, recipe, [
                         true,
-                        settings,
+                        identitySettings,
                     ]);
                 }
                 else {
@@ -1879,7 +2439,7 @@ export class CliUtilityInitialize {
                 }
             }
             else if (recipe === 'sync-ownership' && selectedPolicy === 'distributable') {
-                const settingsPrompt = await CliUtilityInitialize.promptWithCancel({
+                const ownershipSettingsPrompt = await Runner.promptWithCancel({
                     type: 'multiselect',
                     name: 'workspaceRecipeSettings',
                     message: 'sync-ownership: Select properties to sync',
@@ -1916,20 +2476,20 @@ export class CliUtilityInitialize {
                         },
                     ],
                 });
-                if (settingsPrompt['cancelled'] === true) {
+                if (ownershipSettingsPrompt['cancelled'] === true) {
                     return {
                         action: 'back',
                     };
                 }
-                const selectedSettings = settingsPrompt['result'].workspaceRecipeSettings;
-                if (selectedSettings.length > 0) {
-                    const settings = {};
-                    for (const setting of selectedSettings) {
-                        Reflect.set(settings, setting, true);
+                const ownershipSelectedSettings = ownershipSettingsPrompt['result'].workspaceRecipeSettings;
+                if (ownershipSelectedSettings.length > 0) {
+                    const ownershipSettings = {};
+                    for (const setting of ownershipSelectedSettings) {
+                        Reflect.set(ownershipSettings, setting, true);
                     }
                     Reflect.set(recipes, recipe, [
                         true,
-                        settings,
+                        ownershipSettings,
                     ]);
                 }
                 else {
@@ -1937,7 +2497,7 @@ export class CliUtilityInitialize {
                 }
             }
             else if (recipe === 'sync-environment') {
-                const settingsPrompt = await CliUtilityInitialize.promptWithCancel({
+                const environmentSettingsPrompt = await Runner.promptWithCancel({
                     type: 'multiselect',
                     name: 'workspaceRecipeSettings',
                     message: 'sync-environment: Select settings',
@@ -1947,20 +2507,20 @@ export class CliUtilityInitialize {
                             selected: existingSettings !== undefined && existingSettings['trackNodeLtsVersions'] === true,
                         }],
                 });
-                if (settingsPrompt['cancelled'] === true) {
+                if (environmentSettingsPrompt['cancelled'] === true) {
                     return {
                         action: 'back',
                     };
                 }
-                const selectedSettings = settingsPrompt['result'].workspaceRecipeSettings;
-                if (selectedSettings.length > 0) {
-                    const settings = {};
-                    for (const setting of selectedSettings) {
-                        Reflect.set(settings, setting, true);
+                const environmentSelectedSettings = environmentSettingsPrompt['result'].workspaceRecipeSettings;
+                if (environmentSelectedSettings.length > 0) {
+                    const environmentSettings = {};
+                    for (const setting of environmentSelectedSettings) {
+                        Reflect.set(environmentSettings, setting, true);
                     }
                     Reflect.set(recipes, recipe, [
                         true,
-                        settings,
+                        environmentSettings,
                     ]);
                 }
                 else {
@@ -1968,7 +2528,7 @@ export class CliUtilityInitialize {
                 }
             }
             else if (recipe === 'cleanup') {
-                const settingsPrompt = await CliUtilityInitialize.promptWithCancel({
+                const cleanupSettingsPrompt = await Runner.promptWithCancel({
                     type: 'multiselect',
                     name: 'workspaceRecipeSettings',
                     message: 'cleanup: Select settings',
@@ -1985,20 +2545,20 @@ export class CliUtilityInitialize {
                         },
                     ],
                 });
-                if (settingsPrompt['cancelled'] === true) {
+                if (cleanupSettingsPrompt['cancelled'] === true) {
                     return {
                         action: 'back',
                     };
                 }
-                const selectedSettings = settingsPrompt['result'].workspaceRecipeSettings;
-                if (selectedSettings.length > 0) {
-                    const settings = {};
-                    for (const setting of selectedSettings) {
-                        Reflect.set(settings, setting, true);
+                const cleanupSelectedSettings = cleanupSettingsPrompt['result'].workspaceRecipeSettings;
+                if (cleanupSelectedSettings.length > 0) {
+                    const cleanupSettings = {};
+                    for (const setting of cleanupSelectedSettings) {
+                        Reflect.set(cleanupSettings, setting, true);
                     }
                     Reflect.set(recipes, recipe, [
                         true,
-                        settings,
+                        cleanupSettings,
                     ]);
                 }
                 else {
@@ -2006,7 +2566,7 @@ export class CliUtilityInitialize {
                 }
             }
             else if (recipe === 'normalize-dependencies') {
-                const settingsPrompt = await CliUtilityInitialize.promptWithCancel({
+                const dependenciesSettingsPrompt = await Runner.promptWithCancel({
                     type: 'multiselect',
                     name: 'workspaceRecipeSettings',
                     message: 'normalize-dependencies: Select settings',
@@ -2023,20 +2583,20 @@ export class CliUtilityInitialize {
                         },
                     ],
                 });
-                if (settingsPrompt['cancelled'] === true) {
+                if (dependenciesSettingsPrompt['cancelled'] === true) {
                     return {
                         action: 'back',
                     };
                 }
-                const selectedSettings = settingsPrompt['result'].workspaceRecipeSettings;
-                if (selectedSettings.length > 0) {
-                    const settings = {};
-                    for (const setting of selectedSettings) {
-                        Reflect.set(settings, setting, true);
+                const dependenciesSelectedSettings = dependenciesSettingsPrompt['result'].workspaceRecipeSettings;
+                if (dependenciesSelectedSettings.length > 0) {
+                    const dependenciesSettings = {};
+                    for (const setting of dependenciesSelectedSettings) {
+                        Reflect.set(dependenciesSettings, setting, true);
                     }
                     Reflect.set(recipes, recipe, [
                         true,
-                        settings,
+                        dependenciesSettings,
                     ]);
                 }
                 else {
@@ -2051,6 +2611,7 @@ export class CliUtilityInitialize {
             action: 'apply',
             workspace: {
                 name: resolvedName,
+                ...(workspaceDisplayNameInput !== undefined) ? { displayName: workspaceDisplayNameInput } : {},
                 role: selectedRole,
                 policy: selectedPolicy,
                 ...(Object.keys(recipes).length > 0) ? { recipes } : {},
@@ -2078,7 +2639,7 @@ export class CliUtilityInitialize {
     static async checkPath(currentDirectory) {
         const locations = await discoverPathsWithFile('package.json', 'backward');
         Logger.customize({
-            name: 'CliUtilityInitialize.checkPath',
+            name: 'Runner.checkPath',
             purpose: 'detectedLocations',
         }).debug(locations);
         if (locations.length < 1) {
@@ -2087,7 +2648,7 @@ export class CliUtilityInitialize {
                 `Current directory is "${currentDirectory}"`,
             ].join('\n');
             Logger.customize({
-                name: 'CliUtilityInitialize.checkPath',
+                name: 'Runner.checkPath',
                 purpose: 'lessThanOne',
             }).error(lessThanOneMessage);
             return false;
@@ -2098,7 +2659,7 @@ export class CliUtilityInitialize {
                 `Current directory is "${currentDirectory}"`,
             ].join('\n');
             Logger.customize({
-                name: 'CliUtilityInitialize.checkPath',
+                name: 'Runner.checkPath',
                 purpose: 'greaterThanOne',
             }).error(greaterThanOneMessage);
             return false;
@@ -2109,7 +2670,7 @@ export class CliUtilityInitialize {
                 `Current directory is "${currentDirectory}"`,
             ].join('\n');
             Logger.customize({
-                name: 'CliUtilityInitialize.checkPath',
+                name: 'Runner.checkPath',
                 purpose: 'notProjectRootDirectory',
             }).error(notProjectRootDirectoryMessage);
             return false;
@@ -2211,7 +2772,7 @@ export class CliUtilityInitialize {
             .map((item) => item.trim())
             .filter((item) => item !== '');
         for (let i = 0; i < items.length; i += 1) {
-            const normalizedText = CliUtilityInitialize.normalizeText(items[i], maxLengthPerItem);
+            const normalizedText = Runner.normalizeText(items[i], maxLengthPerItem);
             const result = normalizedText['result'];
             const sanitized = normalizedText['sanitized'];
             if (result !== true) {
@@ -2300,7 +2861,7 @@ export class CliUtilityInitialize {
             .map((item) => item.trim())
             .filter((item) => item !== '');
         for (let i = 0; i < items.length; i += 1) {
-            const normalizedUrl = CliUtilityInitialize.normalizeUrl(items[i], protocol);
+            const normalizedUrl = Runner.normalizeUrl(items[i], protocol);
             const result = normalizedUrl['result'];
             const sanitized = normalizedUrl['sanitized'];
             if (result !== true) {