@cbnventures/nova 0.12.0 → 0.13.0

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

@@ -1,7 +1,7 @@
-import * as path from 'path';
+import { relative, sep } from 'path';
 import chalk from 'chalk';
 import prompts from 'prompts';
-import { itemAllowedPoliciesByRole } from '../../lib/item.js';
+import { itemAllowedPoliciesByRole, itemAllowedSyncProperties } from '../../lib/item.js';
 import { NovaConfig } from '../../lib/nova-config.js';
 import { PATTERN_EMAIL_SIMPLE, PATTERN_SLUG_SCOPED, PATTERN_SLUG_SIMPLE } from '../../lib/regex.js';
 import { discoverPathsWithFile } from '../../lib/utility.js';
@@ -10,17 +10,25 @@ export class CLIUtilityInitialize {
     static async run(options) {
         const currentDirectory = process.cwd();
         const isProjectRoot = await CLIUtilityInitialize.checkPath(currentDirectory);
-        if (!isProjectRoot) {
+        if (isProjectRoot !== true) {
             process.exitCode = 1;
             return;
         }
-        if (options.dryRun === true) {
+        const isDryRun = options.dryRun === true;
+        const isReplaceFile = options.replaceFile === true;
+        if (isDryRun === true) {
             Logger.customize({
                 name: 'CLIUtilityInitialize.run',
                 purpose: 'options',
-                padBottom: 1,
             }).warn('Dry run enabled. File changes will not be made in this session.');
         }
+        if (isReplaceFile === true) {
+            const replaceFileNotice = (isDryRun) ? 'This option has no effect during a dry run session.' : 'Backup file will not be created.';
+            Logger.customize({
+                name: 'CLIUtilityInitialize.run',
+                purpose: 'options',
+            }).warn(`Replace file enabled. ${replaceFileNotice}`);
+        }
         const novaConfig = new NovaConfig();
         const workingFile = await novaConfig.load();
         const promptFlowResult = await CLIUtilityInitialize.promptFlow(workingFile);
@@ -28,22 +36,18 @@ export class CLIUtilityInitialize {
             Logger.customize({
                 name: 'CLIUtilityInitialize.run',
                 purpose: 'promptFlow',
-                padTop: 1,
-                padBottom: 1,
             }).debug('Prompt flow exited without saving.');
             return;
         }
         novaConfig.set(workingFile);
-        if (options.dryRun === true) {
+        if (isDryRun === true) {
             Logger.customize({
                 name: 'CLIUtilityInitialize.run',
                 purpose: 'promptFlow',
-                padTop: 1,
-                padBottom: 1,
             }).debug('Dry run enabled. Skipping save operation.');
             return;
         }
-        await novaConfig.save();
+        await novaConfig.save(isReplaceFile);
     }
     static async promptFlow(config) {
         const category = {
@@ -57,9 +61,14 @@ export class CLIUtilityInitialize {
                 description: 'Manage entities, their roles, and contact information.',
                 handler: CLIUtilityInitialize.promptEntities,
             },
+            emails: {
+                label: 'Emails',
+                description: 'Configure project emails (bugs, etc.).',
+                handler: CLIUtilityInitialize.promptEmails,
+            },
             urls: {
                 label: 'URLs',
-                description: 'Set URLs for docs, repo, support, and funding sources.',
+                description: 'Configure project URLs (homepage, repository, fund sources, etc.).',
                 handler: CLIUtilityInitialize.promptUrls,
             },
             workspaces: {
@@ -109,89 +118,88 @@ export class CLIUtilityInitialize {
     }
     static async promptProject(config) {
         const existingProject = config.project;
-        const existingProjectName = existingProject?.name;
-        const existingProjectDescription = existingProject?.description;
-        const existingProjectKeywords = existingProject?.keywords;
+        const existingProjectName = (existingProject !== undefined) ? existingProject.name : undefined;
+        const existingProjectDescription = (existingProject !== undefined) ? existingProject.description : undefined;
+        const existingProjectKeywords = (existingProject !== undefined) ? existingProject.keywords : undefined;
         const project = (existingProject !== undefined) ? { ...existingProject } : {};
         const projectName = (existingProjectName !== undefined) ? { ...existingProjectName } : {};
         const projectDescription = (existingProjectDescription !== undefined) ? { ...existingProjectDescription } : {};
+        const projectKeywords = (existingProjectKeywords !== undefined) ? [...existingProjectKeywords] : [];
         const questionsOutput = await CLIUtilityInitialize.promptWithCancel([
             {
                 type: 'text',
                 name: 'projectNameTitle',
                 message: 'Project title (display name)',
                 initial: projectName.title ?? '',
+                validate: (value) => CLIUtilityInitialize.normalizeText(value, Infinity).result,
             },
             {
                 type: 'text',
                 name: 'projectNameSlug',
                 message: 'Project slug (package name)',
                 initial: projectName.slug ?? '',
-                validate: (value) => {
-                    const trimmed = value.trim();
-                    if (trimmed === '' || new RegExp(PATTERN_SLUG_SIMPLE, 'i').test(trimmed)) {
-                        return true;
-                    }
-                    return 'Use letters, numbers, hyphens, and underscores only.';
-                },
+                validate: (value) => CLIUtilityInitialize.normalizeProjectSlug(value).result,
             },
             {
                 type: 'text',
                 name: 'projectDescriptionShort',
                 message: 'Short description',
                 initial: projectDescription.short ?? '',
+                validate: (value) => CLIUtilityInitialize.normalizeText(value, Infinity).result,
             },
             {
                 type: 'text',
                 name: 'projectDescriptionLong',
                 message: 'Long description',
                 initial: projectDescription.long ?? '',
+                validate: (value) => CLIUtilityInitialize.normalizeText(value, Infinity).result,
             },
             {
                 type: 'text',
                 name: 'projectKeywords',
                 message: 'Keywords (comma separated)',
-                initial: (Array.isArray(existingProjectKeywords)) ? existingProjectKeywords.join(', ') : '',
+                initial: (projectKeywords.length > 0) ? projectKeywords.join(', ') : '',
+                validate: (value) => CLIUtilityInitialize.normalizeTextArray(value, 50).result,
             },
         ]);
         if (questionsOutput.cancelled) {
             return 'back';
         }
         const questionsOutputResult = questionsOutput.result;
-        const projectNameTitleInput = (questionsOutputResult.projectNameTitle ?? '').trim();
-        const projectNameSlugInput = (questionsOutputResult.projectNameSlug ?? '').trim();
-        const projectDescriptionShortInput = (questionsOutputResult.projectDescriptionShort ?? '').trim();
-        const projectDescriptionLongInput = (questionsOutputResult.projectDescriptionLong ?? '').trim();
-        const projectKeywordsInput = (questionsOutputResult.projectKeywords ?? '').trim();
-        if (projectNameTitleInput === '') {
-            Reflect.deleteProperty(projectName, 'title');
+        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;
+        if (projectNameTitleInput !== undefined) {
+            projectName.title = projectNameTitleInput;
         }
         else {
-            projectName.title = projectNameTitleInput;
+            Reflect.deleteProperty(projectName, 'title');
         }
-        if (projectNameSlugInput === '') {
-            Reflect.deleteProperty(projectName, 'slug');
+        if (projectNameSlugInput !== undefined) {
+            projectName.slug = projectNameSlugInput;
         }
         else {
-            projectName.slug = projectNameSlugInput;
+            Reflect.deleteProperty(projectName, 'slug');
         }
-        if (projectDescriptionShortInput === '') {
-            Reflect.deleteProperty(projectDescription, 'short');
+        if (Object.keys(projectName).length > 0) {
+            project.name = projectName;
         }
         else {
-            projectDescription.short = projectDescriptionShortInput;
+            Reflect.deleteProperty(project, 'name');
         }
-        if (projectDescriptionLongInput === '') {
-            Reflect.deleteProperty(projectDescription, 'long');
+        if (projectDescriptionShortInput !== undefined) {
+            projectDescription.short = projectDescriptionShortInput;
         }
         else {
-            projectDescription.long = projectDescriptionLongInput;
+            Reflect.deleteProperty(projectDescription, 'short');
         }
-        if (Object.keys(projectName).length > 0) {
-            project.name = projectName;
+        if (projectDescriptionLongInput !== undefined) {
+            projectDescription.long = projectDescriptionLongInput;
         }
         else {
-            Reflect.deleteProperty(project, 'name');
+            Reflect.deleteProperty(projectDescription, 'long');
         }
         if (Object.keys(projectDescription).length > 0) {
             project.description = projectDescription;
@@ -199,20 +207,11 @@ export class CLIUtilityInitialize {
         else {
             Reflect.deleteProperty(project, 'description');
         }
-        if (projectKeywordsInput === '') {
-            Reflect.deleteProperty(project, 'keywords');
+        if (projectKeywordsInput !== undefined && projectKeywordsInput.length > 0) {
+            project.keywords = projectKeywordsInput;
         }
         else {
-            const projectKeywordsList = projectKeywordsInput
-                .split(',')
-                .map((projectKeywordInput) => projectKeywordInput.trim())
-                .filter((projectKeywordInput) => projectKeywordInput !== '');
-            if (projectKeywordsList.length > 0) {
-                project.keywords = projectKeywordsList;
-            }
-            else {
-                Reflect.deleteProperty(project, 'keywords');
-            }
+            Reflect.deleteProperty(project, 'keywords');
         }
         if (Object.keys(project).length > 0) {
             Object.assign(config, { project });
@@ -220,8 +219,8 @@ export class CLIUtilityInitialize {
         else {
             Reflect.deleteProperty(config, 'project');
         }
-        const previousSlug = existingProjectName?.slug ?? '';
-        const currentSlug = config.project?.name?.slug ?? '';
+        const previousSlug = (existingProjectName !== undefined) ? existingProjectName.slug ?? '' : '';
+        const currentSlug = (config.project !== undefined && config.project.name !== undefined) ? config.project.name.slug ?? '' : '';
         const slugChanged = previousSlug !== currentSlug;
         if (slugChanged && config.workspaces !== undefined) {
             const rolesToSync = ['project', 'docs', 'config', 'app', 'tool'];
@@ -411,7 +410,7 @@ export class CLIUtilityInitialize {
                 const entityEmail = (typeof entityToRemove.email === 'string') ? entityToRemove.email.trim() : '';
                 const entityLabel = entityName || entityEmail || `Entity ${entityIndex + 1}`;
                 const shouldRemove = await CLIUtilityInitialize.promptEntitiesDeleteForm(entityLabel);
-                if (!shouldRemove) {
+                if (shouldRemove !== true) {
                     continue;
                 }
                 entities.splice(entityIndex, 1);
@@ -427,11 +426,11 @@ export class CLIUtilityInitialize {
     }
     static async promptEntitiesForm(entity, mode) {
         const validRoles = ['author', 'contributor', 'supporter'];
-        const existingName = (typeof entity?.name === 'string') ? entity.name : '';
-        const existingEmail = (typeof entity?.email === 'string') ? entity.email : '';
-        const existingUrl = (typeof entity?.url === 'string') ? entity.url : '';
+        const existingName = (entity !== undefined && typeof entity.name === 'string') ? entity.name : '';
+        const existingEmail = (entity !== undefined && typeof entity.email === 'string') ? entity.email : '';
+        const existingUrl = (entity !== undefined && typeof entity.url === 'string') ? entity.url : '';
         let existingRoles = [];
-        if (Array.isArray(entity?.roles)) {
+        if (entity !== undefined && Array.isArray(entity.roles)) {
             existingRoles = entity.roles.filter((role) => validRoles.includes(role));
         }
         const questionsOutput = await CLIUtilityInitialize.promptWithCancel([
@@ -440,38 +439,21 @@ export class CLIUtilityInitialize {
                 name: 'entityName',
                 message: 'Entity name',
                 initial: existingName,
+                validate: (value) => CLIUtilityInitialize.normalizeText(value, Infinity).result,
             },
             {
                 type: 'text',
                 name: 'entityEmail',
                 message: 'Entity email address',
                 initial: existingEmail,
-                validate: (value) => {
-                    const trimmed = value.trim();
-                    if (trimmed === '') {
-                        return true;
-                    }
-                    if (PATTERN_EMAIL_SIMPLE.test(trimmed)) {
-                        return true;
-                    }
-                    return 'Enter a valid email address or leave blank.';
-                },
+                validate: (value) => CLIUtilityInitialize.normalizeEmail(value).result,
             },
             {
                 type: 'text',
                 name: 'entityUrl',
                 message: 'Entity website',
                 initial: existingUrl,
-                validate: (value) => {
-                    const trimmed = value.trim();
-                    if (trimmed === '') {
-                        return true;
-                    }
-                    if (CLIUtilityInitialize.isAllowedHttpUrl(trimmed)) {
-                        return true;
-                    }
-                    return 'Enter a valid URL (http:// or https://) or leave blank.';
-                },
+                validate: (value) => CLIUtilityInitialize.normalizeUrl(value, 'generic').result,
             },
             {
                 type: 'multiselect',
@@ -490,18 +472,18 @@ export class CLIUtilityInitialize {
             };
         }
         const questionsOutputResult = questionsOutput.result;
-        const entityNameInput = (typeof questionsOutputResult.entityName === 'string') ? questionsOutputResult.entityName.trim() : '';
-        const entityEmailInput = (typeof questionsOutputResult.entityEmail === 'string') ? questionsOutputResult.entityEmail.trim() : '';
-        const entityUrlInput = (typeof questionsOutputResult.entityUrl === 'string') ? questionsOutputResult.entityUrl.trim() : '';
+        const entityNameInput = CLIUtilityInitialize.normalizeText(questionsOutputResult.entityName, Infinity).sanitized;
+        const entityEmailInput = CLIUtilityInitialize.normalizeEmail(questionsOutputResult.entityEmail).sanitized;
+        const entityUrlInput = CLIUtilityInitialize.normalizeUrl(questionsOutputResult.entityUrl, 'generic').sanitized;
         const entityRolesInput = Array.isArray(questionsOutputResult.entityRoles) ? [...questionsOutputResult.entityRoles] : [];
         const resolvedEntity = {};
-        if (entityNameInput !== '') {
+        if (entityNameInput !== undefined) {
             resolvedEntity.name = entityNameInput;
         }
-        if (entityEmailInput !== '') {
+        if (entityEmailInput !== undefined) {
             resolvedEntity.email = entityEmailInput;
         }
-        if (entityUrlInput !== '') {
+        if (entityUrlInput !== undefined) {
             resolvedEntity.url = entityUrlInput;
         }
         if (entityRolesInput.length > 0) {
@@ -530,112 +512,180 @@ export class CLIUtilityInitialize {
         const confirmOutputResult = confirmOutput.result;
         return confirmOutputResult.confirm;
     }
+    static async promptEmails(config) {
+        const existingEmails = config.emails;
+        const emails = (existingEmails !== undefined) ? { ...existingEmails } : {};
+        const questionsOutput = await CLIUtilityInitialize.promptWithCancel([
+            {
+                type: 'text',
+                name: 'emailsBugs',
+                message: 'Issue tracker email',
+                initial: emails.bugs ?? '',
+                validate: (value) => CLIUtilityInitialize.normalizeEmail(value).result,
+            },
+        ]);
+        if (questionsOutput.cancelled) {
+            return 'back';
+        }
+        const questionsOutputResult = questionsOutput.result;
+        const emailsBugsInput = CLIUtilityInitialize.normalizeEmail(questionsOutputResult.emailsBugs).sanitized;
+        if (emailsBugsInput !== undefined) {
+            emails.bugs = emailsBugsInput;
+        }
+        else {
+            Reflect.deleteProperty(emails, 'bugs');
+        }
+        if (Object.keys(emails).length > 0) {
+            Object.assign(config, { emails });
+        }
+        else {
+            Reflect.deleteProperty(config, 'emails');
+        }
+        Logger.customize({
+            name: 'CLIUtilityInitialize.promptEmails',
+            purpose: 'updated',
+            padTop: 1,
+            padBottom: 1,
+        }).info('Email references updated.');
+        return 'back';
+    }
     static async promptUrls(config) {
         const existingUrls = config.urls;
         const urls = (existingUrls !== undefined) ? { ...existingUrls } : {};
-        const validatedUrls = {};
-        const validate = (key, input) => {
-            const field = (key === 'repository') ? 'repository' : undefined;
-            const sanitizedUrl = CLIUtilityInitialize.sanitizeHttpUrl(input, field);
-            if (sanitizedUrl !== undefined) {
-                validatedUrls[key] = sanitizedUrl;
-            }
-        };
         const questionsOutput = await CLIUtilityInitialize.promptWithCancel([
             {
                 type: 'text',
                 name: 'urlsHomepage',
                 message: 'Homepage URL',
                 initial: urls.homepage ?? '',
-                validate: (value) => CLIUtilityInitialize.validateHttpUrl(value),
+                validate: (value) => CLIUtilityInitialize.normalizeUrl(value, 'generic').result,
             },
             {
                 type: 'text',
                 name: 'urlsRepository',
                 message: 'Repository URL',
                 initial: urls.repository ?? '',
-                validate: (value) => CLIUtilityInitialize.validateHttpUrl(value, 'repository'),
+                validate: (value) => CLIUtilityInitialize.normalizeUrl(value, 'repository').result,
             },
             {
                 type: 'text',
                 name: 'urlsBugs',
                 message: 'Issue tracker URL',
                 initial: urls.bugs ?? '',
-                validate: (value) => CLIUtilityInitialize.validateHttpUrl(value),
+                validate: (value) => CLIUtilityInitialize.normalizeUrl(value, 'generic').result,
             },
             {
                 type: 'text',
                 name: 'urlsLicense',
                 message: 'License URL',
                 initial: urls.license ?? '',
-                validate: (value) => CLIUtilityInitialize.validateHttpUrl(value),
+                validate: (value) => CLIUtilityInitialize.normalizeUrl(value, 'generic').result,
             },
             {
                 type: 'text',
                 name: 'urlsLogo',
                 message: 'Logo URL',
                 initial: urls.logo ?? '',
-                validate: (value) => CLIUtilityInitialize.validateHttpUrl(value),
+                validate: (value) => CLIUtilityInitialize.normalizeUrl(value, 'generic').result,
             },
             {
                 type: 'text',
                 name: 'urlsDocumentation',
                 message: 'Documentation URL',
                 initial: urls.documentation ?? '',
-                validate: (value) => CLIUtilityInitialize.validateHttpUrl(value),
+                validate: (value) => CLIUtilityInitialize.normalizeUrl(value, 'generic').result,
             },
             {
                 type: 'text',
                 name: 'urlsGithub',
                 message: 'GitHub URL',
                 initial: urls.github ?? '',
-                validate: (value) => CLIUtilityInitialize.validateHttpUrl(value),
+                validate: (value) => CLIUtilityInitialize.normalizeUrl(value, 'generic').result,
             },
             {
                 type: 'text',
                 name: 'urlsNpm',
                 message: 'npm package URL',
                 initial: urls.npm ?? '',
-                validate: (value) => CLIUtilityInitialize.validateHttpUrl(value),
+                validate: (value) => CLIUtilityInitialize.normalizeUrl(value, 'generic').result,
             },
             {
                 type: 'text',
                 name: 'urlsFundSources',
                 message: 'Funding URLs (comma separated)',
                 initial: (Array.isArray(urls.fundSources)) ? urls.fundSources.join(', ') : '',
-                validate: CLIUtilityInitialize.validateFundSources,
+                validate: (value) => CLIUtilityInitialize.normalizeUrlArray(value, 'generic').result,
             },
         ]);
         if (questionsOutput.cancelled) {
             return 'back';
         }
         const questionsOutputResult = questionsOutput.result;
-        validate('homepage', questionsOutputResult.urlsHomepage);
-        validate('repository', questionsOutputResult.urlsRepository);
-        validate('bugs', questionsOutputResult.urlsBugs);
-        validate('license', questionsOutputResult.urlsLicense);
-        validate('logo', questionsOutputResult.urlsLogo);
-        validate('documentation', questionsOutputResult.urlsDocumentation);
-        validate('github', questionsOutputResult.urlsGithub);
-        validate('npm', questionsOutputResult.urlsNpm);
-        const fundSourcesParts = questionsOutputResult.urlsFundSources
-            .split(',')
-            .map((fundSourceInput) => fundSourceInput.trim())
-            .filter((fundSourceInput) => fundSourceInput !== '');
-        if (fundSourcesParts.length > 0) {
-            const fundSourcesList = [];
-            for (const fundSourcesPart of fundSourcesParts) {
-                const sanitizedUrl = CLIUtilityInitialize.sanitizeHttpUrl(fundSourcesPart, 'generic');
-                if (sanitizedUrl !== undefined) {
-                    fundSourcesList.push(sanitizedUrl);
-                }
-            }
-            if (fundSourcesList.length > 0) {
-                validatedUrls.fundSources = fundSourcesList;
-            }
+        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 urlsFundSourcesInput = CLIUtilityInitialize.normalizeUrlArray(questionsOutputResult.urlsFundSources, 'generic').sanitized;
+        if (urlsHomepageInput !== undefined) {
+            urls.homepage = urlsHomepageInput;
+        }
+        else {
+            Reflect.deleteProperty(urls, 'homepage');
+        }
+        if (urlsRepositoryInput !== undefined) {
+            urls.repository = urlsRepositoryInput;
+        }
+        else {
+            Reflect.deleteProperty(urls, 'repository');
         }
-        if (Object.keys(validatedUrls).length > 0) {
-            Object.assign(config, { urls: validatedUrls });
+        if (urlsBugsInput !== undefined) {
+            urls.bugs = urlsBugsInput;
+        }
+        else {
+            Reflect.deleteProperty(urls, 'bugs');
+        }
+        if (urlsLicenseInput !== undefined) {
+            urls.license = urlsLicenseInput;
+        }
+        else {
+            Reflect.deleteProperty(urls, 'license');
+        }
+        if (urlsLogoInput !== undefined) {
+            urls.logo = urlsLogoInput;
+        }
+        else {
+            Reflect.deleteProperty(urls, 'logo');
+        }
+        if (urlsDocumentationInput !== undefined) {
+            urls.documentation = urlsDocumentationInput;
+        }
+        else {
+            Reflect.deleteProperty(urls, 'documentation');
+        }
+        if (urlsGithubInput !== undefined) {
+            urls.github = urlsGithubInput;
+        }
+        else {
+            Reflect.deleteProperty(urls, 'github');
+        }
+        if (urlsNpmInput !== undefined) {
+            urls.npm = urlsNpmInput;
+        }
+        else {
+            Reflect.deleteProperty(urls, 'npm');
+        }
+        if (urlsFundSourcesInput !== undefined) {
+            urls.fundSources = urlsFundSourcesInput;
+        }
+        else {
+            Reflect.deleteProperty(urls, 'fundSources');
+        }
+        if (Object.keys(urls).length > 0) {
+            Object.assign(config, { urls });
         }
         else {
             Reflect.deleteProperty(config, 'urls');
@@ -652,11 +702,11 @@ export class CLIUtilityInitialize {
         const workspaces = (config.workspaces) ? { ...(config.workspaces) } : {};
         const rawWorkspacePaths = await discoverPathsWithFile('package.json', 'forward');
         const workspacePaths = rawWorkspacePaths.map((rawWorkspacePath) => {
-            const relativePath = path.relative(process.cwd(), rawWorkspacePath);
+            const relativePath = relative(process.cwd(), rawWorkspacePath);
             if (relativePath === '') {
                 return './';
             }
-            return `./${relativePath.split(path.sep).join('/')}`;
+            return `./${relativePath.split(sep).join('/')}`;
         });
         Logger.customize({
             name: 'CLIUtilityInitialize.promptWorkspaces',
@@ -666,13 +716,13 @@ export class CLIUtilityInitialize {
             const choices = workspacePaths.map((workspacePath) => {
                 const workspace = workspaces[workspacePath];
                 const summaryParts = [];
-                if (workspace.name) {
+                if (workspace !== undefined && workspace.name !== undefined) {
                     summaryParts.push(workspace.name);
                 }
-                if (workspace.role) {
+                if (workspace !== undefined && workspace.role !== undefined) {
                     summaryParts.push(workspace.role);
                 }
-                if (workspace.policy) {
+                if (workspace !== undefined && workspace.policy !== undefined) {
                     summaryParts.push(workspace.policy);
                 }
                 return {
@@ -704,12 +754,12 @@ export class CLIUtilityInitialize {
             const formResult = await CLIUtilityInitialize.promptWorkspacesForm({
                 workspacePath,
                 existingWorkspace: workspaces[workspacePath],
-                projectSlug: config.project?.name?.slug,
+                projectSlug: (config.project !== undefined && config.project.name !== undefined) ? config.project.name.slug : undefined,
             });
             if (formResult.action === 'back') {
                 continue;
             }
-            workspaces[workspacePath] = formResult.workspace;
+            Reflect.set(workspaces, workspacePath, formResult.workspace);
             Object.assign(config, { workspaces });
             Logger.customize({
                 name: 'CLIUtilityInitialize.promptWorkspaces',
@@ -751,6 +801,11 @@ export class CLIUtilityInitialize {
                 description: 'Internal CLI or build tools (e.g., codegen, bundler)',
                 value: 'tool',
             },
+            {
+                title: 'Template',
+                description: 'Ready-to-copy scaffold bundles consumed by generators (e.g., starter files)',
+                value: 'template',
+            },
         ];
         const policy = {
             freezable: {
@@ -778,42 +833,13 @@ export class CLIUtilityInitialize {
                 type: 'text',
                 name: 'workspaceName',
                 message: 'Workspace package name',
-                initial: options.existingWorkspace.name,
-                validate: (value) => {
-                    const trimmed = value.trim();
-                    if (trimmed === '') {
-                        return 'Enter a package name.';
-                    }
-                    switch (role) {
-                        case 'config':
-                        case 'app':
-                        case 'tool':
-                            const expectedPrefix = `${base}-`;
-                            if (!trimmed.startsWith(expectedPrefix)) {
-                                return `Begin with "${expectedPrefix}" and add a descriptor slug.`;
-                            }
-                            const descriptor = trimmed.slice(expectedPrefix.length);
-                            if (descriptor.length === 0) {
-                                return 'Add a descriptor after the prefix.';
-                            }
-                            if (!PATTERN_SLUG_SIMPLE.test(descriptor)) {
-                                return 'Descriptor must match the slug pattern (lowercase letters, numbers, hyphens, underscores).';
-                            }
-                            return true;
-                        case 'package':
-                        default:
-                            if (PATTERN_SLUG_SIMPLE.test(trimmed) || PATTERN_SLUG_SCOPED.test(trimmed)) {
-                                return true;
-                            }
-                            return 'Enter an unscoped slug or a scoped package name (e.g. @scope/name).';
-                    }
-                },
+                initial: (options.existingWorkspace !== undefined) ? options.existingWorkspace.name ?? '' : '',
+                validate: (value) => CLIUtilityInitialize.normalizeWorkspaceName(value, role, base).result,
             });
             if (namePrompt.cancelled) {
                 return undefined;
             }
-            const name = namePrompt.result.workspaceName.trim();
-            return (name === '') ? undefined : name;
+            return CLIUtilityInitialize.normalizeWorkspaceName(namePrompt.result.workspaceName, role, base).sanitized;
         };
         const rolePrompt = await CLIUtilityInitialize.promptWithCancel({
             type: 'select',
@@ -824,7 +850,7 @@ export class CLIUtilityInitialize {
                 description: role.description,
                 value: role.value,
             })),
-            initial: Math.max(0, allowedRoles.findIndex((role) => role.value === options.existingWorkspace.role)),
+            initial: Math.max(0, allowedRoles.findIndex((role) => options.existingWorkspace !== undefined && role.value === options.existingWorkspace.role)),
         });
         if (rolePrompt.cancelled) {
             return {
@@ -842,7 +868,7 @@ export class CLIUtilityInitialize {
                 description: policy[allowedPolicy].description,
                 value: allowedPolicy,
             })),
-            initial: Math.max(0, allowedPolicies.findIndex((policy) => policy === options.existingWorkspace.policy)),
+            initial: Math.max(0, allowedPolicies.findIndex((policy) => options.existingWorkspace !== undefined && policy === options.existingWorkspace.policy)),
         });
         if (policyPrompt.cancelled) {
             return {
@@ -856,12 +882,61 @@ export class CLIUtilityInitialize {
                 action: 'back',
             };
         }
+        let syncProperties;
+        if (selectedPolicy === 'distributable') {
+            const syncPropertiesPrompt = await CLIUtilityInitialize.promptWithCancel({
+                type: 'multiselect',
+                name: 'workspaceSyncProperties',
+                message: 'Select metadata properties to sync',
+                choices: itemAllowedSyncProperties.map((property) => ({
+                    title: property,
+                    value: property,
+                    selected: (options.existingWorkspace !== undefined && options.existingWorkspace.syncProperties !== undefined) ? options.existingWorkspace.syncProperties.includes(property) : false,
+                })),
+            });
+            if (syncPropertiesPrompt.cancelled) {
+                return {
+                    action: 'back',
+                };
+            }
+            const selectedSyncProperties = syncPropertiesPrompt.result.workspaceSyncProperties;
+            if (selectedSyncProperties.length > 0) {
+                syncProperties = selectedSyncProperties;
+            }
+        }
+        const pinVersionsPrompt = await CLIUtilityInitialize.promptWithCancel({
+            type: 'confirm',
+            name: 'workspacePinVersions',
+            message: 'Pin dependency versions?',
+            initial: options.existingWorkspace !== undefined && options.existingWorkspace.pinVersions === true,
+        });
+        if (pinVersionsPrompt.cancelled) {
+            return {
+                action: 'back',
+            };
+        }
+        const selectedPinVersions = pinVersionsPrompt.result.workspacePinVersions;
+        const syncLtsEnginesPrompt = await CLIUtilityInitialize.promptWithCancel({
+            type: 'confirm',
+            name: 'workspaceSyncLtsEngines',
+            message: 'Sync Node.js LTS engine constraint?',
+            initial: options.existingWorkspace !== undefined && options.existingWorkspace.syncLtsEngines === true,
+        });
+        if (syncLtsEnginesPrompt.cancelled) {
+            return {
+                action: 'back',
+            };
+        }
+        const selectedSyncLtsEngines = syncLtsEnginesPrompt.result.workspaceSyncLtsEngines;
         return {
             action: 'apply',
             workspace: {
                 name: resolvedName,
                 role: selectedRole,
                 policy: selectedPolicy,
+                ...(syncProperties !== undefined) ? { syncProperties } : {},
+                ...(selectedPinVersions === true) ? { pinVersions: selectedPinVersions } : {},
+                ...(selectedSyncLtsEngines === true) ? { syncLtsEngines: selectedSyncLtsEngines } : {},
             },
         };
     }
@@ -893,7 +968,6 @@ export class CLIUtilityInitialize {
             Logger.customize({
                 name: 'CLIUtilityInitialize.checkPath',
                 purpose: 'lessThanOne',
-                padBottom: 1,
             }).error([
                 'No "package.json" files were found. Re-run this command inside the project root directory.',
                 `Current directory is "${currentDirectory}"`,
@@ -904,7 +978,6 @@ export class CLIUtilityInitialize {
             Logger.customize({
                 name: 'CLIUtilityInitialize.checkPath',
                 purpose: 'greaterThanOne',
-                padBottom: 1,
             }).error([
                 'Multiple "package.json" files were found. Re-run this command inside the project root directory.',
                 `Current directory is "${currentDirectory}"`,
@@ -915,7 +988,6 @@ export class CLIUtilityInitialize {
             Logger.customize({
                 name: 'CLIUtilityInitialize.checkPath',
                 purpose: 'notProjectRootDir',
-                padBottom: 1,
             }).error([
                 'Must be run inside the project root directory.',
                 `Current directory is "${currentDirectory}"`,
@@ -924,60 +996,256 @@ export class CLIUtilityInitialize {
         }
         return true;
     }
-    static validateHttpUrl(value, field) {
-        const trimmed = value.trim();
-        if (trimmed === '') {
-            return true;
+    static normalizeEmail(value) {
+        if (typeof value !== 'string') {
+            return {
+                result: `Unexpected type error. Expect type to be "string", got "${typeof value}".`,
+                sanitized: undefined,
+            };
+        }
+        const trimmedValue = value.trim();
+        if (trimmedValue === '') {
+            return {
+                result: true,
+                sanitized: undefined,
+            };
         }
-        if (CLIUtilityInitialize.isAllowedHttpUrl(trimmed, field)) {
-            return true;
+        if (!PATTERN_EMAIL_SIMPLE.test(trimmedValue)) {
+            return {
+                result: 'Enter a valid email address or leave blank.',
+                sanitized: undefined,
+            };
         }
-        return 'Enter a valid URL (http:// or https://) or leave blank.';
+        return {
+            result: true,
+            sanitized: trimmedValue,
+        };
     }
-    static validateFundSources(value) {
-        const trimmed = value.trim();
-        if (trimmed === '') {
-            return true;
+    static normalizeProjectSlug(value) {
+        if (typeof value !== 'string') {
+            return {
+                result: `Unexpected type error. Expect type to be "string", got "${typeof value}".`,
+                sanitized: undefined,
+            };
+        }
+        const trimmedValue = value.trim();
+        if (trimmedValue === '') {
+            return {
+                result: true,
+                sanitized: undefined,
+            };
+        }
+        if (trimmedValue.length > 214
+            || !new RegExp(PATTERN_SLUG_SIMPLE, 'i').test(trimmedValue)) {
+            return {
+                result: 'Use only letters, numbers, hyphens, or underscores, and keep it at 214 characters or fewer.',
+                sanitized: undefined,
+            };
+        }
+        return {
+            result: true,
+            sanitized: trimmedValue,
+        };
+    }
+    static normalizeText(value, maxLength) {
+        if (typeof value !== 'string') {
+            return {
+                result: `Unexpected type error. Expect type to be "string", got "${typeof value}".`,
+                sanitized: undefined,
+            };
+        }
+        const trimmedValue = value.trim();
+        if (trimmedValue === '') {
+            return {
+                result: true,
+                sanitized: undefined,
+            };
+        }
+        if (trimmedValue.length > maxLength) {
+            return {
+                result: `Input a value under ${maxLength} character(s) or leave blank.`,
+                sanitized: undefined,
+            };
+        }
+        return {
+            result: true,
+            sanitized: trimmedValue,
+        };
+    }
+    static normalizeTextArray(value, maxLengthPerItem) {
+        if (typeof value !== 'string') {
+            return {
+                result: `Unexpected type error. Expect type to be "string", got "${typeof value}".`,
+                sanitized: undefined,
+            };
+        }
+        const trimmedValue = value.trim();
+        if (trimmedValue === '') {
+            return {
+                result: true,
+                sanitized: undefined,
+            };
         }
-        const parts = trimmed
+        const items = trimmedValue
             .split(',')
-            .map((part) => part.trim())
-            .filter((part) => part !== '');
-        for (const part of parts) {
-            if (!CLIUtilityInitialize.isAllowedHttpUrl(part, 'generic')) {
-                return 'Enter comma separated URLs (http:// or https://) or leave blank.';
+            .map((item) => item.trim())
+            .filter((item) => item !== '');
+        for (let i = 0; i < items.length; i += 1) {
+            const { result, sanitized } = CLIUtilityInitialize.normalizeText(items[i], maxLengthPerItem);
+            if (result !== true) {
+                return {
+                    result: `Invalid entry "${items[i]}": Input a value under ${maxLengthPerItem} character(s) or remove entry.`,
+                    sanitized: undefined,
+                };
+            }
+            if (sanitized !== undefined) {
+                items[i] = sanitized;
             }
         }
-        return true;
+        return {
+            result: true,
+            sanitized: items,
+        };
     }
-    static sanitizeHttpUrl(value, field) {
+    static normalizeUrl(value, protocol) {
         if (typeof value !== 'string') {
-            return undefined;
+            return {
+                result: `Unexpected type error. Expect type to be "string", got "${typeof value}".`,
+                sanitized: undefined,
+            };
         }
-        const trimmed = value.trim();
-        if (trimmed === '') {
-            return undefined;
+        const trimmedValue = value.trim();
+        if (trimmedValue === '') {
+            return {
+                result: true,
+                sanitized: undefined,
+            };
         }
+        const rules = {
+            generic: {
+                allowed: ['http:', 'https:'],
+                message: 'Enter a valid generic URL (e.g., https://) or leave blank.',
+            },
+            repository: {
+                allowed: ['git:', 'git+https:', 'git+ssh:', 'git+http:', 'http:', 'https:'],
+                message: 'Enter a valid repository URL (e.g., git+https://) or leave blank.',
+            },
+        };
+        const allowed = (protocol === 'repository') ? rules.repository.allowed : rules.generic.allowed;
+        const errorMessage = (protocol === 'repository') ? rules.repository.message : rules.generic.message;
         try {
-            const parsedUrl = new URL(trimmed);
-            if (CLIUtilityInitialize.isAllowedHttpUrl(parsedUrl.toString(), field)) {
-                return parsedUrl.toString();
+            const url = new URL(trimmedValue);
+            if (allowed.includes(url.protocol)) {
+                return {
+                    result: true,
+                    sanitized: url.toString(),
+                };
             }
         }
         catch {
         }
-        return undefined;
+        return {
+            result: errorMessage,
+            sanitized: undefined,
+        };
     }
-    static isAllowedHttpUrl(value, field) {
-        try {
-            const url = new URL(value);
-            const genericProtocols = ['http:', 'https:'];
-            const repositoryProtocols = ['git:', 'git+https:', 'git+ssh:', 'git+http:', 'https:', 'http:'];
-            const allowedProtocols = (field === 'repository') ? repositoryProtocols : genericProtocols;
-            return allowedProtocols.includes(url.protocol);
+    static normalizeUrlArray(value, protocol) {
+        if (typeof value !== 'string') {
+            return {
+                result: `Unexpected type error. Expect type to be "string", got "${typeof value}".`,
+                sanitized: undefined,
+            };
         }
-        catch {
-            return false;
+        const trimmedValue = value.trim();
+        if (trimmedValue === '') {
+            return {
+                result: true,
+                sanitized: undefined,
+            };
+        }
+        const items = trimmedValue
+            .split(',')
+            .map((item) => item.trim())
+            .filter((item) => item !== '');
+        for (let i = 0; i < items.length; i += 1) {
+            const { result, sanitized } = CLIUtilityInitialize.normalizeUrl(items[i], protocol);
+            if (result !== true) {
+                const errorMessages = {
+                    generic: 'Enter a valid generic URL (e.g., https://) or remove entry.',
+                    repository: 'Enter a valid repository URL (e.g., git+https://) or remove entry.',
+                };
+                const errorMessage = (protocol === 'repository') ? errorMessages.repository : errorMessages.generic;
+                return {
+                    result: `Invalid URL "${items[i]}": ${errorMessage}`,
+                    sanitized: undefined,
+                };
+            }
+            if (sanitized !== undefined) {
+                items[i] = sanitized;
+            }
+        }
+        return {
+            result: true,
+            sanitized: items,
+        };
+    }
+    static normalizeWorkspaceName(value, role, base) {
+        if (typeof value !== 'string') {
+            return {
+                result: `Unexpected type error. Expect type to be "string", got "${typeof value}".`,
+                sanitized: undefined,
+            };
+        }
+        const trimmedValue = value.trim();
+        if (trimmedValue === '') {
+            return {
+                result: 'Enter a package name.',
+                sanitized: undefined,
+            };
+        }
+        switch (role) {
+            case 'config':
+            case 'app':
+            case 'tool': {
+                const expectedPrefix = `${base}-`;
+                if (!trimmedValue.startsWith(expectedPrefix)) {
+                    return {
+                        result: `Begin with "${expectedPrefix}" and add a descriptor slug.`,
+                        sanitized: undefined,
+                    };
+                }
+                const descriptor = trimmedValue.slice(expectedPrefix.length);
+                if (descriptor.length === 0) {
+                    return {
+                        result: 'Add a descriptor after the prefix.',
+                        sanitized: undefined,
+                    };
+                }
+                if (!PATTERN_SLUG_SIMPLE.test(descriptor)) {
+                    return {
+                        result: 'Descriptor must match the slug pattern (lowercase letters, numbers, hyphens, underscores).',
+                        sanitized: undefined,
+                    };
+                }
+                return {
+                    result: true,
+                    sanitized: trimmedValue,
+                };
+            }
+            case 'template':
+            case 'package':
+            default: {
+                if (PATTERN_SLUG_SIMPLE.test(trimmedValue) || PATTERN_SLUG_SCOPED.test(trimmedValue)) {
+                    return {
+                        result: true,
+                        sanitized: trimmedValue,
+                    };
+                }
+                return {
+                    result: 'Enter an unscoped slug or a scoped package name (e.g. @scope/name).',
+                    sanitized: undefined,
+                };
+            }
         }
     }
 }