@aifabrix/builder 2.31.1 → 2.32.2

package/lib/api/wizard.api.js

@@ -0,0 +1,177 @@
+/**
+ * @fileoverview Wizard API functions
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+const { ApiClient } = require('./index');
+const { uploadFile } = require('../utils/file-upload');
+
+/**
+ * Select wizard mode
+ * POST /api/v1/wizard/mode-selection
+ * @async
+ * @function selectMode
+ * @param {string} dataplaneUrl - Dataplane base URL
+ * @param {Object} authConfig - Authentication configuration
+ * @param {string} mode - Wizard mode ('create-system' | 'add-datasource')
+ * @returns {Promise<Object>} Mode selection response
+ * @throws {Error} If request fails
+ */
+async function selectMode(dataplaneUrl, authConfig, mode) {
+  const client = new ApiClient(dataplaneUrl, authConfig);
+  return await client.post('/api/v1/wizard/mode-selection', {
+    body: { mode }
+  });
+}
+
+/**
+ * Select wizard source
+ * POST /api/v1/wizard/source-selection
+ * @async
+ * @function selectSource
+ * @param {string} dataplaneUrl - Dataplane base URL
+ * @param {Object} authConfig - Authentication configuration
+ * @param {string} sourceType - Source type ('openapi-file' | 'openapi-url' | 'mcp-server' | 'known-platform')
+ * @param {string} [sourceData] - Source data (file path, URL, etc.)
+ * @returns {Promise<Object>} Source selection response
+ * @throws {Error} If request fails
+ */
+async function selectSource(dataplaneUrl, authConfig, sourceType, sourceData) {
+  const client = new ApiClient(dataplaneUrl, authConfig);
+  return await client.post('/api/v1/wizard/source-selection', {
+    body: {
+      sourceType,
+      sourceData
+    }
+  });
+}
+
+/**
+ * Parse OpenAPI file
+ * POST /api/v1/wizard/parse-openapi
+ * @async
+ * @function parseOpenApi
+ * @param {string} dataplaneUrl - Dataplane base URL
+ * @param {Object} authConfig - Authentication configuration
+ * @param {string} openApiFilePath - Path to OpenAPI file
+ * @returns {Promise<Object>} Parsed OpenAPI response
+ * @throws {Error} If request fails
+ */
+async function parseOpenApi(dataplaneUrl, authConfig, openApiFilePath) {
+  const url = `${dataplaneUrl.replace(/\/$/, '')}/api/v1/wizard/parse-openapi`;
+  return await uploadFile(url, openApiFilePath, 'file', authConfig);
+}
+
+/**
+ * Detect API type from OpenAPI spec
+ * POST /api/v1/wizard/detect-type
+ * @async
+ * @function detectType
+ * @param {string} dataplaneUrl - Dataplane base URL
+ * @param {Object} authConfig - Authentication configuration
+ * @param {Object} openApiSpec - OpenAPI specification object
+ * @returns {Promise<Object>} Type detection response
+ * @throws {Error} If request fails
+ */
+async function detectType(dataplaneUrl, authConfig, openApiSpec) {
+  const client = new ApiClient(dataplaneUrl, authConfig);
+  return await client.post('/api/v1/wizard/detect-type', {
+    body: { openApiSpec }
+  });
+}
+
+/**
+ * Generate configuration via AI
+ * POST /api/v1/wizard/generate-config
+ * @async
+ * @function generateConfig
+ * @param {string} dataplaneUrl - Dataplane base URL
+ * @param {Object} authConfig - Authentication configuration
+ * @param {Object} config - Generation configuration
+ * @param {string} config.mode - Wizard mode
+ * @param {string} config.sourceType - Source type
+ * @param {Object} [config.openApiSpec] - OpenAPI specification (if applicable)
+ * @param {string} [config.userIntent] - User intent (e.g., 'sales-focused', 'support-focused')
+ * @param {Object} [config.preferences] - User preferences
+ * @returns {Promise<Object>} Generated configuration response
+ * @throws {Error} If request fails
+ */
+async function generateConfig(dataplaneUrl, authConfig, config) {
+  const client = new ApiClient(dataplaneUrl, authConfig);
+  return await client.post('/api/v1/wizard/generate-config', {
+    body: config
+  });
+}
+
+/**
+ * Validate wizard configuration
+ * POST /api/v1/wizard/validate
+ * @async
+ * @function validateWizardConfig
+ * @param {string} dataplaneUrl - Dataplane base URL
+ * @param {Object} authConfig - Authentication configuration
+ * @param {Object} systemConfig - System configuration to validate
+ * @param {Object[]} datasourceConfigs - Array of datasource configurations to validate
+ * @returns {Promise<Object>} Validation response
+ * @throws {Error} If request fails
+ */
+async function validateWizardConfig(dataplaneUrl, authConfig, systemConfig, datasourceConfigs) {
+  const client = new ApiClient(dataplaneUrl, authConfig);
+  return await client.post('/api/v1/wizard/validate', {
+    body: {
+      systemConfig,
+      datasourceConfigs
+    }
+  });
+}
+
+/**
+ * Test MCP server connection
+ * POST /api/v1/wizard/test-mcp-connection
+ * @async
+ * @function testMcpConnection
+ * @param {string} dataplaneUrl - Dataplane base URL
+ * @param {Object} authConfig - Authentication configuration
+ * @param {string} serverUrl - MCP server URL
+ * @param {string} token - MCP server authentication token
+ * @returns {Promise<Object>} Connection test response
+ * @throws {Error} If request fails
+ */
+async function testMcpConnection(dataplaneUrl, authConfig, serverUrl, token) {
+  const client = new ApiClient(dataplaneUrl, authConfig);
+  return await client.post('/api/v1/wizard/test-mcp-connection', {
+    body: {
+      serverUrl,
+      token
+    }
+  });
+}
+
+/**
+ * Get deployment documentation for a system
+ * GET /api/v1/wizard/deployment-docs/{systemKey}
+ * @async
+ * @function getDeploymentDocs
+ * @param {string} dataplaneUrl - Dataplane base URL
+ * @param {Object} authConfig - Authentication configuration
+ * @param {string} systemKey - System key identifier
+ * @returns {Promise<Object>} Deployment documentation response
+ * @throws {Error} If request fails
+ */
+async function getDeploymentDocs(dataplaneUrl, authConfig, systemKey) {
+  const client = new ApiClient(dataplaneUrl, authConfig);
+  return await client.get(`/api/v1/wizard/deployment-docs/${systemKey}`);
+}
+
+module.exports = {
+  selectMode,
+  selectSource,
+  parseOpenApi,
+  detectType,
+  generateConfig,
+  validateWizardConfig,
+  testMcpConnection,
+  getDeploymentDocs
+};
+

package/lib/{app-config.js → app/config.js}

@@ -11,10 +11,10 @@
 const fs = require('fs').promises;
 const path = require('path');
 const chalk = require('chalk');
-const { generateVariablesYaml, generateEnvTemplate, generateRbacYaml } = require('./templates');
-const { generateEnvTemplate: generateEnvTemplateFromReader } = require('./env-reader');
-const { generateReadmeMdFile } = require('./app-readme');
-const logger = require('./utils/logger');
+const { generateVariablesYaml, generateEnvTemplate, generateRbacYaml } = require('../core/templates');
+const { generateEnvTemplate: generateEnvTemplateFromReader } = require('../core/env-reader');
+const { generateReadmeMdFile } = require('./readme');
+const logger = require('../utils/logger');
 
 /**
  * Checks if a file exists

package/lib/{app-deploy.js → app/deploy.js}

@@ -13,11 +13,11 @@ const fs = require('fs').promises;
 const path = require('path');
 const yaml = require('js-yaml');
 const chalk = require('chalk');
-const pushUtils = require('./push');
-const logger = require('./utils/logger');
-const config = require('./config');
-const { getDeploymentAuth } = require('./utils/token-manager');
-const { detectAppType } = require('./utils/paths');
+const pushUtils = require('../deployment/push');
+const logger = require('../utils/logger');
+const config = require('../core/config');
+const { getDeploymentAuth } = require('../utils/token-manager');
+const { detectAppType } = require('../utils/paths');
 
 /**
  * Validate application name format
@@ -294,7 +294,7 @@ async function loadDeploymentConfig(appName, options) {
  */
 async function generateAndValidateManifest(appName) {
   logger.log(chalk.blue(`\n📋 Generating deployment manifest for ${appName}...`));
-  const generator = require('./generator');
+  const generator = require('../generator');
 
   // generateDeployJson already validates against schema and throws on error
   const manifestPath = await generator.generateDeployJson(appName);
@@ -327,7 +327,7 @@ function displayDeploymentInfo(manifest, manifestPath) {
  */
 async function executeDeployment(manifest, deploymentConfig) {
   logger.log(chalk.blue(`\n🚀 Deploying to ${deploymentConfig.controllerUrl} (environment: ${deploymentConfig.envKey})...`));
-  const deployer = require('./deployer');
+  const deployer = require('../deployment/deployer');
   return await deployer.deployToController(
     manifest,
     deploymentConfig.controllerUrl,
@@ -418,7 +418,7 @@ async function deployApp(appName, options = {}) {
     const alreadyLogged = error._logged === true;
     const url = controllerUrl || options.controller || 'unknown';
 
-    const deployer = require('./deployer');
+    const deployer = require('../deployment/deployer');
     // handleDeploymentErrors will log, format, and throw the error
     await deployer.handleDeploymentErrors(error, appName, url, alreadyLogged);
   }

package/lib/app/display.js

@@ -0,0 +1,90 @@
+/**
+ * Application Display Utilities
+ *
+ * Handles display of success messages and user guidance
+ * for application creation.
+ *
+ * @fileoverview Display utilities for application creation
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+const path = require('path');
+const chalk = require('chalk');
+const logger = require('../utils/logger');
+
+/**
+ * Displays external system success message
+ * @function displayExternalSystemSuccess
+ * @param {string} appName - Application name
+ * @param {Object} config - Configuration
+ * @param {string} location - Application location
+ */
+function displayExternalSystemSuccess(appName, config, location) {
+  logger.log(chalk.blue('Type: External System'));
+  logger.log(chalk.blue(`System Key: ${config.systemKey || appName}`));
+  logger.log(chalk.green('\nNext steps:'));
+  logger.log(chalk.white('1. Edit external system JSON files in ' + location));
+  logger.log(chalk.white('2. Run: aifabrix app register ' + appName + ' --environment dev'));
+  logger.log(chalk.white('3. Run: aifabrix build ' + appName + ' (deploys to dataplane)'));
+  logger.log(chalk.white('4. Run: aifabrix deploy ' + appName + ' (publishes to dataplane)'));
+}
+
+/**
+ * Displays webapp success message
+ * @function displayWebappSuccess
+ * @param {string} appName - Application name
+ * @param {Object} config - Configuration
+ * @param {string} envConversionMessage - Environment conversion message
+ */
+function displayWebappSuccess(appName, config, envConversionMessage) {
+  logger.log(chalk.blue(`Language: ${config.language}`));
+  logger.log(chalk.blue(`Port: ${config.port}`));
+
+  if (config.database) logger.log(chalk.yellow('  - Database enabled'));
+  if (config.redis) logger.log(chalk.yellow('  - Redis enabled'));
+  if (config.storage) logger.log(chalk.yellow('  - Storage enabled'));
+  if (config.authentication) logger.log(chalk.yellow('  - Authentication enabled'));
+
+  logger.log(chalk.gray(envConversionMessage));
+
+  logger.log(chalk.green('\nNext steps:'));
+  logger.log(chalk.white('1. Copy env.template to .env and fill in your values'));
+  logger.log(chalk.white('2. Run: aifabrix build ' + appName));
+  logger.log(chalk.white('3. Run: aifabrix run ' + appName));
+}
+
+/**
+ * Displays success message after app creation
+ * @param {string} appName - Application name
+ * @param {Object} config - Final configuration
+ * @param {string} envConversionMessage - Environment conversion message
+ * @param {boolean} hasAppFiles - Whether app files were created
+ * @param {string} appPath - Application path
+ */
+function displaySuccessMessage(appName, config, envConversionMessage, hasAppFiles = false, appPath = null) {
+  logger.log(chalk.green('\n✓ Application created successfully!'));
+  logger.log(chalk.blue(`\nApplication: ${appName}`));
+
+  // Determine location based on app type
+  const baseDir = config.type === 'external' ? 'integration' : 'builder';
+  const location = appPath ? path.relative(process.cwd(), appPath) : `${baseDir}/${appName}/`;
+  logger.log(chalk.blue(`Location: ${location}`));
+
+  if (hasAppFiles) {
+    logger.log(chalk.blue(`Application files: apps/${appName}/`));
+  }
+
+  if (config.type === 'external') {
+    displayExternalSystemSuccess(appName, config, location);
+  } else {
+    displayWebappSuccess(appName, config, envConversionMessage);
+  }
+}
+
+module.exports = {
+  displaySuccessMessage,
+  displayExternalSystemSuccess,
+  displayWebappSuccess
+};
+

package/lib/{app-dockerfile.js → app/dockerfile.js}

@@ -12,9 +12,9 @@ const fs = require('fs').promises;
 const path = require('path');
 const chalk = require('chalk');
 const yaml = require('js-yaml');
-const build = require('./build');
-const { validateAppName } = require('./app-push');
-const logger = require('./utils/logger');
+const build = require('../build');
+const { validateAppName } = require('./push');
+const logger = require('../utils/logger');
 
 /**
  * Checks if Dockerfile exists and validates overwrite permission
@@ -85,7 +85,7 @@ async function generateAndCopyDockerfile(appPath, dockerfilePath, config) {
  */
 async function generateDockerfileForApp(appName, options = {}) {
   // Check if app type is external - skip Dockerfile generation
-  const { detectAppType } = require('./utils/paths');
+  const { detectAppType } = require('../utils/paths');
   try {
     const { isExternal } = await detectAppType(appName);
     if (isExternal) {

package/lib/{app-down.js → app/down.js}

@@ -13,10 +13,10 @@
 
 const chalk = require('chalk');
 const { exec } = require('child_process');
-const logger = require('./utils/logger');
-const config = require('./config');
-const helpers = require('./app-run-helpers');
-const { validateAppName } = require('./app-push');
+const logger = require('../utils/logger');
+const config = require('../core/config');
+const helpers = require('./run-helpers');
+const { validateAppName } = require('./push');
 
 /**
  * Executes a shell command asynchronously.

package/lib/app/helpers.js

@@ -0,0 +1,218 @@
+/**
+ * Application Helper Utilities
+ *
+ * Helper functions for application creation and validation
+ *
+ * @fileoverview Helper utilities for application management
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+const fs = require('fs').promises;
+const path = require('path');
+const chalk = require('chalk');
+const { validateTemplate, copyTemplateFiles, copyAppFiles } = require('../validation/template');
+const logger = require('../utils/logger');
+
+/**
+ * Validates that app directory doesn't already exist
+ * @async
+ * @param {string} appPath - Application directory path
+ * @param {string} appName - Application name
+ * @param {string} baseDir - Base directory name
+ * @throws {Error} If directory already exists
+ */
+async function validateAppDirectoryNotExists(appPath, appName, baseDir = 'builder') {
+  try {
+    await fs.access(appPath);
+    throw new Error(`Application '${appName}' already exists in ${baseDir}/${appName}/`);
+  } catch (error) {
+    if (error.code !== 'ENOENT') {
+      throw error;
+    }
+  }
+}
+
+/**
+ * Gets the base directory path for an app based on its type
+ * @param {string} appType - Application type ('external' or other)
+ * @returns {string} Base directory path ('integration' or 'builder')
+ */
+function getBaseDirForAppType(appType) {
+  return appType === 'external' ? 'integration' : 'builder';
+}
+
+/**
+ * Handles GitHub workflow generation if requested
+ * @async
+ * @param {Object} options - Creation options
+ * @param {Object} config - Final configuration
+ */
+async function handleGitHubWorkflows(options, config) {
+  if (!options.github) {
+    return;
+  }
+
+  const githubGen = require('../generator/github');
+
+  // Parse github-steps if provided
+  const githubSteps = options.githubSteps
+    ? options.githubSteps.split(',').map(s => s.trim()).filter(s => s.length > 0)
+    : [];
+
+  const workflowFiles = await githubGen.generateGithubWorkflows(
+    process.cwd(),
+    config,
+    {
+      mainBranch: options.mainBranch || 'main',
+      uploadCoverage: true,
+      githubSteps: githubSteps
+    }
+  );
+
+  logger.log(chalk.green('✓ Generated GitHub Actions workflows:'));
+  workflowFiles.forEach(file => logger.log(chalk.gray(`  - ${file}`)));
+}
+
+/**
+ * Validates app creation prerequisites
+ * @async
+ * @function validateAppCreation
+ * @param {string} appName - Application name
+ * @param {Object} options - Creation options
+ * @param {string} appPath - Application directory path
+ * @param {string} baseDir - Base directory name
+ * @throws {Error} If validation fails
+ */
+async function validateAppCreation(appName, options, appPath, baseDir = 'builder') {
+  const { validateAppName } = require('./push');
+  validateAppName(appName);
+  await validateAppDirectoryNotExists(appPath, appName, baseDir);
+
+  if (!options.app) {
+    return;
+  }
+
+  const appsPath = path.join(process.cwd(), 'apps', appName);
+  try {
+    await fs.access(appsPath);
+    throw new Error(`Application '${appName}' already exists in apps/${appName}/`);
+  } catch (error) {
+    if (error.code !== 'ENOENT') {
+      throw error;
+    }
+  }
+}
+
+/**
+ * Processes template files if template is specified
+ * @async
+ * @function processTemplateFiles
+ * @param {string} template - Template name
+ * @param {string} appPath - Application directory path
+ * @param {string} appName - Application name
+ * @param {Object} options - Creation options
+ * @param {Object} config - Final configuration
+ * @throws {Error} If template processing fails
+ */
+async function processTemplateFiles(template, appPath, appName, options, config) {
+  if (!template) {
+    return;
+  }
+
+  await validateTemplate(template);
+  const copiedFiles = await copyTemplateFiles(template, appPath);
+  logger.log(chalk.green(`✓ Copied ${copiedFiles.length} file(s) from template '${template}'`));
+  const { updateTemplateVariables } = require('../utils/template-helpers');
+  await updateTemplateVariables(appPath, appName, options, config);
+}
+
+/**
+ * Updates variables.yaml for --app flag
+ * @async
+ * @function updateVariablesForAppFlag
+ * @param {string} appPath - Application directory path
+ * @param {string} appName - Application name
+ * @throws {Error} If update fails
+ */
+async function updateVariablesForAppFlag(appPath, appName) {
+  try {
+    const yaml = require('js-yaml');
+    const variablesPath = path.join(appPath, 'variables.yaml');
+    const variablesContent = await fs.readFile(variablesPath, 'utf8');
+    const variables = yaml.load(variablesContent);
+
+    if (variables.build) {
+      variables.build.context = '../..';
+      variables.build.envOutputPath = `../../apps/${appName}/.env`;
+    } else {
+      variables.build = {
+        context: '../..',
+        envOutputPath: `../../apps/${appName}/.env`
+      };
+    }
+
+    await fs.writeFile(variablesPath, yaml.dump(variables, { indent: 2, lineWidth: 120, noRefs: true }));
+  } catch (error) {
+    logger.warn(chalk.yellow(`⚠️  Warning: Could not update variables.yaml: ${error.message}`));
+  }
+}
+
+/**
+ * Gets language from config or variables.yaml
+ * @async
+ * @function getLanguageForAppFiles
+ * @param {string} language - Language from config
+ * @param {string} appPath - Application directory path
+ * @returns {Promise<string>} Language to use
+ * @throws {Error} If language cannot be determined
+ */
+async function getLanguageForAppFiles(language, appPath) {
+  if (language) {
+    return language;
+  }
+
+  const yaml = require('js-yaml');
+  const variablesPath = path.join(appPath, 'variables.yaml');
+  const variablesContent = await fs.readFile(variablesPath, 'utf8');
+  const variables = yaml.load(variablesContent);
+  const languageFromYaml = variables?.build?.language;
+
+  if (!languageFromYaml) {
+    throw new Error('Language not specified and could not be determined from variables.yaml. Use --language flag or ensure variables.yaml contains build.language');
+  }
+
+  return languageFromYaml;
+}
+
+/**
+ * Sets up apps directory and copies application files
+ * @async
+ * @function setupAppFiles
+ * @param {string} appName - Application name
+ * @param {string} appPath - Application directory path
+ * @param {Object} config - Final configuration
+ * @param {Object} options - Creation options
+ * @throws {Error} If setup fails
+ */
+async function setupAppFiles(appName, appPath, config, options) {
+  const appsPath = path.join(process.cwd(), 'apps', appName);
+  await fs.mkdir(appsPath, { recursive: true });
+  await updateVariablesForAppFlag(appPath, appName);
+
+  const language = await getLanguageForAppFiles(config.language || options.language, appPath);
+  const copiedFiles = await copyAppFiles(language, appsPath);
+  logger.log(chalk.green(`✓ Copied ${copiedFiles.length} application file(s) to apps/${appName}/`));
+}
+
+module.exports = {
+  validateAppDirectoryNotExists,
+  getBaseDirForAppType,
+  handleGitHubWorkflows,
+  validateAppCreation,
+  processTemplateFiles,
+  updateVariablesForAppFlag,
+  getLanguageForAppFiles,
+  setupAppFiles
+};
+