@aifabrix/builder 2.41.0 → 2.42.0

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 };