@aifabrix/builder 2.0.0 → 2.0.2

package/lib/app-dockerfile.js

@@ -0,0 +1,112 @@
+/**
+ * Application Dockerfile Generation
+ *
+ * Handles Dockerfile generation for applications
+ *
+ * @fileoverview Dockerfile generation for AI Fabrix Builder
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+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');
+
+/**
+ * Checks if Dockerfile exists and validates overwrite permission
+ * @async
+ * @param {string} dockerfilePath - Path to Dockerfile
+ * @param {Object} options - Generation options
+ * @throws {Error} If Dockerfile exists and force is not enabled
+ */
+async function checkDockerfileExists(dockerfilePath, options) {
+  try {
+    await fs.access(dockerfilePath);
+    if (!options.force) {
+      throw new Error(`Dockerfile already exists at ${dockerfilePath}. Use --force to overwrite.`);
+    }
+  } catch (error) {
+    if (error.code === 'ENOENT') {
+      // File doesn't exist, that's okay
+      return;
+    }
+    throw error;
+  }
+}
+
+/**
+ * Loads application configuration from variables.yaml
+ * @async
+ * @param {string} configPath - Path to variables.yaml
+ * @param {Object} options - Generation options
+ * @returns {Promise<Object>} Application configuration
+ * @throws {Error} If configuration cannot be loaded
+ */
+async function loadAppConfig(configPath, options) {
+  try {
+    const yamlContent = await fs.readFile(configPath, 'utf8');
+    const variables = yaml.load(yamlContent);
+    return {
+      language: options.language || variables.build?.language || 'typescript',
+      port: variables.build?.port || variables.port || 3000,
+      ...variables
+    };
+  } catch {
+    throw new Error(`Failed to load configuration from ${configPath}`);
+  }
+}
+
+/**
+ * Generates and copies Dockerfile to app directory
+ * @async
+ * @param {string} appPath - Application directory path
+ * @param {string} dockerfilePath - Target Dockerfile path
+ * @param {Object} config - Application configuration
+ * @returns {Promise<string>} Path to generated Dockerfile
+ */
+async function generateAndCopyDockerfile(appPath, dockerfilePath, config) {
+  // Extract buildConfig from config to pass to generateDockerfile
+  const buildConfig = config.build || {};
+  const generatedPath = await build.generateDockerfile(appPath, config.language, config, buildConfig);
+  await fs.copyFile(generatedPath, dockerfilePath);
+  logger.log(chalk.green('✓ Generated Dockerfile from template'));
+  return dockerfilePath;
+}
+
+/**
+ * Generate Dockerfile for an application
+ * @param {string} appName - Application name
+ * @param {Object} options - Generation options
+ * @returns {Promise<string>} Path to generated Dockerfile
+ */
+async function generateDockerfileForApp(appName, options = {}) {
+  try {
+    // Validate app name
+    validateAppName(appName);
+
+    const appPath = path.join(process.cwd(), 'builder', appName);
+    const dockerfilePath = path.join(appPath, 'Dockerfile');
+
+    // Check if Dockerfile already exists
+    await checkDockerfileExists(dockerfilePath, options);
+
+    // Load configuration
+    const configPath = path.join(appPath, 'variables.yaml');
+    const config = await loadAppConfig(configPath, options);
+
+    // Generate and copy Dockerfile
+    return await generateAndCopyDockerfile(appPath, dockerfilePath, config);
+
+  } catch (error) {
+    throw new Error(`Failed to generate Dockerfile: ${error.message}`);
+  }
+}
+
+module.exports = {
+  generateDockerfileForApp
+};
+

package/lib/app-prompts.js

@@ -0,0 +1,244 @@
+/**
+ * Application Prompting Utilities
+ *
+ * Handles interactive prompts for application configuration
+ *
+ * @fileoverview Prompt utilities for AI Fabrix Builder
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+const inquirer = require('inquirer');
+
+/**
+ * Builds basic questions (port, language)
+ * @param {Object} options - Provided options
+ * @returns {Array} Array of question objects
+ */
+function buildBasicQuestions(options) {
+  const questions = [];
+
+  // Port validation
+  if (!options.port) {
+    questions.push({
+      type: 'input',
+      name: 'port',
+      message: 'What port should the application run on?',
+      default: '3000',
+      validate: (input) => {
+        const port = parseInt(input, 10);
+        if (isNaN(port) || port < 1 || port > 65535) {
+          return 'Port must be a number between 1 and 65535';
+        }
+        return true;
+      }
+    });
+  }
+
+  // Language selection
+  if (!options.language) {
+    questions.push({
+      type: 'list',
+      name: 'language',
+      message: 'What language is your application written in?',
+      choices: [
+        { name: 'TypeScript/Node.js', value: 'typescript' },
+        { name: 'Python', value: 'python' }
+      ],
+      default: 'typescript'
+    });
+  }
+
+  return questions;
+}
+
+/**
+ * Builds service questions (database, redis, storage, authentication)
+ * @param {Object} options - Provided options
+ * @returns {Array} Array of question objects
+ */
+function buildServiceQuestions(options) {
+  const questions = [];
+
+  if (!Object.prototype.hasOwnProperty.call(options, 'database')) {
+    questions.push({
+      type: 'confirm',
+      name: 'database',
+      message: 'Does your application need a database?',
+      default: false
+    });
+  }
+
+  if (!Object.prototype.hasOwnProperty.call(options, 'redis')) {
+    questions.push({
+      type: 'confirm',
+      name: 'redis',
+      message: 'Does your application need Redis?',
+      default: false
+    });
+  }
+
+  if (!Object.prototype.hasOwnProperty.call(options, 'storage')) {
+    questions.push({
+      type: 'confirm',
+      name: 'storage',
+      message: 'Does your application need file storage?',
+      default: false
+    });
+  }
+
+  if (!Object.prototype.hasOwnProperty.call(options, 'authentication')) {
+    questions.push({
+      type: 'confirm',
+      name: 'authentication',
+      message: 'Does your application need authentication/RBAC?',
+      default: false
+    });
+  }
+
+  return questions;
+}
+
+/**
+ * Builds workflow questions (GitHub, Controller)
+ * @param {Object} options - Provided options
+ * @returns {Array} Array of question objects
+ */
+function buildWorkflowQuestions(options) {
+  const questions = [];
+
+  // GitHub workflows
+  if (!Object.prototype.hasOwnProperty.call(options, 'github')) {
+    questions.push({
+      type: 'confirm',
+      name: 'github',
+      message: 'Do you need GitHub Actions workflows?',
+      default: false
+    });
+  }
+
+  // Controller deployment
+  if (!Object.prototype.hasOwnProperty.call(options, 'controller') &&
+      options.github !== false) {
+    questions.push({
+      type: 'confirm',
+      name: 'controller',
+      message: 'Do you need Controller deployment workflow?',
+      default: false,
+      when: (answers) => answers.github !== false
+    });
+  }
+
+  // Controller URL
+  if (!options.controllerUrl && options.controller &&
+      !Object.prototype.hasOwnProperty.call(options, 'controllerUrl')) {
+    const misoHost = process.env.MISO_HOST || 'localhost';
+    questions.push({
+      type: 'input',
+      name: 'controllerUrl',
+      message: 'Enter Controller URL:',
+      default: `http://${misoHost}:3000`,
+      when: (answers) => answers.controller === true
+    });
+  }
+
+  return questions;
+}
+
+/**
+ * Resolves conflicts between options and answers for a specific field
+ * @function resolveField
+ * @param {*} optionValue - Value from options
+ * @param {*} answerValue - Value from answers
+ * @param {*} defaultValue - Default value
+ * @returns {*} Resolved value
+ */
+function resolveField(optionValue, answerValue, defaultValue) {
+  if (optionValue !== undefined && optionValue !== null) {
+    return optionValue;
+  }
+  if (answerValue !== undefined && answerValue !== null) {
+    return answerValue;
+  }
+  return defaultValue;
+}
+
+/**
+ * Resolves conflicts between options and answers for optional boolean fields
+ * @function resolveOptionalBoolean
+ * @param {*} optionValue - Value from options
+ * @param {*} answerValue - Value from answers
+ * @param {*} defaultValue - Default value
+ * @returns {*} Resolved value
+ */
+function resolveOptionalBoolean(optionValue, answerValue, defaultValue) {
+  if (optionValue !== undefined) {
+    return optionValue;
+  }
+  return answerValue !== undefined ? answerValue : defaultValue;
+}
+
+/**
+ * Resolves conflicts between options and answers
+ * @function resolveConflicts
+ * @param {Object} options - Provided options
+ * @param {Object} answers - Prompt answers
+ * @returns {Object} Resolved configuration
+ */
+function resolveConflicts(options, answers) {
+  return {
+    port: parseInt(resolveField(options.port, answers.port, 3000), 10),
+    language: resolveField(options.language, answers.language, 'typescript'),
+    database: resolveField(options.database, answers.database, false),
+    redis: resolveField(options.redis, answers.redis, false),
+    storage: resolveField(options.storage, answers.storage, false),
+    authentication: resolveField(options.authentication, answers.authentication, false),
+    github: resolveOptionalBoolean(options.github, answers.github, false),
+    controller: resolveOptionalBoolean(options.controller, answers.controller, false),
+    controllerUrl: resolveField(options.controllerUrl, answers.controllerUrl, undefined)
+  };
+}
+
+/**
+ * Merges provided options with prompt answers
+ * @param {string} appName - Application name
+ * @param {Object} options - Provided options
+ * @param {Object} answers - Prompt answers
+ * @returns {Object} Complete configuration
+ */
+function mergePromptAnswers(appName, options, answers) {
+  return {
+    appName,
+    ...resolveConflicts(options, answers)
+  };
+}
+
+/**
+ * Prompt for missing configuration options
+ * @param {string} appName - Application name
+ * @param {Object} options - Provided options
+ * @returns {Promise<Object>} Complete configuration
+ */
+async function promptForOptions(appName, options) {
+  // Default github to false if not provided (make it truly optional)
+  if (!Object.prototype.hasOwnProperty.call(options, 'github')) {
+    options.github = false;
+  }
+
+  const questions = [
+    ...buildBasicQuestions(options),
+    ...buildServiceQuestions(options),
+    ...buildWorkflowQuestions(options)
+  ];
+
+  // Prompt for missing options
+  const answers = questions.length > 0 ? await inquirer.prompt(questions) : {};
+
+  // Merge provided options with answers
+  return mergePromptAnswers(appName, options, answers);
+}
+
+module.exports = {
+  promptForOptions
+};
+

package/lib/app-push.js

@@ -0,0 +1,172 @@
+/**
+ * Application Push Utilities
+ *
+ * Handles pushing Docker images to container registries
+ *
+ * @fileoverview Push functionality for AI Fabrix Builder
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+const fs = require('fs').promises;
+const path = require('path');
+const chalk = require('chalk');
+const yaml = require('js-yaml');
+const pushUtils = require('./push');
+const logger = require('./utils/logger');
+
+/**
+ * Validate application name format
+ * @param {string} appName - Application name to validate
+ * @throws {Error} If app name is invalid
+ */
+function validateAppName(appName) {
+  if (!appName || typeof appName !== 'string') {
+    throw new Error('Application name is required');
+  }
+
+  // App name should be lowercase, alphanumeric with dashes, 3-40 characters
+  const nameRegex = /^[a-z0-9-]{3,40}$/;
+  if (!nameRegex.test(appName)) {
+    throw new Error('Application name must be 3-40 characters, lowercase letters, numbers, and dashes only');
+  }
+
+  // Cannot start or end with dash
+  if (appName.startsWith('-') || appName.endsWith('-')) {
+    throw new Error('Application name cannot start or end with a dash');
+  }
+
+  // Cannot have consecutive dashes
+  if (appName.includes('--')) {
+    throw new Error('Application name cannot have consecutive dashes');
+  }
+}
+
+/**
+ * Loads push configuration from variables.yaml
+ * @async
+ * @param {string} appName - Application name
+ * @param {Object} options - Push options
+ * @returns {Promise<Object>} Configuration with registry
+ * @throws {Error} If configuration cannot be loaded
+ */
+async function loadPushConfig(appName, options) {
+  const configPath = path.join(process.cwd(), 'builder', appName, 'variables.yaml');
+  try {
+    const config = yaml.load(await fs.readFile(configPath, 'utf8'));
+    const registry = options.registry || config.image?.registry;
+    if (!registry) {
+      throw new Error('Registry URL is required. Provide via --registry flag or configure in variables.yaml under image.registry');
+    }
+    return { registry };
+  } catch (error) {
+    if (error.message.includes('Registry URL')) {
+      throw error;
+    }
+    throw new Error(`Failed to load configuration: ${configPath}\nRun 'aifabrix create ${appName}' first`);
+  }
+}
+
+/**
+ * Validates push configuration
+ * @param {string} registry - Registry URL
+ * @param {string} appName - Application name
+ * @throws {Error} If validation fails
+ */
+async function validatePushConfig(registry, appName) {
+  // Validate ACR URL format specifically (must be *.azurecr.io)
+  if (!/^[^.]+\.azurecr\.io$/.test(registry)) {
+    throw new Error(`Invalid ACR URL format: ${registry}. Expected format: *.azurecr.io`);
+  }
+
+  if (!pushUtils.validateRegistryURL(registry)) {
+    throw new Error(`Invalid registry URL format: ${registry}. Expected format: *.azurecr.io`);
+  }
+
+  if (!await pushUtils.checkLocalImageExists(appName, 'latest')) {
+    throw new Error(`Docker image ${appName}:latest not found locally.\nRun 'aifabrix build ${appName}' first`);
+  }
+
+  if (!await pushUtils.checkAzureCLIInstalled()) {
+    throw new Error('Azure CLI is not installed. Install from: https://docs.microsoft.com/cli/azure/install-azure-cli');
+  }
+}
+
+/**
+ * Authenticates with Azure Container Registry
+ * @async
+ * @param {string} registry - Registry URL
+ */
+async function authenticateWithRegistry(registry) {
+  if (await pushUtils.checkACRAuthentication(registry)) {
+    logger.log(chalk.green(`✓ Already authenticated with ${registry}`));
+  } else {
+    await pushUtils.authenticateACR(registry);
+  }
+}
+
+/**
+ * Pushes image tags to registry
+ * @async
+ * @param {string} appName - Application name
+ * @param {string} registry - Registry URL
+ * @param {Array<string>} tags - Image tags
+ */
+async function pushImageTags(appName, registry, tags) {
+  await Promise.all(tags.map(async(tag) => {
+    await pushUtils.tagImage(`${appName}:latest`, `${registry}/${appName}:${tag}`);
+    await pushUtils.pushImage(`${registry}/${appName}:${tag}`);
+  }));
+}
+
+/**
+ * Displays push results
+ * @param {string} registry - Registry URL
+ * @param {string} appName - Application name
+ * @param {Array<string>} tags - Image tags
+ */
+function displayPushResults(registry, appName, tags) {
+  logger.log(chalk.green(`\n✓ Successfully pushed ${tags.length} tag(s) to ${registry}`));
+  logger.log(chalk.gray(`Image: ${registry}/${appName}:*`));
+  logger.log(chalk.gray(`Tags: ${tags.join(', ')}`));
+}
+
+/**
+ * Pushes application image to Azure Container Registry
+ * @async
+ * @function pushApp
+ * @param {string} appName - Name of the application
+ * @param {Object} options - Push options (registry, tag)
+ * @returns {Promise<void>} Resolves when push is complete
+ */
+async function pushApp(appName, options = {}) {
+  try {
+    // Validate app name
+    validateAppName(appName);
+
+    // Load configuration
+    const { registry } = await loadPushConfig(appName, options);
+
+    // Validate push configuration
+    await validatePushConfig(registry, appName);
+
+    // Authenticate with registry
+    await authenticateWithRegistry(registry);
+
+    // Push image tags
+    const tags = options.tag ? options.tag.split(',').map(t => t.trim()) : ['latest'];
+    await pushImageTags(appName, registry, tags);
+
+    // Display results
+    displayPushResults(registry, appName, tags);
+
+  } catch (error) {
+    throw new Error(`Failed to push application: ${error.message}`);
+  }
+}
+
+module.exports = {
+  pushApp,
+  validateAppName
+};
+