@aifabrix/builder 2.31.1 → 2.32.1

package/lib/{generator.js → generator/index.js}

@@ -11,13 +11,13 @@
 
 const fs = require('fs');
 const path = require('path');
-const _keyGenerator = require('./key-generator');
-const _validator = require('./validator');
-const builders = require('./generator-builders');
-const { detectAppType, getDeployJsonPath } = require('./utils/paths');
-const splitFunctions = require('./generator-split');
-const { loadVariables, loadEnvTemplate, loadRbac, parseEnvironmentVariables } = require('./generator-helpers');
-const { generateExternalSystemDeployJson, generateExternalSystemApplicationSchema } = require('./generator-external');
+const _keyGenerator = require('../core/key-generator');
+const _validator = require('../validation/validator');
+const builders = require('./builders');
+const { detectAppType, getDeployJsonPath } = require('../utils/paths');
+const splitFunctions = require('./split');
+const { loadVariables, loadEnvTemplate, loadRbac, parseEnvironmentVariables } = require('./helpers');
+const { generateExternalSystemDeployJson, generateExternalSystemApplicationSchema } = require('./external');
 
 /**
  * Generates deployment JSON from application configuration files
@@ -35,30 +35,37 @@ const { generateExternalSystemDeployJson, generateExternalSystemApplicationSchem
  * const jsonPath = await generateDeployJson('myapp');
  * // Returns: './builder/myapp/myapp-deploy.json' or './integration/hubspot/hubspot-deploy.json'
  */
-async function generateDeployJson(appName) {
-  if (!appName || typeof appName !== 'string') {
-    throw new Error('App name is required and must be a string');
-  }
-
-  // Detect app type and get correct path (integration or builder)
-  const { isExternal, appPath, appType } = await detectAppType(appName);
+/**
+ * Loads configuration files for deployment generation
+ * @function loadDeploymentConfigFiles
+ * @param {string} appPath - Application path
+ * @param {string} appType - Application type
+ * @returns {Object} Loaded configuration files
+ */
+function loadDeploymentConfigFiles(appPath, appType, appName) {
   const variablesPath = path.join(appPath, 'variables.yaml');
-
-  // Check if app type is external
-  if (isExternal) {
-    return await generateExternalSystemDeployJson(appName, appPath);
-  }
-
-  // Regular app: generate deployment manifest
   const templatePath = path.join(appPath, 'env.template');
   const rbacPath = path.join(appPath, 'rbac.yaml');
   const jsonPath = getDeployJsonPath(appName, appType, true); // Use new naming
 
-  // Load configuration files
   const { parsed: variables } = loadVariables(variablesPath);
   const envTemplate = loadEnvTemplate(templatePath);
   const rbac = loadRbac(rbacPath);
 
+  return { variables, envTemplate, rbac, jsonPath };
+}
+
+/**
+ * Builds and validates deployment manifest
+ * @function buildAndValidateDeployment
+ * @param {string} appName - Application name
+ * @param {Object} variables - Variables configuration
+ * @param {Object} envTemplate - Environment template
+ * @param {Object} rbac - RBAC configuration
+ * @returns {Object} Deployment manifest with deploymentKey
+ * @throws {Error} If validation fails
+ */
+function buildAndValidateDeployment(appName, variables, envTemplate, rbac) {
   // Parse environment variables from template and merge portalInput from variables.yaml
   const configuration = parseEnvironmentVariables(envTemplate, variables);
 
@@ -78,6 +85,26 @@ async function generateDeployJson(appName) {
     throw new Error(`Generated deployment JSON does not match schema:\n${errorMessages}`);
   }
 
+  return deployment;
+}
+
+async function generateDeployJson(appName) {
+  if (!appName || typeof appName !== 'string') {
+    throw new Error('App name is required and must be a string');
+  }
+
+  // Detect app type and get correct path (integration or builder)
+  const { isExternal, appPath, appType } = await detectAppType(appName);
+
+  // Check if app type is external
+  if (isExternal) {
+    return await generateExternalSystemDeployJson(appName, appPath);
+  }
+
+  // Regular app: generate deployment manifest
+  const { variables, envTemplate, rbac, jsonPath } = loadDeploymentConfigFiles(appPath, appType, appName);
+  const deployment = buildAndValidateDeployment(appName, variables, envTemplate, rbac);
+
   // Write deployment JSON
   const jsonContent = JSON.stringify(deployment, null, 2);
   fs.writeFileSync(jsonPath, jsonContent, { mode: 0o644 });

package/lib/{generator-split.js → generator/split.js}

@@ -143,41 +143,42 @@ function extractRequirementsSection(deployment) {
  * @param {Object} deployment - Deployment JSON object
  * @returns {Object} Object with optional sections
  */
+/**
+ * Extracts a single optional section if present
+ * @function extractOptionalSection
+ * @param {Object} deployment - Deployment object
+ * @param {string} sectionName - Section name to extract
+ * @param {Object} optional - Optional sections object to update
+ */
+function extractOptionalSection(deployment, sectionName, optional) {
+  if (deployment[sectionName]) {
+    if (sectionName === 'authentication') {
+      optional[sectionName] = { ...deployment[sectionName] };
+    } else {
+      optional[sectionName] = deployment[sectionName];
+    }
+  }
+}
+
 function extractOptionalSections(deployment) {
   const optional = {};
 
-  if (deployment.healthCheck) {
-    optional.healthCheck = deployment.healthCheck;
-  }
-  if (deployment.authentication) {
-    optional.authentication = { ...deployment.authentication };
-  }
-  if (deployment.build) {
-    optional.build = deployment.build;
-  }
-  if (deployment.repository) {
-    optional.repository = deployment.repository;
-  }
-  if (deployment.deployment) {
-    optional.deployment = deployment.deployment;
-  }
-  if (deployment.startupCommand) {
-    optional.startupCommand = deployment.startupCommand;
-  }
-  if (deployment.runtimeVersion) {
-    optional.runtimeVersion = deployment.runtimeVersion;
-  }
-  if (deployment.scaling) {
-    optional.scaling = deployment.scaling;
-  }
-  if (deployment.frontDoorRouting) {
-    optional.frontDoorRouting = deployment.frontDoorRouting;
-  }
-  if (deployment.roles) {
-    optional.roles = deployment.roles;
-  }
-  if (deployment.permissions) {
-    optional.permissions = deployment.permissions;
+  const optionalSectionNames = [
+    'healthCheck',
+    'authentication',
+    'build',
+    'repository',
+    'deployment',
+    'startupCommand',
+    'runtimeVersion',
+    'scaling',
+    'frontDoorRouting',
+    'roles',
+    'permissions'
+  ];
+
+  for (const sectionName of optionalSectionNames) {
+    extractOptionalSection(deployment, sectionName, optional);
   }
 
   return optional;
@@ -311,73 +312,125 @@ function generateReadmeFromDeployJson(deployment) {
  * @returns {Promise<Object>} Object with paths to generated files
  * @throws {Error} If JSON file not found or invalid
  */
-async function splitDeployJson(deployJsonPath, outputDir = null) {
+/**
+ * Validates deployment JSON path
+ * @function validateDeployJsonPath
+ * @param {string} deployJsonPath - Deployment JSON path
+ * @throws {Error} If path is invalid
+ */
+function validateDeployJsonPath(deployJsonPath) {
   if (!deployJsonPath || typeof deployJsonPath !== 'string') {
     throw new Error('Deployment JSON path is required and must be a string');
   }
-
-  // Validate file exists
   const fsSync = require('fs');
   if (!fsSync.existsSync(deployJsonPath)) {
     throw new Error(`Deployment JSON file not found: ${deployJsonPath}`);
   }
+}
 
-  // Determine output directory
+/**
+ * Prepares output directory
+ * @async
+ * @function prepareOutputDirectory
+ * @param {string} deployJsonPath - Deployment JSON path
+ * @param {string|null} outputDir - Optional output directory
+ * @returns {Promise<string>} Final output directory path
+ */
+async function prepareOutputDirectory(deployJsonPath, outputDir) {
   const finalOutputDir = outputDir || path.dirname(deployJsonPath);
-
-  // Ensure output directory exists
+  const fsSync = require('fs');
   if (!fsSync.existsSync(finalOutputDir)) {
     await fs.mkdir(finalOutputDir, { recursive: true });
   }
+  return finalOutputDir;
+}
 
-  // Load and parse deployment JSON
-  let deployment;
+/**
+ * Loads and parses deployment JSON
+ * @async
+ * @function loadDeploymentJson
+ * @param {string} deployJsonPath - Deployment JSON path
+ * @returns {Promise<Object>} Parsed deployment object
+ */
+async function loadDeploymentJson(deployJsonPath) {
   try {
     const jsonContent = await fs.readFile(deployJsonPath, 'utf8');
-    deployment = JSON.parse(jsonContent);
+    return JSON.parse(jsonContent);
   } catch (error) {
     if (error.code === 'ENOENT') {
       throw new Error(`Deployment JSON file not found: ${deployJsonPath}`);
     }
     throw new Error(`Invalid JSON syntax in deployment file: ${error.message}`);
   }
+}
 
-  // Extract components
-  const envTemplate = extractEnvTemplate(deployment.configuration || []);
-  const variables = extractVariablesYaml(deployment);
-  const rbac = extractRbacYaml(deployment);
-  const readme = generateReadmeFromDeployJson(deployment);
+/**
+ * Writes a component file
+ * @async
+ * @function writeComponentFile
+ * @param {string} filePath - File path
+ * @param {string} content - File content
+ * @returns {Promise<void>}
+ */
+async function writeComponentFile(filePath, content) {
+  await fs.writeFile(filePath, content, { mode: 0o644, encoding: 'utf8' });
+}
 
-  // Write component files
+/**
+ * Writes all component files
+ * @async
+ * @function writeComponentFiles
+ * @param {string} outputDir - Output directory
+ * @param {string} envTemplate - Environment template content
+ * @param {Object} variables - Variables object
+ * @param {Object|null} rbac - RBAC object or null
+ * @param {string} readme - README content
+ * @returns {Promise<Object>} Results object with file paths
+ */
+async function writeComponentFiles(outputDir, envTemplate, variables, rbac, readme) {
   const results = {};
 
   // Write env.template
-  const envTemplatePath = path.join(finalOutputDir, 'env.template');
-  await fs.writeFile(envTemplatePath, envTemplate, { mode: 0o644, encoding: 'utf8' });
+  const envTemplatePath = path.join(outputDir, 'env.template');
+  await writeComponentFile(envTemplatePath, envTemplate);
   results.envTemplate = envTemplatePath;
 
   // Write variables.yaml
-  const variablesPath = path.join(finalOutputDir, 'variables.yaml');
+  const variablesPath = path.join(outputDir, 'variables.yaml');
   const variablesYaml = yaml.dump(variables, { indent: 2, lineWidth: -1 });
-  await fs.writeFile(variablesPath, variablesYaml, { mode: 0o644, encoding: 'utf8' });
+  await writeComponentFile(variablesPath, variablesYaml);
   results.variables = variablesPath;
 
   // Write rbac.yml (only if roles/permissions exist)
   if (rbac) {
-    const rbacPath = path.join(finalOutputDir, 'rbac.yml');
+    const rbacPath = path.join(outputDir, 'rbac.yml');
     const rbacYaml = yaml.dump(rbac, { indent: 2, lineWidth: -1 });
-    await fs.writeFile(rbacPath, rbacYaml, { mode: 0o644, encoding: 'utf8' });
+    await writeComponentFile(rbacPath, rbacYaml);
     results.rbac = rbacPath;
   }
 
   // Write README.md
-  const readmePath = path.join(finalOutputDir, 'README.md');
-  await fs.writeFile(readmePath, readme, { mode: 0o644, encoding: 'utf8' });
+  const readmePath = path.join(outputDir, 'README.md');
+  await writeComponentFile(readmePath, readme);
   results.readme = readmePath;
 
   return results;
 }
 
+async function splitDeployJson(deployJsonPath, outputDir = null) {
+  validateDeployJsonPath(deployJsonPath);
+  const finalOutputDir = await prepareOutputDirectory(deployJsonPath, outputDir);
+  const deployment = await loadDeploymentJson(deployJsonPath);
+
+  // Extract components
+  const envTemplate = extractEnvTemplate(deployment.configuration || []);
+  const variables = extractVariablesYaml(deployment);
+  const rbac = extractRbacYaml(deployment);
+  const readme = generateReadmeFromDeployJson(deployment);
+
+  return await writeComponentFiles(finalOutputDir, envTemplate, variables, rbac, readme);
+}
+
 module.exports = {
   splitDeployJson,
   extractEnvTemplate,

package/lib/generator/wizard-prompts.js

@@ -0,0 +1,357 @@
+/**
+ * @fileoverview Wizard prompt utilities for interactive external system creation
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+const inquirer = require('inquirer');
+const path = require('path');
+const fs = require('fs').promises;
+
+/**
+ * Prompt for wizard mode selection
+ * @async
+ * @function promptForMode
+ * @returns {Promise<string>} Selected mode ('create-system' | 'add-datasource')
+ */
+async function promptForMode() {
+  const { mode } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'mode',
+      message: 'What would you like to do?',
+      choices: [
+        { name: 'Create a new external system', value: 'create-system' },
+        { name: 'Add datasource to existing system', value: 'add-datasource' }
+      ]
+    }
+  ]);
+  return mode;
+}
+
+/**
+ * Prompt for source type selection
+ * @async
+ * @function promptForSourceType
+ * @returns {Promise<string>} Selected source type
+ */
+async function promptForSourceType() {
+  const { sourceType } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'sourceType',
+      message: 'What is your source type?',
+      choices: [
+        { name: 'OpenAPI file (local file)', value: 'openapi-file' },
+        { name: 'OpenAPI URL (remote URL)', value: 'openapi-url' },
+        { name: 'MCP server', value: 'mcp-server' },
+        { name: 'Known platform (pre-configured)', value: 'known-platform' }
+      ]
+    }
+  ]);
+  return sourceType;
+}
+
+/**
+ * Prompt for OpenAPI file path
+ * @async
+ * @function promptForOpenApiFile
+ * @returns {Promise<string>} File path
+ */
+async function promptForOpenApiFile() {
+  const { filePath } = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'filePath',
+      message: 'Enter the path to your OpenAPI file:',
+      validate: async(input) => {
+        if (!input || typeof input !== 'string' || input.trim().length === 0) {
+          return 'File path is required';
+        }
+        const resolvedPath = path.resolve(input);
+        try {
+          const stats = await fs.stat(resolvedPath);
+          if (!stats.isFile()) {
+            return 'Path must be a file';
+          }
+          return true;
+        } catch (error) {
+          return `File not found: ${input}`;
+        }
+      }
+    }
+  ]);
+  return path.resolve(filePath);
+}
+
+/**
+ * Prompt for OpenAPI URL
+ * @async
+ * @function promptForOpenApiUrl
+ * @returns {Promise<string>} URL
+ */
+async function promptForOpenApiUrl() {
+  const { url } = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'url',
+      message: 'Enter the OpenAPI URL:',
+      validate: (input) => {
+        if (!input || typeof input !== 'string' || input.trim().length === 0) {
+          return 'URL is required';
+        }
+        try {
+          new URL(input);
+          return true;
+        } catch (error) {
+          return 'Invalid URL format';
+        }
+      }
+    }
+  ]);
+  return url.trim();
+}
+
+/**
+ * Prompt for MCP server details
+ * @async
+ * @function promptForMcpServer
+ * @returns {Promise<Object>} Object with serverUrl and token
+ */
+async function promptForMcpServer() {
+  const answers = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'serverUrl',
+      message: 'Enter MCP server URL:',
+      validate: (input) => {
+        if (!input || typeof input !== 'string' || input.trim().length === 0) {
+          return 'Server URL is required';
+        }
+        try {
+          new URL(input);
+          return true;
+        } catch (error) {
+          return 'Invalid URL format';
+        }
+      }
+    },
+    {
+      type: 'password',
+      name: 'token',
+      message: 'Enter MCP server authentication token:',
+      validate: (input) => {
+        if (!input || typeof input !== 'string' || input.trim().length === 0) {
+          return 'Token is required';
+        }
+        return true;
+      }
+    }
+  ]);
+  return {
+    serverUrl: answers.serverUrl.trim(),
+    token: answers.token
+  };
+}
+
+/**
+ * Prompt for known platform selection
+ * @async
+ * @function promptForKnownPlatform
+ * @param {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
+    }
+  ]);
+  return platform;
+}
+
+/**
+ * Prompt for user intent
+ * @async
+ * @function promptForUserIntent
+ * @returns {Promise<string>} User intent
+ */
+async function promptForUserIntent() {
+  const { intent } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'intent',
+      message: 'What is your primary use case?',
+      choices: [
+        { name: 'Sales-focused (CRM, leads, deals)', value: 'sales-focused' },
+        { name: 'Support-focused (tickets, customers)', value: 'support-focused' },
+        { name: 'Marketing-focused (campaigns, contacts)', value: 'marketing-focused' },
+        { name: 'General integration', value: 'general' }
+      ],
+      default: 'general'
+    }
+  ]);
+  return intent;
+}
+
+/**
+ * Prompt for user preferences
+ * @async
+ * @function promptForUserPreferences
+ * @returns {Promise<Object>} User preferences object
+ */
+async function promptForUserPreferences() {
+  const answers = await inquirer.prompt([
+    {
+      type: 'confirm',
+      name: 'mcp',
+      message: 'Enable MCP (Model Context Protocol)?',
+      default: false
+    },
+    {
+      type: 'confirm',
+      name: 'abac',
+      message: 'Enable ABAC (Attribute-Based Access Control)?',
+      default: false
+    },
+    {
+      type: 'confirm',
+      name: 'rbac',
+      message: 'Enable RBAC (Role-Based Access Control)?',
+      default: false
+    }
+  ]);
+  return {
+    mcp: answers.mcp,
+    abac: answers.abac,
+    rbac: answers.rbac
+  };
+}
+
+/**
+ * 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: 'Edit configuration manually', value: 'edit' },
+        { name: 'Cancel', value: 'cancel' }
+      ]
+    }
+  ]);
+
+  if (action === 'cancel') {
+    return { action: 'cancel' };
+  }
+
+  if (action === 'edit') {
+    const { editedConfig } = await inquirer.prompt([
+      {
+        type: 'editor',
+        name: 'editedConfig',
+        message: 'Edit the configuration (JSON format):',
+        default: JSON.stringify({ systemConfig, datasourceConfigs }, null, 2),
+        validate: (input) => {
+          try {
+            JSON.parse(input);
+            return true;
+          } catch (error) {
+            return `Invalid JSON: ${error.message}`;
+          }
+        }
+      }
+    ]);
+
+    const parsed = JSON.parse(editedConfig);
+    return {
+      action: 'edit',
+      systemConfig: parsed.systemConfig,
+      datasourceConfigs: parsed.datasourceConfigs
+    };
+  }
+
+  return { action: 'accept' };
+}
+
+/**
+ * Prompt for application name
+ * @async
+ * @function promptForAppName
+ * @param {string} [defaultName] - Default application name
+ * @returns {Promise<string>} Application name
+ */
+async function promptForAppName(defaultName) {
+  const { appName } = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'appName',
+      message: 'Enter application name:',
+      default: defaultName,
+      validate: (input) => {
+        if (!input || typeof input !== 'string' || input.trim().length === 0) {
+          return 'Application name is required';
+        }
+        if (!/^[a-z0-9-_]+$/.test(input)) {
+          return 'Application name must contain only lowercase letters, numbers, hyphens, and underscores';
+        }
+        return true;
+      }
+    }
+  ]);
+  return appName.trim();
+}
+
+module.exports = {
+  promptForMode,
+  promptForSourceType,
+  promptForOpenApiFile,
+  promptForOpenApiUrl,
+  promptForMcpServer,
+  promptForKnownPlatform,
+  promptForUserIntent,
+  promptForUserPreferences,
+  promptForConfigReview,
+  promptForAppName
+};
+