@aifabrix/builder 2.40.2 → 2.42.0

package/lib/generator/wizard-prompts-secondary.js

@@ -0,0 +1,294 @@
+/**
+ * @fileoverview Secondary wizard prompts (credential retry, platform, config review)
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+const inquirer = require('inquirer');
+const yaml = require('js-yaml');
+
+let hasAutocompletePrompt = false;
+try {
+  const AutocompletePrompt = require('inquirer-autocomplete-prompt');
+  inquirer.registerPrompt('autocomplete', AutocompletePrompt);
+  hasAutocompletePrompt = true;
+} catch {
+  // Fallback: use 'list' if plugin not installed (no search, pageSize 10)
+}
+
+/**
+ * Re-prompt for credential ID/key when validation failed (e.g. not found on dataplane).
+ * Empty input means skip.
+ * @async
+ * @param {string} [previousError] - Error message from dataplane (e.g. "Credential not found")
+ * @returns {Promise<Object>} { credentialIdOrKey: string } or { skip: true } if user leaves empty
+ */
+async function promptForCredentialIdOrKeyRetry(previousError) {
+  const msg = previousError
+    ? `Credential not found or invalid (${String(previousError).slice(0, 60)}). Enter ID/key or leave empty to skip:`
+    : 'Enter credential ID or key (or leave empty to skip):';
+  const { credentialIdOrKey } = await inquirer.prompt([
+    { type: 'input', name: 'credentialIdOrKey', message: msg, default: '' }
+  ]);
+  const trimmed = (credentialIdOrKey && credentialIdOrKey.trim()) || '';
+  return trimmed ? { credentialIdOrKey: trimmed } : { skip: true };
+}
+
+/**
+ * Prompt for known platform selection
+ * @async
+ * @param {Array<{key: string, displayName?: string}>} [platforms] - List of available platforms
+ * @returns {Promise<string>} Selected platform key
+ */
+async function promptForKnownPlatform(platforms = []) {
+  const defaultPlatforms = [
+    { name: 'HubSpot', value: 'hubspot' },
+    { name: 'Salesforce', value: 'salesforce' },
+    { name: 'Zendesk', value: 'zendesk' },
+    { name: 'Slack', value: 'slack' },
+    { name: 'Microsoft 365', value: 'microsoft365' }
+  ];
+  const choices = platforms.length > 0
+    ? platforms.map(p => ({ name: p.displayName || p.key, value: p.key }))
+    : defaultPlatforms;
+  const { platform } = await inquirer.prompt([
+    { type: 'list', name: 'platform', message: 'Select a platform:', choices, pageSize: 10 }
+  ]);
+  return platform;
+}
+
+/**
+ * Format entity for display in list
+ * @param {Object} e - Entity { name, pathCount? }
+ * @returns {string} Display string
+ */
+function _formatEntityChoice(e) {
+  if (!e || typeof e.name !== 'string') return 'unknown';
+  return e.pathCount !== undefined && e.pathCount !== null ? `${e.name} (${e.pathCount} paths)` : e.name;
+}
+
+/**
+ * Prompt to select an entity from discover-entities list (searchable when plugin available)
+ * @async
+ * @param {Array<{name: string, pathCount?: number, schemaMatch?: boolean}>} entities - From discover-entities
+ * @returns {Promise<string>} Selected entity name
+ */
+async function promptForEntitySelection(entities = []) {
+  if (!Array.isArray(entities) || entities.length === 0) {
+    throw new Error('At least one entity is required');
+  }
+  const choices = entities.map(e => ({
+    name: _formatEntityChoice(e),
+    value: e.name
+  }));
+
+  const promptConfig = {
+    type: hasAutocompletePrompt ? 'autocomplete' : 'list',
+    name: 'entityName',
+    message: 'Select entity for datasource generation:',
+    choices,
+    pageSize: 10
+  };
+
+  if (hasAutocompletePrompt) {
+    promptConfig.source = (answers, input) => {
+      const q = (input || '').toLowerCase();
+      const filtered = entities.filter(e => (e.name || '').toLowerCase().includes(q));
+      return Promise.resolve(
+        filtered.map(e => ({ name: _formatEntityChoice(e), value: e.name }))
+      );
+    };
+  }
+
+  const { entityName } = await inquirer.prompt([promptConfig]);
+  return entityName;
+}
+
+/** @param {*} o - Value to stringify */
+const _s = (o) => (o === null || o === undefined || o === '' ? '—' : String(o));
+
+/** @param {Object} sys - systemSummary */
+function _formatSystem(sys) {
+  return [
+    '\nSystem',
+    `  Key:            ${_s(sys.key)}`,
+    `  Display name:   ${_s(sys.displayName)}`,
+    `  Type:           ${_s(sys.type)}`,
+    `  Base URL:       ${_s(sys.baseUrl)}`,
+    `  Auth:           ${_s(sys.authenticationType)}`,
+    `  Endpoints:      ${_s(sys.endpointCount)}`
+  ];
+}
+
+/** @param {Object} ds - datasourceSummary */
+function _formatDatasource(ds) {
+  return [
+    '\nDatasource',
+    `  Key:            ${_s(ds.key)}`,
+    `  Entity:         ${_s(ds.entity)}`,
+    `  Resource type:  ${_s(ds.resourceType)}`,
+    `  CIP steps:      ${_s(ds.cipStepCount)}`,
+    `  Field mappings: ${_s(ds.fieldMappingCount)}`,
+    `  Exposed:        ${_s(ds.exposedProfileCount)} profiles`
+  ];
+}
+
+/** @param {Object} fm - fieldMappingsSummary */
+function _formatFieldMappings(fm) {
+  const mapped = Array.isArray(fm.mappedFields) ? fm.mappedFields : [];
+  const unmapped = Array.isArray(fm.unmappedFields) ? fm.unmappedFields : [];
+  const mappedStr = mapped.length > 0
+    ? `${mapped.length} (${mapped.slice(0, 5).join(', ')}${mapped.length > 5 ? ', ...' : ''})`
+    : _s(fm.mappingCount);
+  const unmappedStr = unmapped.length > 0
+    ? `${unmapped.length} (${unmapped.slice(0, 3).join(', ')}${unmapped.length > 3 ? ', ...' : ''})`
+    : '0';
+  return ['\nField Mappings', `  Mapped:   ${mappedStr}`, `  Unmapped: ${unmappedStr}`];
+}
+
+/**
+ * Derive a preview summary from systemConfig and datasourceConfigs when the dataplane
+ * preview API does not return summaries. Ensures a compact summary is always shown.
+ * @param {Object} systemConfig - System configuration
+ * @param {Object[]} datasourceConfigs - Array of datasource configurations
+ * @returns {Object} Preview object compatible with formatPreviewSummary
+ */
+function _buildDatasourceSummary(ds) {
+  let fieldMappingCount = 0;
+  const attrs = ds.fieldMappings?.attributes ?? ds.attributes ?? {};
+  if (typeof attrs === 'object' && !Array.isArray(attrs)) {
+    fieldMappingCount = Object.keys(attrs).length;
+  }
+  const exposedCount = ds.exposed?.attributes?.length ?? 0;
+  return {
+    key: ds.key,
+    entity: ds.entityType ?? ds.entity ?? ds.resourceType ?? ds.key?.split('-').pop(),
+    resourceType: ds.resourceType,
+    cipStepCount: null,
+    fieldMappingCount: fieldMappingCount || null,
+    exposedProfileCount: exposedCount || null
+  };
+}
+
+function _buildSystemSummary(sys) {
+  const baseUrl = sys.openapi?.servers?.[0]?.url ?? sys.baseUrl ?? sys.openapi?.baseUrl ?? null;
+  const authType = sys.authentication?.type ?? sys.authenticationType ?? null;
+  const endpointCount = sys.openapi?.endpoints?.length ??
+    (sys.openapi?.operations ? Object.keys(sys.openapi.operations || {}).length : null);
+  return {
+    key: sys.key,
+    displayName: sys.displayName,
+    type: sys.type,
+    baseUrl,
+    authenticationType: authType,
+    endpointCount
+  };
+}
+
+function _buildFieldMappingsSummary(ds0) {
+  const attrs0 = ds0.fieldMappings?.attributes ?? ds0.attributes ?? {};
+  const mappedFields = (typeof attrs0 === 'object' && !Array.isArray(attrs0)) ? Object.keys(attrs0) : [];
+  return mappedFields.length > 0 ? { mappingCount: mappedFields.length, mappedFields, unmappedFields: [] } : null;
+}
+
+function derivePreviewFromConfig(systemConfig, datasourceConfigs) {
+  const sys = systemConfig || {};
+  const dsList = Array.isArray(datasourceConfigs) ? datasourceConfigs : (datasourceConfigs ? [datasourceConfigs] : []);
+
+  const result = {
+    systemSummary: _buildSystemSummary(sys),
+    fieldMappingsSummary: _buildFieldMappingsSummary(dsList[0] || {})
+  };
+  const datasourceSummaries = dsList.map(_buildDatasourceSummary);
+  if (datasourceSummaries.length === 1) {
+    result.datasourceSummary = datasourceSummaries[0];
+  } else if (datasourceSummaries.length > 1) {
+    result.datasourceSummaries = datasourceSummaries;
+  }
+  return result;
+}
+
+/**
+ * Format a preview summary for display (WizardPreviewResponse from dataplane)
+ * @param {Object} preview - Preview data from GET /api/v1/wizard/preview/{sessionId}
+ * @returns {string} Formatted summary text
+ */
+function formatPreviewSummary(preview) {
+  const hasVal = (v) => v !== null && v !== undefined;
+  const parts = ['\n📋 Configuration Preview (what will be created)', '─'.repeat(60)];
+
+  if (preview.systemSummary) parts.push(..._formatSystem(preview.systemSummary));
+  if (preview.datasourceSummaries && preview.datasourceSummaries.length > 0) {
+    preview.datasourceSummaries.forEach((ds, i) => {
+      const lines = _formatDatasource(ds);
+      const label = preview.datasourceSummaries.length > 1 ? `Datasource ${i + 1}` : 'Datasource';
+      parts.push(...lines.map((line, j) => (j === 0 ? line.replace('Datasource', label) : line)));
+    });
+  } else if (preview.datasourceSummary) {
+    parts.push(..._formatDatasource(preview.datasourceSummary));
+  }
+  if (preview.cipPipelineSummary) {
+    const cip = preview.cipPipelineSummary;
+    parts.push('\nCIP Pipeline', `  Steps:          ${_s(cip.stepCount)}`, `  Est. execution: ${_s(cip.estimatedExecutionTime) || '—'}`);
+  }
+  if (preview.fieldMappingsSummary) parts.push(..._formatFieldMappings(preview.fieldMappingsSummary));
+  if (hasVal(preview.estimatedRecords) || hasVal(preview.estimatedSyncTime)) {
+    parts.push('\nEstimates', `  Records:  ${_s(preview.estimatedRecords)}`, `  Sync:     ${_s(preview.estimatedSyncTime)}`);
+  }
+  parts.push('\n' + '─'.repeat(60));
+  return parts.join('\n');
+}
+
+/**
+ * Prompt for configuration review and editing
+ * When preview is provided, displays a compact summary; otherwise dumps full YAML.
+ * @async
+ * @param {Object} opts - Options
+ * @param {Object|null} [opts.preview] - Preview data from getPreview (null = fallback to YAML)
+ * @param {Object} opts.systemConfig - System configuration
+ * @param {Object[]} opts.datasourceConfigs - Array of datasource configurations
+ * @returns {Promise<Object>} Object with action ('accept'|'cancel') and optionally edited configs
+ */
+async function promptForConfigReview({ preview, systemConfig, datasourceConfigs }) {
+  const hasSummary = preview && (preview.systemSummary || preview.datasourceSummary || (preview.datasourceSummaries && preview.datasourceSummaries.length > 0));
+  const summaryToShow = hasSummary ? preview : derivePreviewFromConfig(systemConfig, datasourceConfigs);
+  const canShowSummary = summaryToShow.systemSummary || summaryToShow.datasourceSummary ||
+    (summaryToShow.datasourceSummaries && summaryToShow.datasourceSummaries.length > 0);
+
+  if (canShowSummary) {
+    // eslint-disable-next-line no-console
+    console.log(formatPreviewSummary(summaryToShow));
+  } else {
+    // eslint-disable-next-line no-console
+    console.log('\n📋 Generated Configuration:\nSystem Configuration:');
+    // eslint-disable-next-line no-console
+    console.log(yaml.dump(systemConfig, { lineWidth: -1 }));
+    // eslint-disable-next-line no-console
+    console.log('Datasource Configurations:');
+    (datasourceConfigs || []).forEach((ds, index) => {
+      // eslint-disable-next-line no-console
+      console.log(`\nDatasource ${index + 1}:\n${yaml.dump(ds, { lineWidth: -1 })}`);
+    });
+  }
+  const { action } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'action',
+      message: 'What would you like to do?',
+      choices: [
+        { name: 'Accept and save', value: 'accept' },
+        { name: 'Cancel', value: 'cancel' }
+      ]
+    }
+  ]);
+  return action === 'cancel' ? { action: 'cancel' } : { action: 'accept' };
+}
+
+module.exports = {
+  promptForCredentialIdOrKeyRetry,
+  promptForKnownPlatform,
+  promptForEntitySelection,
+  promptForConfigReview,
+  derivePreviewFromConfig,
+  formatPreviewSummary
+};

package/lib/generator/wizard-prompts.js

@@ -7,18 +7,20 @@
 const inquirer = require('inquirer');
 const path = require('path');
 const fs = require('fs').promises;
+const { formatCredentialWithStatus } = require('../utils/credential-display');
 
 /**
  * Prompt for wizard mode selection
  * @async
  * @function promptForMode
  * @param {string} [defaultMode] - Default value ('create-system' | 'add-datasource')
+ * @param {boolean} [allowAddDatasource=true] - If false, only show "Create a new external system"
  * @returns {Promise<string>} Selected mode ('create-system' | 'add-datasource')
  */
-async function promptForMode(defaultMode) {
+async function promptForMode(defaultMode, allowAddDatasource = true) {
   const choices = [
     { name: 'Create a new external system', value: 'create-system' },
-    { name: 'Add datasource to existing system', value: 'add-datasource' }
+    ...(allowAddDatasource ? [{ name: 'Add datasource to existing system', value: 'add-datasource' }] : [])
   ];
   const { mode } = await inquirer.prompt([
     {
@@ -26,6 +28,7 @@ async function promptForMode(defaultMode) {
       name: 'mode',
       message: 'What would you like to do?',
       choices,
+      pageSize: 10,
       default: defaultMode && choices.some(c => c.value === defaultMode) ? defaultMode : undefined
     }
   ]);
@@ -35,12 +38,58 @@ async function promptForMode(defaultMode) {
 /**
  * Prompt for existing system ID or key (for add-datasource mode).
  * Only external systems (OpenAPI, MCP, custom) support add-datasource; webapps do not.
+ * When a list is available, use promptForExistingSystem instead to show a selection list.
  * @async
  * @function promptForSystemIdOrKey
  * @param {string} [defaultValue] - Default value (e.g. from loaded wizard.yaml)
  * @returns {Promise<string>} System ID or key
  */
 async function promptForSystemIdOrKey(defaultValue) {
+  return promptForExistingSystemInput(defaultValue);
+}
+
+/**
+ * Prompt to select an existing external system: show a list from the dataplane when available, otherwise ask for ID/key.
+ * @async
+ * @function promptForExistingSystem
+ * @param {Array<{key?: string, id?: string, displayName?: string}>} [systemsList] - External systems from GET /api/v1/external/systems (or empty/null on error)
+ * @param {string} [defaultValue] - Default value (e.g. from loaded wizard.yaml)
+ * @returns {Promise<string>} Selected system ID or key
+ */
+async function promptForExistingSystem(systemsList = [], defaultValue) {
+  const list = Array.isArray(systemsList) ? systemsList : [];
+  if (list.length > 0) {
+    const choices = list.map((s) => {
+      const value = s.key ?? s.id ?? '';
+      const displayName = s.displayName ?? s.name ?? value;
+      const name = displayName === value ? String(value) : `${displayName} (${value})`;
+      return { name: String(name), value };
+    }).filter((c) => c.value);
+    if (choices.length === 0) {
+      return promptForExistingSystemInput(defaultValue);
+    }
+    const { systemIdOrKey } = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'systemIdOrKey',
+        message: 'Select an existing external system (not a webapp):',
+        choices,
+        pageSize: 10
+      }
+    ]);
+    return systemIdOrKey;
+  }
+  return promptForExistingSystemInput(defaultValue);
+}
+
+/**
+ * Prompt for external system ID or key via free-text input (used when list is empty or API failed).
+ * @async
+ * @function promptForExistingSystemInput
+ * @param {string} [defaultValue] - Default value
+ * @returns {Promise<string>} System ID or key
+ */
+async function promptForExistingSystemInput(defaultValue) {
   const { systemIdOrKey } = await inquirer.prompt([
     {
       type: 'input',
@@ -78,7 +127,8 @@ async function promptForSourceType(platforms = []) {
       type: 'list',
       name: 'sourceType',
       message: 'What is your source type?',
-      choices
+      choices,
+      pageSize: 10
     }
   ]);
   return sourceType;
@@ -189,9 +239,10 @@ async function promptForMcpServer() {
 /**
  * Prompt for credential action (skip / create new / use existing).
  * Choose Skip if you don't have credentials yet; you can add them later in env.template.
+ * When "Use existing" is chosen, the caller should fetch credentials and call promptForExistingCredential.
  * @async
  * @function promptForCredentialAction
- * @returns {Promise<Object>} Object with action ('skip'|'create'|'select') and optional credentialIdOrKey
+ * @returns {Promise<Object>} Object with action ('skip'|'create'|'select'); credentialIdOrKey only when action is 'select' and chosen via promptForExistingCredential
  */
 async function promptForCredentialAction() {
   const { action } = await inquirer.prompt([
@@ -206,79 +257,65 @@ async function promptForCredentialAction() {
       ]
     }
   ]);
-  if (action === 'select') {
+  return { action };
+}
+
+/**
+ * Prompt to select an existing credential: show a list from the dataplane when available, otherwise ask for ID/key.
+ * @async
+ * @function promptForExistingCredential
+ * @param {Array<{key?: string, id?: string, credentialKey?: string, displayName?: string, name?: string, status?: string}>} [credentialsList] - Credentials from GET /api/v1/wizard/credentials (or empty/null on error)
+ * @returns {Promise<{credentialIdOrKey: string}>} Selected credential ID or key
+ */
+async function promptForExistingCredential(credentialsList = []) {
+  const list = Array.isArray(credentialsList) ? credentialsList : [];
+  if (list.length > 0) {
+    const choices = list.map((c) => {
+      const { name: baseName, statusFormatted, statusLabel } = formatCredentialWithStatus(c);
+      const name = statusFormatted
+        ? `${statusFormatted} ${baseName}${statusLabel}`
+        : String(baseName);
+      const value = c.key ?? c.id ?? c.credentialKey ?? '';
+      return { name, value };
+    }).filter((c) => c.value);
+    if (choices.length === 0) {
+      return promptForExistingCredentialInput();
+    }
     const { credentialIdOrKey } = await inquirer.prompt([
       {
-        type: 'input',
+        type: 'list',
         name: 'credentialIdOrKey',
-        message: 'Enter credential ID or key (must exist on the dataplane):',
-        validate: (input) => {
-          if (!input || typeof input !== 'string' || input.trim().length === 0) {
-            return 'Credential ID or key is required (or choose Skip at the previous step)';
-          }
-          return true;
-        }
+        message: 'Select a credential:',
+        choices,
+        pageSize: 10
       }
     ]);
-    return { action, credentialIdOrKey: credentialIdOrKey.trim() };
+    return { credentialIdOrKey };
   }
-  return { action };
+  return promptForExistingCredentialInput();
 }
 
 /**
- * Re-prompt for credential ID/key when validation failed (e.g. not found on dataplane).
- * Empty input means skip.
+ * Prompt for credential ID or key via free-text input (used when list is empty or API failed).
  * @async
- * @function promptForCredentialIdOrKeyRetry
- * @param {string} [previousError] - Error message from dataplane (e.g. "Credential not found")
- * @returns {Promise<Object>} { credentialIdOrKey: string } or { skip: true } if user leaves empty
+ * @function promptForExistingCredentialInput
+ * @returns {Promise<{credentialIdOrKey: string}>}
  */
-async function promptForCredentialIdOrKeyRetry(previousError) {
-  const msg = previousError
-    ? `Credential not found or invalid (${String(previousError).slice(0, 60)}). Enter ID/key or leave empty to skip:`
-    : 'Enter credential ID or key (or leave empty to skip):';
+async function promptForExistingCredentialInput() {
   const { credentialIdOrKey } = await inquirer.prompt([
     {
       type: 'input',
       name: 'credentialIdOrKey',
-      message: msg,
-      default: ''
-    }
-  ]);
-  const trimmed = (credentialIdOrKey && credentialIdOrKey.trim()) || '';
-  return trimmed ? { credentialIdOrKey: trimmed } : { skip: true };
-}
-
-/**
- * Prompt for known platform selection
- * @async
- * @function promptForKnownPlatform
- * @param {Array<{key: string, displayName?: string}>} [platforms] - List of available platforms (if provided)
- * @returns {Promise<string>} Selected platform key
- */
-async function promptForKnownPlatform(platforms = []) {
-  // Default platforms if none provided
-  const defaultPlatforms = [
-    { name: 'HubSpot', value: 'hubspot' },
-    { name: 'Salesforce', value: 'salesforce' },
-    { name: 'Zendesk', value: 'zendesk' },
-    { name: 'Slack', value: 'slack' },
-    { name: 'Microsoft 365', value: 'microsoft365' }
-  ];
-
-  const choices = platforms.length > 0
-    ? platforms.map(p => ({ name: p.displayName || p.key, value: p.key }))
-    : defaultPlatforms;
-
-  const { platform } = await inquirer.prompt([
-    {
-      type: 'list',
-      name: 'platform',
-      message: 'Select a platform:',
-      choices
+      message: 'Enter credential ID or key (must exist on the dataplane):',
+      validate: (input) => {
+        if (!input || typeof input !== 'string' || input.trim().length === 0) {
+          return 'Credential ID or key is required (or choose Skip at the previous step)';
+        }
+        return true;
+      }
     }
   ]);
-  return platform;
+  return { credentialIdOrKey: credentialIdOrKey.trim() };
 }
 
 /**
@@ -351,49 +388,6 @@ async function promptForUserPreferences() {
   };
 }
 
-/**
- * Prompt for configuration review and editing
- * @async
- * @function promptForConfigReview
- * @param {Object} systemConfig - System configuration
- * @param {Object[]} datasourceConfigs - Array of datasource configurations
- * @returns {Promise<Object>} Object with review decision and optionally edited configs
- */
-async function promptForConfigReview(systemConfig, datasourceConfigs) {
-  // eslint-disable-next-line no-console
-  console.log('\n📋 Generated Configuration:');
-  // eslint-disable-next-line no-console
-  console.log('\nSystem Configuration:');
-  // eslint-disable-next-line no-console
-  console.log(JSON.stringify(systemConfig, null, 2));
-  // eslint-disable-next-line no-console
-  console.log('\nDatasource Configurations:');
-  datasourceConfigs.forEach((ds, index) => {
-    // eslint-disable-next-line no-console
-    console.log(`\nDatasource ${index + 1}:`);
-    // eslint-disable-next-line no-console
-    console.log(JSON.stringify(ds, null, 2));
-  });
-
-  const { action } = await inquirer.prompt([
-    {
-      type: 'list',
-      name: 'action',
-      message: 'What would you like to do?',
-      choices: [
-        { name: 'Accept and save', value: 'accept' },
-        { name: 'Cancel', value: 'cancel' }
-      ]
-    }
-  ]);
-
-  if (action === 'cancel') {
-    return { action: 'cancel' };
-  }
-
-  return { action: 'accept' };
-}
-
 /**
  * Prompt for application name
  * @async
@@ -440,19 +434,24 @@ async function promptForRunWithSavedConfig() {
   return run;
 }
 
+const secondary = require('./wizard-prompts-secondary');
+
 module.exports = {
   promptForMode,
   promptForSystemIdOrKey,
+  promptForExistingSystem,
   promptForSourceType,
   promptForOpenApiFile,
   promptForOpenApiUrl,
   promptForMcpServer,
   promptForCredentialAction,
-  promptForCredentialIdOrKeyRetry,
-  promptForKnownPlatform,
+  promptForExistingCredential,
+  promptForCredentialIdOrKeyRetry: secondary.promptForCredentialIdOrKeyRetry,
+  promptForKnownPlatform: secondary.promptForKnownPlatform,
+  promptForEntitySelection: secondary.promptForEntitySelection,
   promptForUserIntent,
   promptForUserPreferences,
-  promptForConfigReview,
+  promptForConfigReview: secondary.promptForConfigReview,
   promptForAppName,
   promptForRunWithSavedConfig
 };

package/lib/generator/wizard-readme.js

@@ -0,0 +1,88 @@
+/**
+ * Wizard README generation - used by wizard file generator
+ * @fileoverview Generates README.md for external system wizard output
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+'use strict';
+
+const fs = require('fs').promises;
+const path = require('path');
+const chalk = require('chalk');
+const logger = require('../utils/logger');
+const { generateExternalReadmeContent } = require('../utils/external-readme');
+
+const FORMAT_EXT = { yaml: '.yaml', json: '.json' };
+
+/**
+ * Converts a string to a schema-valid key segment (lowercase letters, numbers, hyphens only).
+ * @param {string} str - Raw entity type or key segment (may be camelCase)
+ * @returns {string} Segment matching ^[a-z0-9-]+$
+ */
+function toKeySegment(str) {
+  if (!str || typeof str !== 'string') return 'default';
+  const withHyphens = str.replace(/([A-Z])/g, '-$1').toLowerCase();
+  const sanitized = withHyphens.replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
+  return sanitized || 'default';
+}
+
+/**
+ * Generate README.md with basic documentation
+ * @async
+ * @function generateReadme
+ * @param {Object} options - Options for README generation
+ * @param {string} options.appPath - Application directory path
+ * @param {string} options.appName - Application name
+ * @param {string} options.systemKey - System key
+ * @param {Object} options.systemConfig - System configuration
+ * @param {Object[]} options.datasourceConfigs - Array of datasource configurations
+ * @param {string} [options.aiGeneratedContent] - Optional AI-generated README content from dataplane
+ * @param {string} [options.format] - Output format: 'yaml' or 'json'
+ * @throws {Error} If generation fails
+ */
+async function generateReadme(options) {
+  const { appPath, appName, systemKey, systemConfig, datasourceConfigs, aiGeneratedContent, format } = options;
+  try {
+    const readmePath = path.join(appPath, 'README.md');
+
+    if (aiGeneratedContent) {
+      await fs.writeFile(readmePath, aiGeneratedContent, 'utf8');
+      logger.log(chalk.green('✓ Generated README.md (AI-generated from dataplane)'));
+      return;
+    }
+
+    const ext = FORMAT_EXT[format === 'json' ? 'json' : 'yaml'] || '.yaml';
+    const datasources = (Array.isArray(datasourceConfigs) ? datasourceConfigs : []).map((ds, index) => {
+      const entityType = ds.entityType || ds.entityKey || ds.key?.split('-').pop() || `datasource${index + 1}`;
+      const keySegment = toKeySegment(entityType);
+      const datasourceKey = ds.key || `${systemKey}-${keySegment}`;
+      const datasourceKeyOnly = datasourceKey.includes('-') && datasourceKey.startsWith(`${systemKey}-`)
+        ? datasourceKey.substring(systemKey.length + 1)
+        : keySegment;
+      return {
+        key: datasourceKey,
+        entityType,
+        displayName: ds.displayName || ds.name || ds.key || `Datasource ${index + 1}`,
+        fileName: `${systemKey}-datasource-${datasourceKeyOnly}${ext}`
+      };
+    });
+
+    const readmeContent = generateExternalReadmeContent({
+      appName,
+      systemKey,
+      systemType: systemConfig.type || systemConfig.systemType,
+      displayName: systemConfig.displayName,
+      description: systemConfig.description,
+      fileExt: ext,
+      datasources
+    });
+
+    await fs.writeFile(readmePath, readmeContent, 'utf8');
+    logger.log(chalk.green('✓ Generated README.md (template)'));
+  } catch (error) {
+    throw new Error(`Failed to generate README.md: ${error.message}`);
+  }
+}
+
+module.exports = { generateReadme };