@aifabrix/builder 2.0.0

package/lib/build.js

@@ -0,0 +1,313 @@
+/**
+ * AI Fabrix Builder Build Functions
+ *
+ * This module handles application building, Docker image creation,
+ * and Dockerfile generation. Separated from app.js to maintain
+ * file size limits and improve code organization.
+ *
+ * @fileoverview Build functions for AI Fabrix Builder
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+const fs = require('fs').promises;
+const fsSync = require('fs');
+const path = require('path');
+const { exec } = require('child_process');
+const { promisify } = require('util');
+const chalk = require('chalk');
+const yaml = require('js-yaml');
+const handlebars = require('handlebars');
+const validator = require('./validator');
+const secrets = require('./secrets');
+
+const execAsync = promisify(exec);
+
+/**
+ * Loads variables.yaml configuration for an application
+ * @param {string} appName - Application name
+ * @returns {Promise<Object>} Configuration object
+ * @throws {Error} If file cannot be loaded or parsed
+ */
+async function loadVariablesYaml(appName) {
+  const variablesPath = path.join(process.cwd(), 'builder', appName, 'variables.yaml');
+
+  if (!fsSync.existsSync(variablesPath)) {
+    throw new Error(`Configuration not found. Run 'aifabrix create ${appName}' first.`);
+  }
+
+  const content = fsSync.readFileSync(variablesPath, 'utf8');
+  let variables;
+
+  try {
+    variables = yaml.load(content);
+  } catch (error) {
+    throw new Error(`Invalid YAML syntax in variables.yaml: ${error.message}`);
+  }
+
+  return variables;
+}
+
+/**
+ * Resolves build context path relative to builder directory
+ * @param {string} builderPath - Path to builder directory
+ * @param {string} contextPath - Relative context path
+ * @returns {string} Absolute context path
+ * @throws {Error} If context path doesn't exist
+ */
+function resolveContextPath(builderPath, contextPath) {
+  if (!contextPath) {
+    return process.cwd();
+  }
+
+  const resolvedPath = path.resolve(builderPath, contextPath);
+
+  if (!fsSync.existsSync(resolvedPath)) {
+    throw new Error(`Build context not found: ${resolvedPath}`);
+  }
+
+  return resolvedPath;
+}
+
+/**
+ * Executes Docker build command with proper error handling
+ * @param {string} imageName - Image name to build
+ * @param {string} dockerfilePath - Path to Dockerfile
+ * @param {string} contextPath - Build context path
+ * @param {string} tag - Image tag
+ * @returns {Promise<void>} Resolves when build completes
+ * @throws {Error} If build fails
+ */
+async function executeDockerBuild(imageName, dockerfilePath, contextPath, tag) {
+  const dockerCommand = `docker build -t ${imageName}:${tag} -f "${dockerfilePath}" "${contextPath}"`;
+
+  try {
+    console.log(chalk.blue('Building image...'));
+    console.log(chalk.gray(`Command: ${dockerCommand}`));
+
+    const { stdout, stderr } = await execAsync(dockerCommand);
+
+    if (stderr && !stderr.includes('warning')) {
+      console.log(chalk.yellow(stderr));
+    }
+
+    if (stdout) {
+      console.log(stdout);
+    }
+
+    console.log(chalk.green(`✓ Image built: ${imageName}:${tag}`));
+  } catch (error) {
+    if (error.message.includes('docker: command not found')) {
+      throw new Error('Docker is not running or not installed. Please start Docker Desktop.');
+    }
+
+    throw new Error(`Docker build failed: ${error.message}`);
+  }
+}
+
+/**
+ * Detects the runtime language of an application
+ * Analyzes project files to determine TypeScript, Python, etc.
+ *
+ * @function detectLanguage
+ * @param {string} appPath - Path to application directory
+ * @returns {string} Detected language ('typescript', 'python', etc.)
+ * @throws {Error} If language cannot be detected
+ *
+ * @example
+ * const language = detectLanguage('./myapp');
+ * // Returns: 'typescript'
+ */
+function detectLanguage(appPath) {
+  const packageJsonPath = path.join(appPath, 'package.json');
+  const requirementsPath = path.join(appPath, 'requirements.txt');
+  const pyprojectPath = path.join(appPath, 'pyproject.toml');
+  const dockerfilePath = path.join(appPath, 'Dockerfile');
+
+  // Check for package.json (TypeScript/Node.js)
+  if (fsSync.existsSync(packageJsonPath)) {
+    return 'typescript';
+  }
+
+  // Check for requirements.txt or pyproject.toml (Python)
+  if (fsSync.existsSync(requirementsPath) || fsSync.existsSync(pyprojectPath)) {
+    return 'python';
+  }
+
+  // Check for custom Dockerfile
+  if (fsSync.existsSync(dockerfilePath)) {
+    throw new Error('Custom Dockerfile found. Use --force-template to regenerate from template.');
+  }
+
+  // Default to typescript if no indicators found
+  return 'typescript';
+}
+
+/**
+ * Generates a Dockerfile from template based on detected language
+ * Uses Handlebars templates to create optimized Dockerfiles
+ *
+ * @async
+ * @function generateDockerfile
+ * @param {string} appPath - Path to application directory
+ * @param {string} language - Target language ('typescript', 'python')
+ * @param {Object} config - Application configuration from variables.yaml
+ * @returns {Promise<string>} Path to generated Dockerfile
+ * @throws {Error} If template generation fails
+ *
+ * @example
+ * const dockerfilePath = await generateDockerfile('./myapp', 'typescript', config);
+ * // Returns: './myapp/.aifabrix/Dockerfile.typescript'
+ */
+async function generateDockerfile(appPath, language, config) {
+  const templatePath = path.join(__dirname, '..', 'templates', language, 'Dockerfile.hbs');
+
+  if (!fsSync.existsSync(templatePath)) {
+    throw new Error(`Template not found for language: ${language}`);
+  }
+
+  const templateContent = fsSync.readFileSync(templatePath, 'utf8');
+  const template = handlebars.compile(templateContent);
+
+  // Prepare template variables
+  const templateVars = {
+    port: config.port || 3000,
+    healthCheck: {
+      interval: config.healthCheck?.interval || 30,
+      path: config.healthCheck?.path || '/health'
+    },
+    startupCommand: config.startupCommand
+  };
+
+  const dockerfileContent = template(templateVars);
+
+  // Create .aifabrix directory if it doesn't exist
+  const aifabrixDir = path.join(appPath, '.aifabrix');
+  if (!fsSync.existsSync(aifabrixDir)) {
+    await fs.mkdir(aifabrixDir, { recursive: true });
+  }
+
+  const dockerfilePath = path.join(aifabrixDir, `Dockerfile.${language}`);
+  await fs.writeFile(dockerfilePath, dockerfileContent);
+
+  return dockerfilePath;
+}
+
+/**
+ * Builds a container image for the specified application
+ * Auto-detects runtime and generates Dockerfile if needed
+ *
+ * @async
+ * @function buildApp
+ * @param {string} appName - Name of the application to build
+ * @param {Object} options - Build options
+ * @param {string} [options.language] - Override language detection
+ * @param {boolean} [options.forceTemplate] - Force rebuild from template
+ * @param {string} [options.tag] - Image tag (default: latest)
+ * @returns {Promise<string>} Image tag that was built
+ * @throws {Error} If build fails or app configuration is invalid
+ *
+ * @example
+ * const imageTag = await buildApp('myapp', { language: 'typescript' });
+ * // Returns: 'myapp:latest'
+ */
+async function buildApp(appName, options = {}) {
+  try {
+    console.log(chalk.blue(`\n🔨 Building application: ${appName}`));
+
+    // 1. Load and validate configuration
+    const config = await loadVariablesYaml(appName);
+    console.log(chalk.green(`✓ Loaded configuration from builder/${appName}/variables.yaml`));
+
+    // Validate configuration
+    const validation = await validator.validateVariables(appName);
+    if (!validation.valid) {
+      console.log(chalk.red('❌ Configuration validation failed:'));
+      validation.errors.forEach(error => console.log(chalk.red(`  - ${error}`)));
+      throw new Error('Configuration validation failed');
+    }
+
+    // Extract configuration values
+    const imageName = config.image?.split(':')[0] || appName;
+    const buildConfig = config.build || {};
+
+    // 2. Determine language
+    let language = options.language || buildConfig.language;
+    if (!language) {
+      const builderPath = path.join(process.cwd(), 'builder', appName);
+      language = detectLanguage(builderPath);
+    }
+    console.log(chalk.green(`✓ Detected language: ${language}`));
+
+    // 3. Determine Dockerfile
+    let dockerfilePath;
+    const customDockerfile = buildConfig.dockerfile;
+
+    if (customDockerfile && !options.forceTemplate) {
+      const customPath = path.join(process.cwd(), 'builder', appName, customDockerfile);
+      if (fsSync.existsSync(customPath)) {
+        dockerfilePath = customPath;
+        console.log(chalk.green(`✓ Using custom Dockerfile: ${customDockerfile}`));
+      }
+    }
+
+    if (!dockerfilePath || options.forceTemplate) {
+      // Generate Dockerfile from template
+      const builderPath = path.join(process.cwd(), 'builder', appName);
+      dockerfilePath = await generateDockerfile(builderPath, language, config);
+      console.log(chalk.green(`✓ Generated Dockerfile from template: .aifabrix/Dockerfile.${language}`));
+    }
+
+    // 4. Determine build context
+    const contextPath = resolveContextPath(
+      path.join(process.cwd(), 'builder', appName),
+      buildConfig.context
+    );
+
+    // 5. Build Docker image
+    const tag = options.tag || 'latest';
+    await executeDockerBuild(imageName, dockerfilePath, contextPath, tag);
+
+    // 6. Tag image if additional tag provided
+    if (options.tag && options.tag !== 'latest') {
+      await execAsync(`docker tag ${imageName}:${tag} ${imageName}:latest`);
+      console.log(chalk.green(`✓ Tagged image: ${imageName}:latest`));
+    }
+
+    // 7. Generate .env file
+    try {
+      const envPath = await secrets.generateEnvFile(appName, buildConfig.secrets);
+      console.log(chalk.green(`✓ Generated .env file: ${envPath}`));
+
+      // Copy to output path if specified
+      if (buildConfig.envOutputPath) {
+        const outputPath = path.resolve(path.join(process.cwd(), 'builder', appName), buildConfig.envOutputPath);
+        const outputDir = path.dirname(outputPath);
+
+        if (!fsSync.existsSync(outputDir)) {
+          await fs.mkdir(outputDir, { recursive: true });
+        }
+
+        await fs.copyFile(envPath, outputPath);
+        console.log(chalk.green(`✓ Copied .env to: ${buildConfig.envOutputPath}`));
+      }
+    } catch (error) {
+      console.log(chalk.yellow(`⚠️  Warning: Could not generate .env file: ${error.message}`));
+    }
+
+    console.log(chalk.green('\n✅ Build completed successfully!'));
+    return `${imageName}:${tag}`;
+
+  } catch (error) {
+    throw new Error(`Build failed: ${error.message}`);
+  }
+}
+
+module.exports = {
+  loadVariablesYaml,
+  resolveContextPath,
+  executeDockerBuild,
+  detectLanguage,
+  generateDockerfile,
+  buildApp
+};

package/lib/cli.js

@@ -0,0 +1,307 @@
+/**
+ * AI Fabrix Builder CLI Command Definitions
+ *
+ * This module defines all CLI commands using Commander.js.
+ * Commands: up, down, build, run, push, deploy, resolve, json, genkey, doctor
+ *
+ * @fileoverview Command definitions for AI Fabrix Builder CLI
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+const infra = require('./infra');
+const app = require('./app');
+const secrets = require('./secrets');
+const generator = require('./generator');
+const validator = require('./validator');
+const keyGenerator = require('./key-generator');
+
+/**
+ * Sets up all CLI commands on the Commander program instance
+ * @param {Command} program - Commander program instance
+ */
+function setupCommands(program) {
+  // Infrastructure commands
+  program.command('up')
+    .description('Start local infrastructure services (Postgres, Redis, pgAdmin, Redis Commander)')
+    .action(async() => {
+      try {
+        await infra.startInfra();
+      } catch (error) {
+        handleCommandError(error, 'up');
+        process.exit(1);
+      }
+    });
+
+  program.command('down')
+    .description('Stop and remove local infrastructure services')
+    .option('-v, --volumes', 'Remove volumes (deletes all data)')
+    .action(async(options) => {
+      try {
+        if (options.volumes) {
+          await infra.stopInfraWithVolumes();
+        } else {
+          await infra.stopInfra();
+        }
+      } catch (error) {
+        handleCommandError(error, 'down');
+        process.exit(1);
+      }
+    });
+
+  // Application commands
+  program.command('create <app>')
+    .description('Create new application with configuration files')
+    .option('-p, --port <port>', 'Application port', '3000')
+    .option('-d, --database', 'Requires database')
+    .option('-r, --redis', 'Requires Redis')
+    .option('-s, --storage', 'Requires file storage')
+    .option('-a, --authentication', 'Requires authentication/RBAC')
+    .option('-l, --language <lang>', 'Runtime language (typescript/python)')
+    .option('-t, --template <name>', 'Template to use')
+    .option('-g, --github', 'Generate GitHub Actions workflows')
+    .option('--main-branch <branch>', 'Main branch name for workflows', 'main')
+    .action(async(appName, options) => {
+      try {
+        await app.createApp(appName, options);
+      } catch (error) {
+        handleCommandError(error, 'create');
+        process.exit(1);
+      }
+    });
+
+  program.command('build <app>')
+    .description('Build container image (auto-detects runtime)')
+    .option('-l, --language <lang>', 'Override language detection')
+    .option('-f, --force-template', 'Force rebuild from template')
+    .option('-t, --tag <tag>', 'Image tag (default: latest)')
+    .action(async(appName, options) => {
+      try {
+        const imageTag = await app.buildApp(appName, options);
+        console.log(`✅ Built image: ${imageTag}`);
+      } catch (error) {
+        handleCommandError(error, 'build');
+        process.exit(1);
+      }
+    });
+
+  program.command('run <app>')
+    .description('Run application locally')
+    .option('-p, --port <port>', 'Override local port')
+    .action(async(appName, options) => {
+      try {
+        await app.runApp(appName, options);
+      } catch (error) {
+        handleCommandError(error, 'run');
+        process.exit(1);
+      }
+    });
+
+  // Deployment commands
+  program.command('push <app>')
+    .description('Push image to Azure Container Registry')
+    .option('-r, --registry <registry>', 'ACR registry URL (overrides variables.yaml)')
+    .option('-t, --tag <tag>', 'Image tag(s) - comma-separated for multiple (default: latest)')
+    .action(async(appName, options) => {
+      try {
+        await app.pushApp(appName, options);
+      } catch (error) {
+        handleCommandError(error, 'push');
+        process.exit(1);
+      }
+    });
+
+  program.command('deploy <app>')
+    .description('Deploy to Azure via Miso Controller')
+    .option('-c, --controller <url>', 'Controller URL (required)')
+    .option('-e, --environment <env>', 'Target environment (dev/tst/pro)')
+    .action(async(appName, options) => {
+      try {
+        await app.deployApp(appName, options);
+      } catch (error) {
+        handleCommandError(error, 'deploy');
+        process.exit(1);
+      }
+    });
+
+  // Infrastructure status and management
+  program.command('doctor')
+    .description('Check environment and configuration')
+    .action(async() => {
+      try {
+        const result = await validator.checkEnvironment();
+        console.log('\n🔍 AI Fabrix Environment Check\n');
+
+        console.log(`Docker: ${result.docker === 'ok' ? '✅ Running' : '❌ Not available'}`);
+        console.log(`Ports: ${result.ports === 'ok' ? '✅ Available' : '⚠️  Some ports in use'}`);
+        console.log(`Secrets: ${result.secrets === 'ok' ? '✅ Configured' : '❌ Missing'}`);
+
+        if (result.recommendations.length > 0) {
+          console.log('\n📋 Recommendations:');
+          result.recommendations.forEach(rec => console.log(`  • ${rec}`));
+        }
+
+        // Check infrastructure health if Docker is available
+        if (result.docker === 'ok') {
+          try {
+            const health = await infra.checkInfraHealth();
+            console.log('\n🏥 Infrastructure Health:');
+            Object.entries(health).forEach(([service, status]) => {
+              const icon = status === 'healthy' ? '✅' : status === 'unknown' ? '❓' : '❌';
+              console.log(`  ${icon} ${service}: ${status}`);
+            });
+          } catch (error) {
+            console.log('\n🏥 Infrastructure: Not running');
+          }
+        }
+
+        console.log('');
+      } catch (error) {
+        handleCommandError(error, 'doctor');
+        process.exit(1);
+      }
+    });
+
+  program.command('status')
+    .description('Show detailed infrastructure service status')
+    .action(async() => {
+      try {
+        const status = await infra.getInfraStatus();
+        console.log('\n📊 Infrastructure Status\n');
+
+        Object.entries(status).forEach(([service, info]) => {
+          const icon = info.status === 'running' ? '✅' : '❌';
+          console.log(`${icon} ${service}:`);
+          console.log(`   Status: ${info.status}`);
+          console.log(`   Port: ${info.port}`);
+          console.log(`   URL: ${info.url}`);
+          console.log('');
+        });
+      } catch (error) {
+        handleCommandError(error, 'status');
+        process.exit(1);
+      }
+    });
+
+  program.command('restart <service>')
+    .description('Restart a specific infrastructure service')
+    .action(async(service) => {
+      try {
+        await infra.restartService(service);
+        console.log(`✅ ${service} service restarted successfully`);
+      } catch (error) {
+        handleCommandError(error, 'restart');
+        process.exit(1);
+      }
+    });
+
+  // Utility commands
+  program.command('resolve <app>')
+    .description('Generate .env file from template')
+    .action(async(appName) => {
+      try {
+        const envPath = await secrets.generateEnvFile(appName);
+        console.log(`✓ Generated .env file: ${envPath}`);
+      } catch (error) {
+        handleCommandError(error, 'resolve');
+        process.exit(1);
+      }
+    });
+
+  program.command('json <app>')
+    .description('Generate deployment JSON')
+    .action(async(appName) => {
+      try {
+        const result = await generator.generateDeployJsonWithValidation(appName);
+        if (result.success) {
+          console.log(`✓ Generated deployment JSON: ${result.path}`);
+
+          if (result.validation.warnings.length > 0) {
+            console.log('\n⚠️  Warnings:');
+            result.validation.warnings.forEach(warning => console.log(`   • ${warning}`));
+          }
+        } else {
+          console.log('❌ Validation failed:');
+          result.validation.errors.forEach(error => console.log(`   • ${error}`));
+          process.exit(1);
+        }
+      } catch (error) {
+        handleCommandError(error, 'json');
+        process.exit(1);
+      }
+    });
+
+  program.command('genkey <app>')
+    .description('Generate deployment key')
+    .action(async(appName) => {
+      try {
+        const key = await keyGenerator.generateDeploymentKey(appName);
+        console.log(`\nDeployment key for ${appName}:`);
+        console.log(key);
+        console.log(`\nGenerated from: builder/${appName}/variables.yaml`);
+      } catch (error) {
+        handleCommandError(error, 'genkey');
+        process.exit(1);
+      }
+    });
+}
+
+/**
+ * Validates command arguments and provides helpful error messages
+ * @param {string} command - Command name
+ * @param {Object} options - Command options
+ * @returns {boolean} True if valid
+ */
+function validateCommand(_command, _options) {
+  // TODO: Implement command validation
+  // TODO: Add helpful error messages for common issues
+  return true;
+}
+
+/**
+ * Handles command execution errors with user-friendly messages
+ * @param {Error} error - The error that occurred
+ * @param {string} command - Command that failed
+ */
+function handleCommandError(error, command) {
+  console.error(`\n❌ Error in ${command} command:`);
+
+  // Provide specific error messages for common issues
+  if (error.message.includes('Docker')) {
+    console.error('   Docker is not running or not installed.');
+    console.error('   Please start Docker Desktop and try again.');
+  } else if (error.message.includes('port')) {
+    console.error('   Port conflict detected.');
+    console.error('   Run "aifabrix doctor" to check which ports are in use.');
+  } else if (error.message.includes('permission')) {
+    console.error('   Permission denied.');
+    console.error('   Make sure you have the necessary permissions to run Docker commands.');
+  } else if (error.message.includes('Azure CLI') || error.message.includes('az --version')) {
+    console.error('   Azure CLI is not installed.');
+    console.error('   Install from: https://docs.microsoft.com/cli/azure/install-azure-cli');
+    console.error('   Run: az login');
+  } else if (error.message.includes('authenticate') || error.message.includes('ACR')) {
+    console.error('   Azure Container Registry authentication failed.');
+    console.error('   Run: az acr login --name <registry-name>');
+    console.error('   Or login to Azure: az login');
+  } else if (error.message.includes('not found locally') || error.message.includes('not found')) {
+    console.error('   Docker image not found.');
+    console.error('   Run: aifabrix build <app> first');
+  } else if (error.message.includes('Invalid ACR URL') || error.message.includes('Expected format')) {
+    console.error('   Invalid registry URL format.');
+    console.error('   Use format: *.azurecr.io (e.g., myacr.azurecr.io)');
+  } else if (error.message.includes('Registry URL is required')) {
+    console.error('   Registry URL is required.');
+    console.error('   Provide via --registry flag or configure in variables.yaml under image.registry');
+  } else {
+    console.error(`   ${error.message}`);
+  }
+
+  console.error('\n💡 Run "aifabrix doctor" for environment diagnostics.\n');
+}
+
+module.exports = {
+  setupCommands,
+  validateCommand,
+  handleCommandError
+};