wizz-method 2.0.0 → 2.1.1

package/tools/installer/modules/config-collector.js

@@ -0,0 +1,762 @@
+/**
+ * Lado "coleta de configuração" de OfficialModules — item 20, etapa 3
+ * (auditoria 2026-09-11).
+ *
+ * Único módulo do split que importa `prompts`: collectAllConfigurations
+ * (gateway express/customize), collectModuleConfig(Quick), buildQuestion e
+ * a exibição das post-install notes. Os helpers puros de valor
+ * (processResultTemplate, replacePlaceholders, resolveConfigValue,
+ * normalizeExistingValueForPrompt, ...) foram para config-values.js e voltam
+ * por spread, sem mudar nada para os callers.
+ *
+ * Os métodos são montados no prototype de OfficialModules (Object.assign em
+ * official-modules.js): o estado da coleta (collectedConfig, allAnswers,
+ * _existingConfig, currentProjectDir, _silentConfig, skipPrompts,
+ * modulesToCustomize) vive na mesma instância usada pelo install.
+ */
+
+const path = require('node:path');
+const prompts = require('../prompts');
+const { CLIUtils } = require('../banner');
+const { getProjectRoot } = require('../project-root');
+const { isMissingDefault, resolveModuleConfigPath, MODULE_METADATA_FIELDS } = require('./module-catalog');
+const { loadYamlCached } = require('../core/yaml-cache');
+const { ConfigValueMethods, buildQuestionChoices } = require('./config-values');
+
+const ConfigCollectorMethods = {
+  // Helpers puros de valor (processResultTemplate, replacePlaceholders,
+  // resolveConfigValue, ...) moram em config-values.js desde o item 20 e são
+  // remontados aqui para os callers continuarem chamando-os como métodos.
+  ...ConfigValueMethods,
+  /**
+   * Collect configuration for all modules
+   * @param {Array} modules - List of modules to configure (including 'core')
+   * @param {string} projectDir - Target project directory
+   * @param {Object} options - Additional options
+   * @param {boolean} options.skipPrompts - Skip prompts and use defaults (for --yes flag)
+   */
+  async collectAllConfigurations(modules, projectDir, options = {}) {
+    this.skipPrompts = options.skipPrompts || false;
+    this.modulesToCustomize = undefined;
+    await this.loadExistingConfig(projectDir);
+
+    // Check if core was already collected (e.g., in early collection phase)
+    const coreAlreadyCollected = this.collectedConfig.core && Object.keys(this.collectedConfig.core).length > 0;
+
+    // If core wasn't already collected, include it
+    const allModules = coreAlreadyCollected ? modules.filter((m) => m !== 'core') : ['core', ...modules.filter((m) => m !== 'core')];
+
+    // Store all answers across modules for cross-referencing
+    if (!this.allAnswers) {
+      this.allAnswers = {};
+    }
+
+    // Split processing: core first, then gateway, then remaining modules
+    const coreModules = allModules.filter((m) => m === 'core');
+    const nonCoreModules = allModules.filter((m) => m !== 'core');
+
+    // Collect core config first (always fully prompted)
+    for (const moduleName of coreModules) {
+      await this.collectModuleConfig(moduleName, projectDir);
+    }
+
+    // Show batch configuration gateway for non-core modules
+    // Scan all non-core module schemas for display names and config metadata
+    let scannedModules = [];
+    if (!this.skipPrompts && nonCoreModules.length > 0) {
+      scannedModules = await this.scanModuleSchemas(nonCoreModules);
+      const customizableModules = scannedModules.filter((m) => m.questionCount > 0);
+
+      if (customizableModules.length > 0) {
+        const configMode = await prompts.select({
+          message: 'Module configuration',
+          choices: [
+            { name: 'Express Setup', value: 'express', hint: 'accept all defaults (recommended)' },
+            { name: 'Customize', value: 'customize', hint: 'choose modules to configure' },
+          ],
+          default: 'express',
+        });
+
+        if (configMode === 'customize') {
+          const choices = customizableModules.map((m) => ({
+            name: `${m.displayName} (${m.questionCount} option${m.questionCount === 1 ? '' : 's'})`,
+            value: m.moduleName,
+            hint: m.hasFieldsWithoutDefaults ? 'has fields without defaults' : undefined,
+            checked: m.hasFieldsWithoutDefaults,
+          }));
+          const selected = await prompts.multiselect({
+            message: 'Select modules to customize:',
+            choices,
+            required: false,
+          });
+          this.modulesToCustomize = new Set(selected);
+        } else {
+          // Express mode: no modules to customize
+          this.modulesToCustomize = new Set();
+        }
+      } else {
+        // All non-core modules have zero config - no gateway needed
+        this.modulesToCustomize = new Set();
+      }
+    }
+
+    // Collect remaining non-core modules
+    if (this.modulesToCustomize === undefined) {
+      // No gateway was shown (skipPrompts, no non-core modules, or direct call) - process all normally
+      for (const moduleName of nonCoreModules) {
+        await this.collectModuleConfig(moduleName, projectDir);
+      }
+    } else {
+      // Split into default modules (tasks progress) and customized modules (interactive)
+      const defaultModules = nonCoreModules.filter((m) => !this.modulesToCustomize.has(m));
+      const customizeModules = nonCoreModules.filter((m) => this.modulesToCustomize.has(m));
+
+      // Run default modules with a single spinner
+      if (defaultModules.length > 0) {
+        // Build display name map from all scanned modules for pre-call spinner messages
+        const displayNameMap = new Map();
+        for (const m of scannedModules) {
+          displayNameMap.set(m.moduleName, m.displayName);
+        }
+
+        const configSpinner = await prompts.spinner();
+        configSpinner.start('Configuring modules...');
+        try {
+          for (const moduleName of defaultModules) {
+            const displayName = displayNameMap.get(moduleName) || moduleName.toUpperCase();
+            configSpinner.message(`Configuring ${displayName}...`);
+            try {
+              this._silentConfig = true;
+              await this.collectModuleConfig(moduleName, projectDir);
+            } finally {
+              this._silentConfig = false;
+            }
+          }
+        } finally {
+          configSpinner.stop(customizeModules.length > 0 ? 'Module defaults applied' : 'Module configuration complete');
+        }
+      }
+
+      // Run customized modules individually (may show interactive prompts)
+      for (const moduleName of customizeModules) {
+        await this.collectModuleConfig(moduleName, projectDir);
+      }
+
+      if (customizeModules.length > 0) {
+        await prompts.log.step('Module configuration complete');
+      }
+    }
+
+    // Add metadata
+    this.collectedConfig._meta = {
+      version: require(path.join(getProjectRoot(), 'package.json')).version,
+      installDate: new Date().toISOString(),
+      lastModified: new Date().toISOString(),
+    };
+
+    return this.collectedConfig;
+  },
+  /**
+   * Collect configuration for a single module (Quick Update mode - only new fields)
+   * @param {string} moduleName - Module name
+   * @param {string} projectDir - Target project directory
+   * @param {boolean} silentMode - If true, only prompt for new/missing fields
+   * @returns {boolean} True if new fields were prompted, false if all fields existed
+   */
+  async collectModuleConfigQuick(moduleName, projectDir, silentMode = true) {
+    this.currentProjectDir = projectDir;
+    // Load existing config if not already loaded
+    if (!this._existingConfig) {
+      await this.loadExistingConfig(projectDir);
+    }
+
+    // Initialize allAnswers if not already initialized
+    if (!this.allAnswers) {
+      this.allAnswers = {};
+    }
+
+    // Load module's config schema from module.yaml ( resolução unificada no
+    // catálogo — item 20, etapa 2: o mesmo bloco estava copiado 3x)
+    const moduleConfigPath = await resolveModuleConfigPath((code, opts) => this.findModuleSource(code, opts), moduleName);
+
+    const moduleConfig = moduleConfigPath ? await loadYamlCached(moduleConfigPath) : null;
+
+    // No usable config schema for this module — keep the existing values.
+    // `moduleConfigPath` is non-null whenever a module SOURCE was found, even
+    // if that source has no module.yaml; before the item 20 split the check
+    // was `pathExists(module.yaml)`, so both cases landed here. Treating only
+    // the null-path case as "no schema" silently dropped the module's prior
+    // answers from collectedConfig on quick update.
+    if (!moduleConfig) {
+      if (this._existingConfig && this._existingConfig[moduleName]) {
+        if (!this.collectedConfig[moduleName]) {
+          this.collectedConfig[moduleName] = {};
+        }
+        this.collectedConfig[moduleName] = { ...this._existingConfig[moduleName] };
+      }
+      return false;
+    }
+
+    // Compare schema with existing config to find new/missing fields
+    const configKeys = Object.keys(moduleConfig).filter((key) => key !== 'prompt');
+    const existingKeys = this._existingConfig && this._existingConfig[moduleName] ? Object.keys(this._existingConfig[moduleName]) : [];
+
+    // Check if this module has no configuration keys at all (like CIS)
+    // Filter out metadata fields and only count actual config objects
+    const actualConfigKeys = configKeys.filter((key) => !MODULE_METADATA_FIELDS.has(key));
+    const hasNoConfig = actualConfigKeys.length === 0;
+
+    // If module has no config keys at all, handle it specially
+    if (hasNoConfig && moduleConfig.subheader) {
+      const moduleDisplayName = moduleConfig.header || `${moduleName.toUpperCase()} Module`;
+      await prompts.log.step(moduleDisplayName);
+      await prompts.log.message(`  \u2713 ${moduleConfig.subheader}`);
+      return false; // No new fields
+    }
+
+    // Find new interactive fields (with prompt)
+    const newKeys = configKeys.filter((key) => {
+      const item = moduleConfig[key];
+      // Check if it's a config item and doesn't exist in existing config
+      return item && typeof item === 'object' && item.prompt && !existingKeys.includes(key);
+    });
+
+    // Find new static fields (without prompt, just result)
+    const newStaticKeys = configKeys.filter((key) => {
+      const item = moduleConfig[key];
+      return item && typeof item === 'object' && !item.prompt && item.result && !existingKeys.includes(key);
+    });
+
+    // If in silent mode and no new keys (neither interactive nor static), use existing config and skip prompts
+    if (silentMode && newKeys.length === 0 && newStaticKeys.length === 0) {
+      if (this._existingConfig && this._existingConfig[moduleName]) {
+        if (!this.collectedConfig[moduleName]) {
+          this.collectedConfig[moduleName] = {};
+        }
+        this.collectedConfig[moduleName] = { ...this._existingConfig[moduleName] };
+
+        // Special handling for user_name: ensure it has a value
+        if (
+          moduleName === 'core' &&
+          (!this.collectedConfig[moduleName].user_name || this.collectedConfig[moduleName].user_name === '[USER_NAME]')
+        ) {
+          this.collectedConfig[moduleName].user_name = this.getDefaultUsername();
+        }
+
+        // Also populate allAnswers for cross-referencing
+        for (const [key, value] of Object.entries(this._existingConfig[moduleName])) {
+          // Ensure user_name is properly set in allAnswers too
+          let finalValue = value;
+          if (moduleName === 'core' && key === 'user_name' && (!value || value === '[USER_NAME]')) {
+            finalValue = this.getDefaultUsername();
+          }
+          this.allAnswers[`${moduleName}_${key}`] = finalValue;
+        }
+      } else if (moduleName === 'core') {
+        // No existing core config - ensure we at least have user_name
+        if (!this.collectedConfig[moduleName]) {
+          this.collectedConfig[moduleName] = {};
+        }
+        if (!this.collectedConfig[moduleName].user_name) {
+          this.collectedConfig[moduleName].user_name = this.getDefaultUsername();
+          this.allAnswers[`${moduleName}_user_name`] = this.getDefaultUsername();
+        }
+      }
+
+      // Show "no config" message for modules with no new questions (that have config keys)
+      await prompts.log.message(`  \u2713 ${moduleName.toUpperCase()} module already up to date`);
+      return false; // No new fields
+    }
+
+    // If we have new fields (interactive or static), process them
+    if (newKeys.length > 0 || newStaticKeys.length > 0) {
+      const questions = [];
+      const staticAnswers = {};
+
+      // Build questions for interactive fields
+      for (const key of newKeys) {
+        const item = moduleConfig[key];
+        const question = await this.buildQuestion(moduleName, key, item, moduleConfig);
+        if (question) {
+          questions.push(question);
+        }
+      }
+
+      // Prepare static answers (no prompt, just result)
+      for (const key of newStaticKeys) {
+        staticAnswers[`${moduleName}_${key}`] = undefined;
+      }
+
+      // Collect all answers (static + prompted)
+      let allAnswers = { ...staticAnswers };
+
+      if (questions.length > 0 && silentMode) {
+        // In silent mode (quick update), use defaults for new fields instead of prompting
+        for (const q of questions) {
+          allAnswers[q.name] = typeof q.default === 'function' ? q.default({}) : q.default;
+        }
+        await prompts.log.message(`  \u2713 ${moduleName.toUpperCase()} module configured with defaults`);
+      } else if (questions.length > 0) {
+        // Only show header if we actually have questions
+        await CLIUtils.displayModuleConfigHeader(moduleName, moduleConfig.header, moduleConfig.subheader);
+        await prompts.log.message('');
+        const promptedAnswers = await prompts.prompt(questions);
+
+        // Merge prompted answers with static answers
+        Object.assign(allAnswers, promptedAnswers);
+      } else if (newStaticKeys.length > 0) {
+        // Only static fields, no questions - show no config message
+        await prompts.log.message(`  \u2713 ${moduleName.toUpperCase()} module configuration updated`);
+      }
+
+      // Store all answers for cross-referencing
+      Object.assign(this.allAnswers, allAnswers);
+
+      // Process all answers (both static and prompted)
+      // First, copy existing config to preserve values that aren't being updated
+      if (this._existingConfig && this._existingConfig[moduleName]) {
+        this.collectedConfig[moduleName] = { ...this._existingConfig[moduleName] };
+      } else {
+        this.collectedConfig[moduleName] = {};
+      }
+
+      for (const key of Object.keys(allAnswers)) {
+        const originalKey = key.replace(`${moduleName}_`, '');
+        const item = moduleConfig[originalKey];
+        const value = allAnswers[key];
+
+        let result;
+        if (Array.isArray(value)) {
+          result = value;
+        } else if (item.result) {
+          result = this.processResultTemplate(item.result, value);
+        } else {
+          result = value;
+        }
+
+        // Update the collected config with new/updated values
+        this.collectedConfig[moduleName][originalKey] = result;
+      }
+    }
+
+    // Copy over existing values for fields that weren't prompted
+    if (this._existingConfig && this._existingConfig[moduleName]) {
+      if (!this.collectedConfig[moduleName]) {
+        this.collectedConfig[moduleName] = {};
+      }
+      for (const [key, value] of Object.entries(this._existingConfig[moduleName])) {
+        if (!this.collectedConfig[moduleName][key]) {
+          this.collectedConfig[moduleName][key] = value;
+          this.allAnswers[`${moduleName}_${key}`] = value;
+        }
+      }
+    }
+
+    await this.displayModulePostConfigNotes(moduleName, moduleConfig);
+
+    return newKeys.length > 0 || newStaticKeys.length > 0; // Return true if we had any new fields (interactive or static)
+  },
+  /**
+   * Collect configuration for a single module
+   * @param {string} moduleName - Module name
+   * @param {string} projectDir - Target project directory
+   * @param {boolean} skipLoadExisting - Skip loading existing config (for early core collection)
+   * @param {boolean} skipCompletion - Skip showing completion message (for early core collection)
+   */
+  async collectModuleConfig(moduleName, projectDir, skipLoadExisting = false, skipCompletion = false) {
+    this.currentProjectDir = projectDir;
+    // Load existing config if needed and not already loaded
+    if (!skipLoadExisting && !this._existingConfig) {
+      await this.loadExistingConfig(projectDir);
+    }
+
+    // Initialize allAnswers if not already initialized
+    if (!this.allAnswers) {
+      this.allAnswers = {};
+    }
+    // Load module's config (resolução unificada no catálogo — item 20, etapa 2)
+    const moduleConfigPath = await resolveModuleConfigPath((code, opts) => this.findModuleSource(code, opts), moduleName);
+
+    if (!moduleConfigPath) {
+      // No config for this module
+      return;
+    }
+
+    const moduleConfig = await loadYamlCached(moduleConfigPath);
+
+    if (!moduleConfig) {
+      return;
+    }
+
+    // Process each config item
+    const questions = [];
+    const staticAnswers = {};
+    const configKeys = Object.keys(moduleConfig).filter((key) => key !== 'prompt');
+
+    for (const key of configKeys) {
+      const item = moduleConfig[key];
+
+      // Skip if not a config object
+      if (!item || typeof item !== 'object') {
+        continue;
+      }
+
+      // Handle static values (no prompt, just result)
+      if (!item.prompt && item.result) {
+        // Add to static answers with a marker value
+        staticAnswers[`${moduleName}_${key}`] = undefined;
+        continue;
+      }
+
+      // Handle interactive values (with prompt)
+      if (item.prompt) {
+        const question = await this.buildQuestion(moduleName, key, item, moduleConfig);
+        if (question) {
+          questions.push(question);
+        }
+      }
+    }
+
+    // Collect all answers (static + prompted)
+    let allAnswers = { ...staticAnswers };
+
+    // If there are questions to ask, prompt for accepting defaults vs customizing
+    if (questions.length > 0) {
+      const moduleDisplayName = moduleConfig.header || `${moduleName.toUpperCase()} Module`;
+
+      // Skip prompts mode: use all defaults without asking
+      if (this.skipPrompts) {
+        await prompts.log.info(`Using default configuration for ${moduleDisplayName}`);
+        // Use defaults for all questions
+        for (const question of questions) {
+          const hasDefault = !isMissingDefault(question.default);
+          if (hasDefault && typeof question.default !== 'function') {
+            allAnswers[question.name] = question.default;
+          }
+        }
+      } else {
+        if (!this._silentConfig) await prompts.log.step(`Configuring ${moduleDisplayName}`);
+        let useDefaults = true;
+        if (moduleName === 'core') {
+          useDefaults = false; // Core: always show all questions
+        } else if (this.modulesToCustomize === undefined) {
+          // Fallback: original per-module confirm (backward compat for direct calls)
+          const customizeAnswer = await prompts.prompt([
+            {
+              type: 'confirm',
+              name: 'customize',
+              message: 'Accept Defaults (no to customize)?',
+              default: true,
+            },
+          ]);
+          useDefaults = customizeAnswer.customize;
+        } else {
+          // Batch mode: use defaults unless module was selected for customization
+          useDefaults = !this.modulesToCustomize.has(moduleName);
+        }
+
+        if (useDefaults && moduleName !== 'core') {
+          // Accept defaults - only ask questions that have NO default value
+          const questionsWithoutDefaults = questions.filter((q) => isMissingDefault(q.default));
+
+          if (questionsWithoutDefaults.length > 0) {
+            await prompts.log.message(`  Asking required questions for ${moduleName.toUpperCase()}...`);
+            const promptedAnswers = await prompts.prompt(questionsWithoutDefaults);
+            Object.assign(allAnswers, promptedAnswers);
+          }
+
+          // For questions with defaults that weren't asked, we need to process them with their default values
+          const questionsWithDefaults = questions.filter((q) => !isMissingDefault(q.default));
+          for (const question of questionsWithDefaults) {
+            // Skip function defaults - these are dynamic and will be evaluated later
+            if (typeof question.default === 'function') {
+              continue;
+            }
+            allAnswers[question.name] = question.default;
+          }
+        } else {
+          const promptedAnswers = await prompts.prompt(questions);
+          Object.assign(allAnswers, promptedAnswers);
+        }
+      }
+    }
+
+    // Store all answers for cross-referencing
+    Object.assign(this.allAnswers, allAnswers);
+
+    // Process all answers (both static and prompted)
+    // Always process if we have any answers or static answers
+    if (Object.keys(allAnswers).length > 0 || Object.keys(staticAnswers).length > 0) {
+      const answers = allAnswers;
+
+      // Process answers and build result values
+      for (const key of Object.keys(answers)) {
+        const originalKey = key.replace(`${moduleName}_`, '');
+        const item = moduleConfig[originalKey];
+        const value = answers[key];
+
+        // Build the result using the template (OM-01: usa o processResultTemplate
+        // compartilhado em vez da reimplementação inline que tinha aqui — as duas
+        // versões já tinham divergido no lookup cross-module)
+        let result;
+        if (Array.isArray(value)) {
+          result = value;
+        } else if (item.result) {
+          result = this.processResultTemplate(item.result, value);
+        } else {
+          result = value;
+        }
+
+        // Store only the result value (no prompts, defaults, examples, etc.)
+        if (!this.collectedConfig[moduleName]) {
+          this.collectedConfig[moduleName] = {};
+        }
+        this.collectedConfig[moduleName][originalKey] = result;
+      }
+
+      // No longer display completion boxes - keep output clean
+    } else {
+      // No questions for this module - show completion message with header if available
+      const moduleDisplayName = moduleConfig.header || `${moduleName.toUpperCase()} Module`;
+
+      // Check if this module has NO configuration keys at all (like CIS)
+      // Filter out metadata fields and only count actual config objects
+      const actualConfigKeys = configKeys.filter((key) => !MODULE_METADATA_FIELDS.has(key));
+      const hasNoConfig = actualConfigKeys.length === 0;
+
+      if (!this._silentConfig) {
+        if (hasNoConfig && (moduleConfig.subheader || moduleConfig.header)) {
+          await prompts.log.step(moduleDisplayName);
+          if (moduleConfig.subheader) {
+            await prompts.log.message(`  \u2713 ${moduleConfig.subheader}`);
+          } else {
+            await prompts.log.message(`  \u2713 No custom configuration required`);
+          }
+        } else {
+          // Module has config but just no questions to ask
+          await prompts.log.message(`  \u2713 ${moduleName.toUpperCase()} module configured`);
+        }
+      }
+    }
+
+    // If we have no collected config for this module, but we have a module schema,
+    // ensure we have at least an empty object
+    if (!this.collectedConfig[moduleName]) {
+      this.collectedConfig[moduleName] = {};
+
+      // If we accepted defaults and have no answers, we still need to check
+      // if there are any static values in the schema that should be applied
+      if (moduleConfig) {
+        for (const key of Object.keys(moduleConfig)) {
+          if (key !== 'prompt' && moduleConfig[key] && typeof moduleConfig[key] === 'object') {
+            const item = moduleConfig[key];
+            // For static items (no prompt, just result), apply the result
+            if (!item.prompt && item.result) {
+              // Apply any placeholder replacements to the result
+              let result = item.result;
+              if (typeof result === 'string') {
+                result = this.replacePlaceholders(result, moduleName, moduleConfig);
+              }
+              this.collectedConfig[moduleName][key] = result;
+            }
+          }
+        }
+      }
+    }
+
+    await this.displayModulePostConfigNotes(moduleName, moduleConfig);
+  },
+  /**
+   * Build a prompt question from a config item
+   * @param {string} moduleName - Module name
+   * @param {string} key - Config key
+   * @param {Object} item - Config item definition
+   * @param {Object} moduleConfig - Full module config schema (for resolving defaults)
+   */
+  async buildQuestion(moduleName, key, item, moduleConfig = null) {
+    const questionName = `${moduleName}_${key}`;
+
+    // Check for existing value
+    let existingValue = null;
+    if (this._existingConfig && this._existingConfig[moduleName]) {
+      existingValue = this._existingConfig[moduleName][key];
+      existingValue = this.normalizeExistingValueForPrompt(existingValue, moduleName, item, moduleConfig);
+    }
+
+    // Special handling for user_name: default to system user
+    if (moduleName === 'core' && key === 'user_name' && !existingValue) {
+      item.default = this.getDefaultUsername();
+    }
+
+    // Determine question type and default value (helpers puros em
+    // config-values.js — item 20)
+    const resolved = this.resolveQuestionDefault(item.default, moduleName, moduleConfig);
+    let defaultValue = resolved.defaultValue;
+    const dynamicDefault = resolved.dynamicDefault;
+
+    // Handle different question types
+    const { questionType, choices } = buildQuestionChoices(item, existingValue, defaultValue);
+    if (questionType === 'list' && existingValue) {
+      defaultValue = existingValue;
+    }
+
+    // Build the prompt message
+    let message = '';
+
+    // Handle array prompts for multi-line messages
+    if (Array.isArray(item.prompt)) {
+      message = item.prompt.join('\n');
+    } else {
+      message = item.prompt;
+    }
+
+    // Replace placeholders in prompt message with collected config values
+    if (typeof message === 'string') {
+      message = this.replacePlaceholders(message, moduleName, moduleConfig);
+    }
+
+    // Add current value indicator for existing configs
+    const color = await prompts.getColor();
+    if (existingValue !== null && existingValue !== undefined) {
+      if (typeof existingValue === 'boolean') {
+        message += color.dim(` (current: ${existingValue ? 'true' : 'false'})`);
+      } else if (Array.isArray(existingValue)) {
+        message += color.dim(` (current: ${existingValue.join(', ')})`);
+      } else if (questionType !== 'list') {
+        // Show the cleaned value (without {project-root}/) for display
+        message += color.dim(` (current: ${existingValue})`);
+      }
+    } else if (item.example && questionType === 'input') {
+      // Show example for input fields
+      let exampleText = typeof item.example === 'string' ? item.example : JSON.stringify(item.example);
+      // Replace placeholders in example
+      if (typeof exampleText === 'string') {
+        exampleText = this.replacePlaceholders(exampleText, moduleName, moduleConfig);
+        exampleText = exampleText.replace('{project-root}/', '');
+      }
+      message += color.dim(` (e.g., ${exampleText})`);
+    }
+
+    // Build the question object
+    const question = {
+      type: questionType,
+      name: questionName,
+      message: message,
+    };
+
+    // Set default - if it's dynamic, use a function that the prompt will evaluate with current answers
+    // But if we have an existing value, always use that instead
+    if (existingValue !== null && existingValue !== undefined && questionType !== 'list') {
+      question.default = existingValue;
+    } else if (dynamicDefault && typeof item.default === 'string') {
+      const originalDefault = item.default;
+      question.default = (answers) => {
+        // Replace placeholders using answers from previous questions in the same batch
+        let resolved = originalDefault;
+        resolved = resolved.replaceAll(/{([^}]+)}/g, (match, fieldName) => {
+          // Look for the answer in the current batch (prefixed with module name)
+          const answerKey = `${moduleName}_${fieldName}`;
+          if (answers[answerKey] !== undefined) {
+            return answers[answerKey];
+          }
+          // Fall back to collected config
+          return this.collectedConfig[moduleName]?.[fieldName] || match;
+        });
+        // Strip {project-root}/ for cleaner display
+        if (resolved.includes('{project-root}/')) {
+          resolved = resolved.replace('{project-root}/', '');
+        }
+        return resolved;
+      };
+    } else {
+      question.default = defaultValue;
+    }
+
+    // Add choices for select types
+    if (choices) {
+      question.choices = choices;
+    }
+
+    // Add validation for input fields
+    if (questionType === 'input') {
+      question.validate = (input) => {
+        if (!input && item.required) {
+          return 'This field is required';
+        }
+        // Validate against regex pattern if provided
+        if (input && item.regex) {
+          const regex = new RegExp(item.regex);
+          if (!regex.test(input)) {
+            return `Invalid format. Must match pattern: ${item.regex}`;
+          }
+        }
+        return true;
+      };
+    }
+
+    // Add validation for checkbox (multi-select) fields
+    if (questionType === 'checkbox' && item.required) {
+      question.validate = (answers) => {
+        if (!answers || answers.length === 0) {
+          return 'At least one option must be selected';
+        }
+        return true;
+      };
+    }
+
+    return question;
+  },
+  /**
+   * Display post-configuration notes for a module
+   * Shows prerequisite guidance based on collected config values
+   * Reads notes from the module's `post-install-notes` section in module.yaml
+   * Supports two formats:
+   *   - Simple string: always displayed
+   *   - Object keyed by config field name, with value-specific messages
+   * @param {string} moduleName - Module name
+   * @param {Object} moduleConfig - Parsed module.yaml content
+   */
+  async displayModulePostConfigNotes(moduleName, moduleConfig) {
+    if (this._silentConfig) return;
+    if (!moduleConfig || !moduleConfig['post-install-notes']) return;
+
+    const notes = moduleConfig['post-install-notes'];
+    const color = await prompts.getColor();
+
+    // Format 1: Simple string - always display
+    if (typeof notes === 'string') {
+      await prompts.log.message('');
+      for (const line of notes.trim().split('\n')) {
+        await prompts.log.message(color.dim(line));
+      }
+      return;
+    }
+
+    // Format 2: Conditional on config values
+    if (typeof notes === 'object') {
+      const config = this.collectedConfig[moduleName];
+      if (!config) return;
+
+      let hasOutput = false;
+      for (const [configKey, valueMessages] of Object.entries(notes)) {
+        const selectedValue = config[configKey];
+        if (!selectedValue || !valueMessages[selectedValue]) continue;
+
+        if (hasOutput) await prompts.log.message('');
+        hasOutput = true;
+
+        const message = valueMessages[selectedValue];
+        for (const line of message.trim().split('\n')) {
+          const trimmedLine = line.trim();
+          if (trimmedLine.endsWith(':') && !trimmedLine.startsWith(' ')) {
+            await prompts.log.info(color.bold(trimmedLine));
+          } else {
+            await prompts.log.message(color.dim('  ' + trimmedLine));
+          }
+        }
+      }
+    }
+  },
+};
+
+module.exports = { ConfigCollectorMethods };