@cbnventures/nova 0.11.0

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

@@ -0,0 +1,962 @@
+import * as path from 'path';
+import chalk from 'chalk';
+import prompts from 'prompts';
+import { itemAllowedPoliciesByRole } 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';
+import { Logger } from '../../toolkit/index.js';
+export class CLIUtilityInitialize {
+    static async run(options) {
+        const currentDirectory = process.cwd();
+        const isProjectRoot = await CLIUtilityInitialize.checkPath(currentDirectory);
+        if (!isProjectRoot) {
+            process.exitCode = 1;
+            return;
+        }
+        if (options.dryRun === true) {
+            Logger.customize({
+                name: 'CLIUtilityInitialize.run::options',
+                padBottom: 1,
+            }).warn('Dry run enabled. File changes will not be made in this session.');
+        }
+        const novaConfig = new NovaConfig();
+        const workingFile = await novaConfig.load();
+        const promptFlowResult = await CLIUtilityInitialize.promptFlow(workingFile);
+        if (promptFlowResult === 'cancel') {
+            Logger.customize({
+                name: 'CLIUtilityInitialize.run::promptFlow',
+                padTop: 1,
+                padBottom: 1,
+            }).debug('Prompt flow exited without saving.');
+            return;
+        }
+        novaConfig.set(workingFile);
+        if (options.dryRun === true) {
+            Logger.customize({
+                name: 'CLIUtilityInitialize.run::promptFlow',
+                padTop: 1,
+                padBottom: 1,
+            }).debug('Dry run enabled. Skipping save operation.');
+            return;
+        }
+        await novaConfig.save();
+    }
+    static async promptFlow(config) {
+        const category = {
+            project: {
+                label: 'Project',
+                description: 'Configure project metadata (name, description, keywords).',
+                handler: CLIUtilityInitialize.promptProject,
+            },
+            entities: {
+                label: 'Entities',
+                description: 'Manage entities, their roles, and contact information.',
+                handler: CLIUtilityInitialize.promptEntities,
+            },
+            urls: {
+                label: 'URLs',
+                description: 'Set URLs for docs, repo, support, and funding sources.',
+                handler: CLIUtilityInitialize.promptUrls,
+            },
+            workspaces: {
+                label: 'Workspaces',
+                description: 'Review workspace packages, assigning roles and policies.',
+                handler: CLIUtilityInitialize.promptWorkspaces,
+            },
+        };
+        while (true) {
+            const categoryKeys = Object.keys(category);
+            const choices = categoryKeys.map((categoryKey) => ({
+                title: category[categoryKey].label,
+                description: category[categoryKey].description,
+                value: categoryKey,
+            }));
+            choices.push({
+                title: 'Save & Exit',
+                description: 'Persist the "nova.config.json" file and exit.',
+                value: 'save',
+            });
+            choices.push({
+                title: 'Cancel',
+                description: 'Exit without persisting any changes.',
+                value: 'cancel',
+            });
+            const menuOutput = await CLIUtilityInitialize.promptWithCancel({
+                type: 'select',
+                name: 'action',
+                message: 'Select a Nova configuration category to edit.',
+                choices,
+            });
+            if (menuOutput.cancelled) {
+                return 'cancel';
+            }
+            const menuOutputResult = menuOutput.result;
+            if (menuOutputResult.action === undefined
+                || menuOutputResult.action === 'cancel') {
+                return 'cancel';
+            }
+            if (menuOutputResult.action === 'save') {
+                return 'save';
+            }
+            const categoryKey = menuOutputResult.action;
+            const categoryHandler = category[categoryKey].handler;
+            await categoryHandler(config);
+        }
+    }
+    static async promptProject(config) {
+        const existingProject = config.project;
+        const existingProjectName = existingProject?.name;
+        const existingProjectDescription = existingProject?.description;
+        const existingProjectKeywords = existingProject?.keywords;
+        const project = (existingProject !== undefined) ? { ...existingProject } : {};
+        const projectName = (existingProjectName !== undefined) ? { ...existingProjectName } : {};
+        const projectDescription = (existingProjectDescription !== undefined) ? { ...existingProjectDescription } : {};
+        const questionsOutput = await CLIUtilityInitialize.promptWithCancel([
+            {
+                type: 'text',
+                name: 'projectNameTitle',
+                message: 'Project title (display name)',
+                initial: projectName.title ?? '',
+            },
+            {
+                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.';
+                },
+            },
+            {
+                type: 'text',
+                name: 'projectDescriptionShort',
+                message: 'Short description',
+                initial: projectDescription.short ?? '',
+            },
+            {
+                type: 'text',
+                name: 'projectDescriptionLong',
+                message: 'Long description',
+                initial: projectDescription.long ?? '',
+            },
+            {
+                type: 'text',
+                name: 'projectKeywords',
+                message: 'Keywords (comma separated)',
+                initial: (Array.isArray(existingProjectKeywords)) ? existingProjectKeywords.join(', ') : '',
+            },
+        ]);
+        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');
+        }
+        else {
+            projectName.title = projectNameTitleInput;
+        }
+        if (projectNameSlugInput === '') {
+            Reflect.deleteProperty(projectName, 'slug');
+        }
+        else {
+            projectName.slug = projectNameSlugInput;
+        }
+        if (projectDescriptionShortInput === '') {
+            Reflect.deleteProperty(projectDescription, 'short');
+        }
+        else {
+            projectDescription.short = projectDescriptionShortInput;
+        }
+        if (projectDescriptionLongInput === '') {
+            Reflect.deleteProperty(projectDescription, 'long');
+        }
+        else {
+            projectDescription.long = projectDescriptionLongInput;
+        }
+        if (Object.keys(projectName).length > 0) {
+            project.name = projectName;
+        }
+        else {
+            Reflect.deleteProperty(project, 'name');
+        }
+        if (Object.keys(projectDescription).length > 0) {
+            project.description = projectDescription;
+        }
+        else {
+            Reflect.deleteProperty(project, 'description');
+        }
+        if (projectKeywordsInput === '') {
+            Reflect.deleteProperty(project, 'keywords');
+        }
+        else {
+            const projectKeywordsList = projectKeywordsInput
+                .split(',')
+                .map((projectKeywordInput) => projectKeywordInput.trim())
+                .filter((projectKeywordInput) => projectKeywordInput !== '');
+            if (projectKeywordsList.length > 0) {
+                project.keywords = projectKeywordsList;
+            }
+            else {
+                Reflect.deleteProperty(project, 'keywords');
+            }
+        }
+        if (Object.keys(project).length > 0) {
+            Object.assign(config, { project });
+        }
+        else {
+            Reflect.deleteProperty(config, 'project');
+        }
+        const previousSlug = existingProjectName?.slug ?? '';
+        const currentSlug = config.project?.name?.slug ?? '';
+        const slugChanged = previousSlug !== currentSlug;
+        if (slugChanged && config.workspaces !== undefined) {
+            const rolesToSync = ['project', 'docs', 'config', 'app', 'tool'];
+            const slugPrefix = new RegExp(`^${previousSlug}-`);
+            Logger.customize({
+                name: 'CLIUtilityInitialize.promptProject::updated',
+                padTop: 1,
+            }).info(`Project slug updated from "${previousSlug || '(unset)'}" to "${currentSlug || '(unset)'}".`);
+            for (const workspace of Object.values(config.workspaces)) {
+                if (!rolesToSync.includes(workspace.role)) {
+                    continue;
+                }
+                const { name } = workspace;
+                if (previousSlug === '' && currentSlug !== '') {
+                    workspace.name = `${currentSlug}-${name}`;
+                }
+                else if (previousSlug !== '' && currentSlug === '') {
+                    workspace.name = name.replace(slugPrefix, '');
+                }
+                else {
+                    workspace.name = name.replace(slugPrefix, `${currentSlug}-`);
+                }
+                Logger.customize({ name: 'CLIUtilityInitialize.promptProject::updated' }).info(`Workspace name updated from "${name}" to "${workspace.name}".`);
+            }
+        }
+        Logger.customize({
+            name: 'CLIUtilityInitialize.promptProject::updated',
+            padTop: (slugChanged && config.workspaces !== undefined) ? 0 : 1,
+            padBottom: 1,
+        }).info('Project details updated.');
+        return 'back';
+    }
+    static async promptEntities(config) {
+        const entities = [];
+        if (Array.isArray(config.entities)) {
+            for (const configEntity of config.entities) {
+                const clonedEntity = { ...configEntity };
+                if (Array.isArray(configEntity.roles)) {
+                    clonedEntity.roles = [...configEntity.roles];
+                }
+                else {
+                    Reflect.deleteProperty(clonedEntity, 'roles');
+                }
+                entities.push(clonedEntity);
+            }
+        }
+        const sync = () => {
+            if (entities.length > 0) {
+                const normalizedEntities = entities.map((entity) => {
+                    const normalizedEntity = { ...entity };
+                    if (Array.isArray(entity.roles) && entity.roles.length > 0) {
+                        normalizedEntity.roles = [...entity.roles];
+                    }
+                    else {
+                        Reflect.deleteProperty(normalizedEntity, 'roles');
+                    }
+                    return normalizedEntity;
+                });
+                Object.assign(config, { entities: normalizedEntities });
+            }
+            else {
+                Reflect.deleteProperty(config, 'entities');
+            }
+        };
+        while (true) {
+            const choices = [];
+            entities.forEach((entity, index) => {
+                const entityName = (entity.name !== undefined) ? entity.name.trim() : '';
+                const entityEmail = (entity.email !== undefined) ? entity.email.trim() : '';
+                const entityRoles = (Array.isArray(entity.roles)) ? entity.roles.filter((role) => role.trim() !== '') : [];
+                const label = entityName || entityEmail || `Entity ${index + 1}`;
+                const descriptionParts = [];
+                if (entityEmail !== '') {
+                    descriptionParts.push(entityEmail);
+                }
+                if (entityRoles.length > 0) {
+                    const normalizedRoles = entityRoles
+                        .map((entityRole) => entityRole.trim())
+                        .filter((entityRole) => entityRole.length > 0)
+                        .reduce((unique, entityRole) => {
+                        if (!unique.includes(entityRole)) {
+                            unique.push(entityRole);
+                        }
+                        return unique;
+                    }, []);
+                    if (normalizedRoles.length > 0) {
+                        descriptionParts.push(normalizedRoles.join(', '));
+                    }
+                }
+                const description = descriptionParts.join(' · ');
+                choices.push({
+                    title: `${chalk.yellow.bold('[EDIT]')} ${label}`,
+                    description: (description !== '') ? description : 'Update this entity.',
+                    value: {
+                        kind: 'edit',
+                        index,
+                    },
+                });
+                choices.push({
+                    title: `${chalk.red.bold('[REMOVE]')} ${label}`,
+                    description: 'Delete this entity.',
+                    value: {
+                        kind: 'remove',
+                        index,
+                    },
+                });
+            });
+            choices.push({
+                title: 'Add new entity',
+                description: 'Create a new entity.',
+                value: {
+                    kind: 'add',
+                },
+            });
+            choices.push({
+                title: 'Back',
+                description: 'Return to the category selection.',
+                value: {
+                    kind: 'back',
+                },
+            });
+            const menuOutput = await CLIUtilityInitialize.promptWithCancel({
+                type: 'select',
+                name: 'action',
+                message: (entities.length > 0) ? 'Select an entity to manage.' : 'No entities found. Choose an option.',
+                choices,
+            });
+            if (menuOutput.cancelled) {
+                return 'back';
+            }
+            const menuOutputResult = menuOutput.result;
+            if (menuOutputResult.action === undefined
+                || menuOutputResult.action.kind === 'back') {
+                sync();
+                return 'back';
+            }
+            if (menuOutputResult.action.kind === 'add') {
+                const result = await CLIUtilityInitialize.promptEntitiesForm(undefined, 'create');
+                if (result.action === 'back') {
+                    continue;
+                }
+                entities.push(result.entity);
+                sync();
+                Logger.customize({
+                    name: 'CLIUtilityInitialize.promptEntities::add',
+                    padTop: 1,
+                    padBottom: 1,
+                }).info('Added new entity.');
+                continue;
+            }
+            if (menuOutputResult.action.kind === 'edit') {
+                const entityIndex = menuOutputResult.action.index;
+                if (entityIndex < 0 || entityIndex >= entities.length) {
+                    continue;
+                }
+                const entityToEdit = entities[entityIndex];
+                const entityResult = await CLIUtilityInitialize.promptEntitiesForm(entityToEdit, 'update');
+                if (entityResult.action === 'back') {
+                    continue;
+                }
+                entities[entityIndex] = entityResult.entity;
+                sync();
+                Logger.customize({
+                    name: 'CLIUtilityInitialize.promptEntities::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) {
+                    continue;
+                }
+                const entityToRemove = entities[entityIndex];
+                if (entityToRemove === undefined) {
+                    continue;
+                }
+                const entityName = (typeof entityToRemove.name === 'string') ? entityToRemove.name.trim() : '';
+                const entityEmail = (typeof entityToRemove.email === 'string') ? entityToRemove.email.trim() : '';
+                const entityLabel = entityName || entityEmail || `Entity ${entityIndex + 1}`;
+                const shouldRemove = await CLIUtilityInitialize.promptEntitiesDeleteForm(entityLabel);
+                if (!shouldRemove) {
+                    continue;
+                }
+                entities.splice(entityIndex, 1);
+                sync();
+                Logger.customize({
+                    name: 'CLIUtilityInitialize.promptEntities::remove',
+                    padTop: 1,
+                    padBottom: 1,
+                }).info('Removed entity.');
+            }
+        }
+    }
+    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 : '';
+        let existingRoles = [];
+        if (Array.isArray(entity?.roles)) {
+            existingRoles = entity.roles.filter((role) => validRoles.includes(role));
+        }
+        const questionsOutput = await CLIUtilityInitialize.promptWithCancel([
+            {
+                type: 'text',
+                name: 'entityName',
+                message: 'Entity name',
+                initial: existingName,
+            },
+            {
+                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.';
+                },
+            },
+            {
+                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.';
+                },
+            },
+            {
+                type: 'multiselect',
+                name: 'entityRoles',
+                message: 'Entity roles',
+                choices: validRoles.map((validRole) => ({
+                    title: `${validRole.charAt(0).toUpperCase()}${validRole.slice(1)}`,
+                    value: validRole,
+                    selected: existingRoles.includes(validRole),
+                })),
+            },
+        ]);
+        if (questionsOutput.cancelled) {
+            return {
+                action: 'back',
+            };
+        }
+        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 entityRolesInput = Array.isArray(questionsOutputResult.entityRoles) ? [...questionsOutputResult.entityRoles] : [];
+        const resolvedEntity = {};
+        if (entityNameInput !== '') {
+            resolvedEntity.name = entityNameInput;
+        }
+        if (entityEmailInput !== '') {
+            resolvedEntity.email = entityEmailInput;
+        }
+        if (entityUrlInput !== '') {
+            resolvedEntity.url = entityUrlInput;
+        }
+        if (entityRolesInput.length > 0) {
+            resolvedEntity.roles = entityRolesInput;
+        }
+        if (mode === 'create' && Object.keys(resolvedEntity).length < 1) {
+            return {
+                action: 'back',
+            };
+        }
+        return {
+            action: 'apply',
+            entity: resolvedEntity,
+        };
+    }
+    static async promptEntitiesDeleteForm(label) {
+        const confirmOutput = await CLIUtilityInitialize.promptWithCancel({
+            type: 'confirm',
+            name: 'confirm',
+            message: `Remove entity "${label}"?`,
+            initial: false,
+        });
+        if (confirmOutput.cancelled) {
+            return false;
+        }
+        const confirmOutputResult = confirmOutput.result;
+        return confirmOutputResult.confirm;
+    }
+    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),
+            },
+            {
+                type: 'text',
+                name: 'urlsRepository',
+                message: 'Repository URL',
+                initial: urls.repository ?? '',
+                validate: (value) => CLIUtilityInitialize.validateHttpUrl(value, 'repository'),
+            },
+            {
+                type: 'text',
+                name: 'urlsBugs',
+                message: 'Issue tracker URL',
+                initial: urls.bugs ?? '',
+                validate: (value) => CLIUtilityInitialize.validateHttpUrl(value),
+            },
+            {
+                type: 'text',
+                name: 'urlsLicense',
+                message: 'License URL',
+                initial: urls.license ?? '',
+                validate: (value) => CLIUtilityInitialize.validateHttpUrl(value),
+            },
+            {
+                type: 'text',
+                name: 'urlsLogo',
+                message: 'Logo URL',
+                initial: urls.logo ?? '',
+                validate: (value) => CLIUtilityInitialize.validateHttpUrl(value),
+            },
+            {
+                type: 'text',
+                name: 'urlsDocumentation',
+                message: 'Documentation URL',
+                initial: urls.documentation ?? '',
+                validate: (value) => CLIUtilityInitialize.validateHttpUrl(value),
+            },
+            {
+                type: 'text',
+                name: 'urlsGithub',
+                message: 'GitHub URL',
+                initial: urls.github ?? '',
+                validate: (value) => CLIUtilityInitialize.validateHttpUrl(value),
+            },
+            {
+                type: 'text',
+                name: 'urlsNpm',
+                message: 'npm package URL',
+                initial: urls.npm ?? '',
+                validate: (value) => CLIUtilityInitialize.validateHttpUrl(value),
+            },
+            {
+                type: 'text',
+                name: 'urlsFundSources',
+                message: 'Funding URLs (comma separated)',
+                initial: (Array.isArray(urls.fundSources)) ? urls.fundSources.join(', ') : '',
+                validate: CLIUtilityInitialize.validateFundSources,
+            },
+        ]);
+        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;
+            }
+        }
+        if (Object.keys(validatedUrls).length > 0) {
+            Object.assign(config, { urls: validatedUrls });
+        }
+        else {
+            Reflect.deleteProperty(config, 'urls');
+        }
+        Logger.customize({
+            name: 'CLIUtilityInitialize.promptUrls::updated',
+            padTop: 1,
+            padBottom: 1,
+        }).info('URL references updated.');
+        return 'back';
+    }
+    static async promptWorkspaces(config) {
+        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);
+            if (relativePath === '') {
+                return './';
+            }
+            return `./${relativePath.split(path.sep).join('/')}`;
+        });
+        Logger.customize({ name: 'CLIUtilityInitialize.promptWorkspaces::paths' }).debug(workspacePaths);
+        while (true) {
+            const choices = workspacePaths.map((workspacePath) => {
+                const workspace = workspaces[workspacePath];
+                const summaryParts = [];
+                if (workspace.name) {
+                    summaryParts.push(workspace.name);
+                }
+                if (workspace.role) {
+                    summaryParts.push(workspace.role);
+                }
+                if (workspace.policy) {
+                    summaryParts.push(workspace.policy);
+                }
+                return {
+                    title: workspacePath,
+                    description: (summaryParts.length > 0) ? summaryParts.join(' · ') : 'Not configured yet.',
+                    value: workspacePath,
+                };
+            });
+            choices.push({
+                title: 'Back',
+                description: 'Return to the category selection.',
+                value: 'back',
+            });
+            const menuOutput = await CLIUtilityInitialize.promptWithCancel({
+                type: 'select',
+                name: 'workspacePath',
+                message: 'Select a workspace to configure.',
+                choices,
+            });
+            if (menuOutput.cancelled) {
+                return 'back';
+            }
+            const menuOutputResult = menuOutput.result;
+            if (menuOutputResult.workspacePath === undefined
+                || menuOutputResult.workspacePath === 'back') {
+                return 'back';
+            }
+            const workspacePath = menuOutputResult.workspacePath;
+            const formResult = await CLIUtilityInitialize.promptWorkspacesForm({
+                workspacePath,
+                existingWorkspace: workspaces[workspacePath],
+                projectSlug: config.project?.name?.slug,
+            });
+            if (formResult.action === 'back') {
+                continue;
+            }
+            workspaces[workspacePath] = formResult.workspace;
+            Object.assign(config, { workspaces });
+            Logger.customize({
+                name: 'CLIUtilityInitialize.promptWorkspaces::updated',
+                padTop: 1,
+                padBottom: 1,
+            }).info(`Updated workspace "${workspacePath}" → ${formResult.workspace.name} · ${formResult.workspace.role} · ${formResult.workspace.policy}`);
+        }
+    }
+    static async promptWorkspacesForm(options) {
+        const allowedRoles = [
+            {
+                title: 'Project Root',
+                description: 'Monorepo root workspace (e.g., root package.json)',
+                value: 'project',
+            },
+            {
+                title: 'Configuration',
+                description: 'Shared static config (e.g., eslint, tsconfig, prettier)',
+                value: 'config',
+            },
+            {
+                title: 'Documentation',
+                description: 'Documentation workspace (e.g., Docusaurus, Docsify)',
+                value: 'docs',
+            },
+            {
+                title: 'Application',
+                description: 'Deployable runtimes (e.g., web, mobile, workers, API, bots)',
+                value: 'app',
+            },
+            {
+                title: 'Package',
+                description: 'Reusable modules (e.g., libraries, plugins, components)',
+                value: 'package',
+            },
+            {
+                title: 'Tool',
+                description: 'Internal CLI or build tools (e.g., codegen, bundler)',
+                value: 'tool',
+            },
+        ];
+        const policy = {
+            freezable: {
+                label: 'Freezable',
+                description: 'Non-versioned (0.0.0) and never published (private: true)',
+            },
+            trackable: {
+                label: 'Trackable',
+                description: 'Versioned (>=0.0.1) and never published (private: true)',
+            },
+            distributable: {
+                label: 'Distributable',
+                description: 'Versioned (>=0.0.1) and published (private: false)',
+            },
+        };
+        const resolveName = async (role) => {
+            if (role === 'project' || role === 'docs') {
+                if (options.projectSlug === undefined) {
+                    return (role === 'project') ? 'project' : 'docs';
+                }
+                return `${options.projectSlug}-${role}`;
+            }
+            const base = (options.projectSlug !== undefined) ? `${options.projectSlug}-${role}` : role;
+            const namePrompt = await CLIUtilityInitialize.promptWithCancel({
+                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).';
+                    }
+                },
+            });
+            if (namePrompt.cancelled) {
+                return undefined;
+            }
+            const name = namePrompt.result.workspaceName.trim();
+            return (name === '') ? undefined : name;
+        };
+        const rolePrompt = await CLIUtilityInitialize.promptWithCancel({
+            type: 'select',
+            name: 'workspaceRole',
+            message: `Select a role for "${options.workspacePath}"`,
+            choices: allowedRoles.map((role) => ({
+                title: role.title,
+                description: role.description,
+                value: role.value,
+            })),
+            initial: Math.max(0, allowedRoles.findIndex((role) => role.value === options.existingWorkspace.role)),
+        });
+        if (rolePrompt.cancelled) {
+            return {
+                action: 'back',
+            };
+        }
+        const selectedRole = rolePrompt.result.workspaceRole;
+        const allowedPolicies = itemAllowedPoliciesByRole[selectedRole];
+        const policyPrompt = await CLIUtilityInitialize.promptWithCancel({
+            type: 'select',
+            name: 'workspacePolicy',
+            message: 'Select a policy',
+            choices: allowedPolicies.map((allowedPolicy) => ({
+                title: policy[allowedPolicy].label,
+                description: policy[allowedPolicy].description,
+                value: allowedPolicy,
+            })),
+            initial: Math.max(0, allowedPolicies.findIndex((policy) => policy === options.existingWorkspace.policy)),
+        });
+        if (policyPrompt.cancelled) {
+            return {
+                action: 'back',
+            };
+        }
+        const selectedPolicy = policyPrompt.result.workspacePolicy;
+        const resolvedName = await resolveName(selectedRole);
+        if (resolvedName === undefined) {
+            return {
+                action: 'back',
+            };
+        }
+        return {
+            action: 'apply',
+            workspace: {
+                name: resolvedName,
+                role: selectedRole,
+                policy: selectedPolicy,
+            },
+        };
+    }
+    static async promptWithCancel(questions) {
+        let cancelled = false;
+        const result = await prompts(questions, {
+            onCancel: () => {
+                cancelled = true;
+                return false;
+            },
+        });
+        if (cancelled) {
+            return {
+                cancelled: true,
+            };
+        }
+        return {
+            cancelled: false,
+            result,
+        };
+    }
+    static async checkPath(currentDirectory) {
+        const locations = await discoverPathsWithFile('package.json', 'backward');
+        Logger.customize({ name: 'CLIUtilityInitialize.checkPath::detectedLocations' }).debug(locations);
+        if (locations.length < 1) {
+            Logger.customize({
+                name: 'CLIUtilityInitialize.checkPath::lessThanOne',
+                padBottom: 1,
+            }).error([
+                'No "package.json" files were found. Re-run this command inside the project root directory.',
+                `Current directory is "${currentDirectory}"`,
+            ].join('\n'));
+            return false;
+        }
+        if (locations.length > 1) {
+            Logger.customize({
+                name: 'CLIUtilityInitialize.checkPath::greaterThanOne',
+                padBottom: 1,
+            }).error([
+                'Multiple "package.json" files were found. Re-run this command inside the project root directory.',
+                `Current directory is "${currentDirectory}"`,
+            ].join('\n'));
+            return false;
+        }
+        if (locations.length === 1 && locations[0] !== currentDirectory) {
+            Logger.customize({
+                name: 'CLIUtilityInitialize.checkPath::notProjectRootDir',
+                padBottom: 1,
+            }).error([
+                'Must be run inside the project root directory.',
+                `Current directory is "${currentDirectory}"`,
+            ].join('\n'));
+            return false;
+        }
+        return true;
+    }
+    static validateHttpUrl(value, field) {
+        const trimmed = value.trim();
+        if (trimmed === '') {
+            return true;
+        }
+        if (CLIUtilityInitialize.isAllowedHttpUrl(trimmed, field)) {
+            return true;
+        }
+        return 'Enter a valid URL (http:// or https://) or leave blank.';
+    }
+    static validateFundSources(value) {
+        const trimmed = value.trim();
+        if (trimmed === '') {
+            return true;
+        }
+        const parts = trimmed
+            .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.';
+            }
+        }
+        return true;
+    }
+    static sanitizeHttpUrl(value, field) {
+        if (typeof value !== 'string') {
+            return undefined;
+        }
+        const trimmed = value.trim();
+        if (trimmed === '') {
+            return undefined;
+        }
+        try {
+            const parsedUrl = new URL(trimmed);
+            if (CLIUtilityInitialize.isAllowedHttpUrl(parsedUrl.toString(), field)) {
+                return parsedUrl.toString();
+            }
+        }
+        catch {
+        }
+        return 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);
+        }
+        catch {
+            return false;
+        }
+    }
+}
+//# sourceMappingURL=initialize.js.map