@aifabrix/builder 2.0.0 → 2.0.2

package/lib/build.js

@@ -13,13 +13,15 @@
 const fs = require('fs').promises;
 const fsSync = require('fs');
 const path = require('path');
+const os = require('os');
 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 logger = require('./utils/logger');
+const validator = require('./validator');
+const dockerfileUtils = require('./utils/dockerfile-utils');
 
 const execAsync = promisify(exec);
 
@@ -69,6 +71,34 @@ function resolveContextPath(builderPath, contextPath) {
   return resolvedPath;
 }
 
+/**
+ * Checks if error indicates Docker is not running or not installed
+ * @param {string} errorMessage - Error message to check
+ * @returns {boolean} True if Docker is not available
+ */
+function isDockerNotAvailableError(errorMessage) {
+  return errorMessage.includes('docker: command not found') ||
+         errorMessage.includes('Cannot connect to the Docker daemon') ||
+         errorMessage.includes('Is the docker daemon running') ||
+         errorMessage.includes('Cannot connect to Docker');
+}
+
+/**
+ * Handles Docker build errors and provides user-friendly messages
+ * @param {Error} error - Build error
+ * @throws {Error} Formatted error message
+ */
+function handleBuildError(error) {
+  const errorMessage = error.message || error.stderr || String(error);
+
+  if (isDockerNotAvailableError(errorMessage)) {
+    throw new Error('Docker is not running or not installed. Please start Docker Desktop and try again.');
+  }
+
+  const detailedError = error.stderr || error.stdout || errorMessage;
+  throw new Error(`Docker build failed: ${detailedError}`);
+}
+
 /**
  * Executes Docker build command with proper error handling
  * @param {string} imageName - Image name to build
@@ -82,26 +112,22 @@ 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}`));
+    logger.log(chalk.blue('Building image...'));
+    logger.log(chalk.gray(`Command: ${dockerCommand}`));
 
     const { stdout, stderr } = await execAsync(dockerCommand);
 
     if (stderr && !stderr.includes('warning')) {
-      console.log(chalk.yellow(stderr));
+      logger.log(chalk.yellow(stderr));
     }
 
     if (stdout) {
-      console.log(stdout);
+      logger.log(stdout);
     }
 
-    console.log(chalk.green(`✓ Image built: ${imageName}:${tag}`));
+    logger.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}`);
+    handleBuildError(error);
   }
 }
 
@@ -146,53 +172,179 @@ function detectLanguage(appPath) {
 /**
  * Generates a Dockerfile from template based on detected language
  * Uses Handlebars templates to create optimized Dockerfiles
+ * Dockerfiles are stored in ~/.aifabrix/{appName}/ directory
  *
  * @async
  * @function generateDockerfile
- * @param {string} appPath - Path to application directory
+ * @param {string} appNameOrPath - Application name or path (backward compatibility)
  * @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'
+ * const dockerfilePath = await generateDockerfile('myapp', 'typescript', config);
+ * // Returns: '~/.aifabrix/myapp/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}`);
+async function generateDockerfile(appNameOrPath, language, config, buildConfig = {}) {
+  let appName;
+  if (appNameOrPath.includes(path.sep) || appNameOrPath.includes('/') || appNameOrPath.includes('\\')) {
+    appName = path.basename(appNameOrPath);
+  } else {
+    appName = appNameOrPath;
   }
 
-  const templateContent = fsSync.readFileSync(templatePath, 'utf8');
-  const template = handlebars.compile(templateContent);
+  const template = dockerfileUtils.loadDockerfileTemplate(language);
+  const isAppFlag = buildConfig.context === '../..';
+  const appSourcePath = isAppFlag ? `apps/${appName}/` : '.';
 
-  // Prepare template variables
   const templateVars = {
     port: config.port || 3000,
     healthCheck: {
       interval: config.healthCheck?.interval || 30,
       path: config.healthCheck?.path || '/health'
     },
-    startupCommand: config.startupCommand
+    startupCommand: config.startupCommand,
+    appSourcePath: appSourcePath
   };
 
-  const dockerfileContent = template(templateVars);
+  const dockerfileContent = dockerfileUtils.renderDockerfile(template, templateVars, language, isAppFlag, appSourcePath);
 
-  // Create .aifabrix directory if it doesn't exist
-  const aifabrixDir = path.join(appPath, '.aifabrix');
+  const aifabrixDir = path.join(os.homedir(), '.aifabrix', appName);
   if (!fsSync.existsSync(aifabrixDir)) {
     await fs.mkdir(aifabrixDir, { recursive: true });
   }
 
   const dockerfilePath = path.join(aifabrixDir, `Dockerfile.${language}`);
-  await fs.writeFile(dockerfilePath, dockerfileContent);
+  await fs.writeFile(dockerfilePath, dockerfileContent, 'utf8');
+
+  return dockerfilePath;
+}
+
+/**
+ * Determines Dockerfile path, generating from template if needed
+ * @async
+ * @param {string} appName - Application name
+ * @param {Object} options - Dockerfile determination options
+ * @param {string} options.language - Application language
+ * @param {Object} options.config - Application configuration
+ * @param {Object} options.buildConfig - Build configuration
+ * @param {string} options.contextPath - Build context path (absolute)
+ * @param {boolean} options.forceTemplate - Force template flag
+ * @returns {Promise<string>} Path to Dockerfile
+ */
+async function determineDockerfile(appName, options) {
+  const builderPath = path.join(process.cwd(), 'builder', appName);
+
+  const templateDockerfile = dockerfileUtils.checkTemplateDockerfile(builderPath, appName, options.forceTemplate);
+  if (templateDockerfile) {
+    logger.log(chalk.green(`✓ Using existing Dockerfile: builder/${appName}/Dockerfile`));
+    return templateDockerfile;
+  }
 
+  const customDockerfile = dockerfileUtils.checkProjectDockerfile(builderPath, appName, options.buildConfig, options.contextPath, options.forceTemplate);
+  if (customDockerfile) {
+    logger.log(chalk.green(`✓ Using custom Dockerfile: ${options.buildConfig.dockerfile}`));
+    return customDockerfile;
+  }
+
+  const dockerfilePath = await generateDockerfile(appName, options.language, options.config, options.buildConfig);
+  const relativePath = path.relative(process.cwd(), dockerfilePath);
+  logger.log(chalk.green(`✓ Generated Dockerfile from template: ${relativePath}`));
   return dockerfilePath;
 }
 
+/**
+ * Prepares build context path
+ * @param {string} appName - Application name
+ * @param {string} contextPath - Relative context path
+ * @returns {string} Absolute context path
+ */
+function prepareBuildContext(appName, contextPath) {
+  // Ensure contextPath is a string
+  const context = typeof contextPath === 'string' ? contextPath : (contextPath || '');
+  return resolveContextPath(
+    path.join(process.cwd(), 'builder', appName),
+    context
+  );
+}
+
+/**
+ * Loads and validates configuration for build
+ * @async
+ * @param {string} appName - Application name
+ * @returns {Promise<Object>} Configuration object with config, imageName, and buildConfig
+ * @throws {Error} If configuration cannot be loaded or validated
+ */
+async function loadAndValidateConfig(appName) {
+  const variables = await loadVariablesYaml(appName);
+
+  // Validate configuration
+  const validation = await validator.validateVariables(appName);
+  if (!validation.valid) {
+    throw new Error(`Configuration validation failed:\n${validation.errors.join('\n')}`);
+  }
+
+  // Extract image name
+  let imageName;
+  if (typeof variables.image === 'string') {
+    imageName = variables.image.split(':')[0];
+  } else if (variables.image?.name) {
+    imageName = variables.image.name;
+  } else if (variables.app?.key) {
+    imageName = variables.app.key;
+  } else {
+    imageName = appName;
+  }
+
+  // Extract build config
+  const buildConfig = variables.build || {};
+
+  return {
+    config: variables,
+    imageName,
+    buildConfig
+  };
+}
+
+/**
+ * Executes Docker build and handles tagging
+ * @async
+ * @param {string} imageName - Image name
+ * @param {string} dockerfilePath - Path to Dockerfile
+ * @param {string} contextPath - Build context path
+ * @param {string} tag - Image tag
+ * @param {Object} options - Build options
+ */
+async function executeBuild(imageName, dockerfilePath, contextPath, tag, options) {
+  await executeDockerBuild(imageName, dockerfilePath, contextPath, tag);
+
+  // Tag image if additional tag provided
+  if (options.tag && options.tag !== 'latest') {
+    await execAsync(`docker tag ${imageName}:${tag} ${imageName}:latest`);
+    logger.log(chalk.green(`✓ Tagged image: ${imageName}:latest`));
+  }
+}
+
+async function postBuildTasks(appName, buildConfig) {
+  try {
+    const envPath = await secrets.generateEnvFile(appName, buildConfig.secrets);
+    logger.log(chalk.green(`✓ Generated .env file: ${envPath}`));
+    if (buildConfig.envOutputPath) {
+      const builderPath = path.join(process.cwd(), 'builder', appName);
+      const outputPath = path.resolve(builderPath, buildConfig.envOutputPath);
+      const outputDir = path.dirname(outputPath);
+      if (!fsSync.existsSync(outputDir)) {
+        await fs.mkdir(outputDir, { recursive: true });
+      }
+      await fs.copyFile(envPath, outputPath);
+      logger.log(chalk.green(`✓ Copied .env to: ${buildConfig.envOutputPath}`));
+    }
+  } catch (error) {
+    logger.log(chalk.yellow(`⚠️  Warning: Could not generate .env file: ${error.message}`));
+  }
+}
+
 /**
  * Builds a container image for the specified application
  * Auto-detects runtime and generates Dockerfile if needed
@@ -213,89 +365,48 @@ async function generateDockerfile(appPath, language, config) {
  */
 async function buildApp(appName, options = {}) {
   try {
-    console.log(chalk.blue(`\n🔨 Building application: ${appName}`));
+    logger.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');
-    }
+    const { config, imageName, buildConfig } = await loadAndValidateConfig(appName);
 
-    // Extract configuration values
-    const imageName = config.image?.split(':')[0] || appName;
-    const buildConfig = config.build || {};
+    // 2. Prepare build context
+    const contextPath = prepareBuildContext(appName, buildConfig.context);
 
-    // 2. Determine language
+    // 3. Check if Dockerfile exists in builder/{appName}/ directory
+    const builderPath = path.join(process.cwd(), 'builder', appName);
+    const appDockerfilePath = path.join(builderPath, 'Dockerfile');
+    const hasExistingDockerfile = fsSync.existsSync(appDockerfilePath) && !options.forceTemplate;
+
+    // 4. Determine language (skip if existing Dockerfile found)
     let language = options.language || buildConfig.language;
-    if (!language) {
-      const builderPath = path.join(process.cwd(), 'builder', appName);
+    if (!language && !hasExistingDockerfile) {
       language = detectLanguage(builderPath);
+    } else if (!language) {
+      // Default language if existing Dockerfile is found (won't be used, but needed for API)
+      language = 'typescript';
     }
-    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 (!hasExistingDockerfile) {
+      logger.log(chalk.green(`✓ Detected language: ${language}`));
     }
 
-    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. Determine Dockerfile (needs context path to generate in correct location)
+    const dockerfilePath = await determineDockerfile(appName, {
+      language,
+      config,
+      buildConfig,
+      contextPath,
+      forceTemplate: options.forceTemplate
+    });
 
-    // 5. Build Docker image
+    // 6. 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`));
-    }
+    await executeBuild(imageName, dockerfilePath, contextPath, tag, options);
 
-    // 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}`));
-    }
+    // 7. Post-build tasks
+    await postBuildTasks(appName, buildConfig);
 
-    console.log(chalk.green('\n✅ Build completed successfully!'));
+    logger.log(chalk.green('\n✅ Build completed successfully!'));
     return `${imageName}:${tag}`;
 
   } catch (error) {

package/lib/cli.js

@@ -15,12 +15,33 @@ const secrets = require('./secrets');
 const generator = require('./generator');
 const validator = require('./validator');
 const keyGenerator = require('./key-generator');
+const chalk = require('chalk');
+const logger = require('./utils/logger');
+const { validateCommand, handleCommandError } = require('./utils/cli-utils');
+const { handleLogin } = require('./commands/login');
 
 /**
  * Sets up all CLI commands on the Commander program instance
  * @param {Command} program - Commander program instance
  */
 function setupCommands(program) {
+  // Authentication command
+  program.command('login')
+    .description('Authenticate with Miso Controller')
+    .option('-u, --url <url>', 'Controller URL', 'http://localhost:3000')
+    .option('-m, --method <method>', 'Authentication method (device|credentials)')
+    .option('--client-id <id>', 'Client ID (for credentials method)')
+    .option('--client-secret <secret>', 'Client Secret (for credentials method)')
+    .option('-e, --environment <env>', 'Environment key (for device method, e.g., dev, tst, pro)')
+    .action(async(options) => {
+      try {
+        await handleLogin(options);
+      } catch (error) {
+        logger.error(chalk.red('\n❌ Login failed:'), error.message);
+        process.exit(1);
+      }
+    });
+
   // Infrastructure commands
   program.command('up')
     .description('Start local infrastructure services (Postgres, Redis, pgAdmin, Redis Commander)')
@@ -58,8 +79,10 @@ function setupCommands(program) {
     .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('-t, --template <name>', 'Template to use (e.g., miso-controller, keycloak)')
+    .option('--app', 'Generate minimal application files (package.json, index.ts or requirements.txt, main.py)')
     .option('-g, --github', 'Generate GitHub Actions workflows')
+    .option('--github-steps <steps>', 'Extra GitHub workflow steps (comma-separated, e.g., npm,test)')
     .option('--main-branch <branch>', 'Main branch name for workflows', 'main')
     .action(async(appName, options) => {
       try {
@@ -78,7 +101,7 @@ function setupCommands(program) {
     .action(async(appName, options) => {
       try {
         const imageTag = await app.buildApp(appName, options);
-        console.log(`✅ Built image: ${imageTag}`);
+        logger.log(`✅ Built image: ${imageTag}`);
       } catch (error) {
         handleCommandError(error, 'build');
         process.exit(1);
@@ -113,8 +136,12 @@ function setupCommands(program) {
 
   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)')
+    .option('-c, --controller <url>', 'Controller URL')
+    .option('-e, --environment <env>', 'Environment (dev, tst, pro)', 'dev')
+    .option('--client-id <id>', 'Client ID (overrides config)')
+    .option('--client-secret <secret>', 'Client Secret (overrides config)')
+    .option('--poll', 'Poll for deployment status', true)
+    .option('--no-poll', 'Do not poll for status')
     .action(async(appName, options) => {
       try {
         await app.deployApp(appName, options);
@@ -130,32 +157,32 @@ function setupCommands(program) {
     .action(async() => {
       try {
         const result = await validator.checkEnvironment();
-        console.log('\n🔍 AI Fabrix Environment Check\n');
+        logger.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'}`);
+        logger.log(`Docker: ${result.docker === 'ok' ? '✅ Running' : '❌ Not available'}`);
+        logger.log(`Ports: ${result.ports === 'ok' ? '✅ Available' : '⚠️  Some ports in use'}`);
+        logger.log(`Secrets: ${result.secrets === 'ok' ? '✅ Configured' : '❌ Missing'}`);
 
         if (result.recommendations.length > 0) {
-          console.log('\n📋 Recommendations:');
-          result.recommendations.forEach(rec => console.log(`  • ${rec}`));
+          logger.log('\n📋 Recommendations:');
+          result.recommendations.forEach(rec => logger.log(`  • ${rec}`));
         }
 
         // Check infrastructure health if Docker is available
         if (result.docker === 'ok') {
           try {
             const health = await infra.checkInfraHealth();
-            console.log('\n🏥 Infrastructure Health:');
+            logger.log('\n🏥 Infrastructure Health:');
             Object.entries(health).forEach(([service, status]) => {
               const icon = status === 'healthy' ? '✅' : status === 'unknown' ? '❓' : '❌';
-              console.log(`  ${icon} ${service}: ${status}`);
+              logger.log(`  ${icon} ${service}: ${status}`);
             });
           } catch (error) {
-            console.log('\n🏥 Infrastructure: Not running');
+            logger.log('\n🏥 Infrastructure: Not running');
           }
         }
 
-        console.log('');
+        logger.log('');
       } catch (error) {
         handleCommandError(error, 'doctor');
         process.exit(1);
@@ -167,15 +194,15 @@ function setupCommands(program) {
     .action(async() => {
       try {
         const status = await infra.getInfraStatus();
-        console.log('\n📊 Infrastructure Status\n');
+        logger.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('');
+          logger.log(`${icon} ${service}:`);
+          logger.log(`   Status: ${info.status}`);
+          logger.log(`   Port: ${info.port}`);
+          logger.log(`   URL: ${info.url}`);
+          logger.log('');
         });
       } catch (error) {
         handleCommandError(error, 'status');
@@ -188,7 +215,7 @@ function setupCommands(program) {
     .action(async(service) => {
       try {
         await infra.restartService(service);
-        console.log(`✅ ${service} service restarted successfully`);
+        logger.log(`✅ ${service} service restarted successfully`);
       } catch (error) {
         handleCommandError(error, 'restart');
         process.exit(1);
@@ -198,10 +225,11 @@ function setupCommands(program) {
   // Utility commands
   program.command('resolve <app>')
     .description('Generate .env file from template')
-    .action(async(appName) => {
+    .option('-f, --force', 'Generate missing secret keys in secrets file')
+    .action(async(appName, options) => {
       try {
-        const envPath = await secrets.generateEnvFile(appName);
-        console.log(`✓ Generated .env file: ${envPath}`);
+        const envPath = await secrets.generateEnvFile(appName, undefined, 'local', options.force);
+        logger.log(`✓ Generated .env file: ${envPath}`);
       } catch (error) {
         handleCommandError(error, 'resolve');
         process.exit(1);
@@ -214,15 +242,17 @@ function setupCommands(program) {
       try {
         const result = await generator.generateDeployJsonWithValidation(appName);
         if (result.success) {
-          console.log(`✓ Generated deployment JSON: ${result.path}`);
+          logger.log(`✓ Generated deployment JSON: ${result.path}`);
 
-          if (result.validation.warnings.length > 0) {
-            console.log('\n⚠️  Warnings:');
-            result.validation.warnings.forEach(warning => console.log(`   • ${warning}`));
+          if (result.validation.warnings && result.validation.warnings.length > 0) {
+            logger.log('\n⚠️  Warnings:');
+            result.validation.warnings.forEach(warning => logger.log(`   • ${warning}`));
           }
         } else {
-          console.log('❌ Validation failed:');
-          result.validation.errors.forEach(error => console.log(`   • ${error}`));
+          logger.log('❌ Validation failed:');
+          if (result.validation.errors && result.validation.errors.length > 0) {
+            result.validation.errors.forEach(error => logger.log(`   • ${error}`));
+          }
           process.exit(1);
         }
       } catch (error) {
@@ -236,68 +266,28 @@ function setupCommands(program) {
     .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`);
+        logger.log(`\nDeployment key for ${appName}:`);
+        logger.log(key);
       } 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');
+  program.command('dockerfile <app>')
+    .description('Generate Dockerfile for an application')
+    .option('-l, --language <lang>', 'Override language detection')
+    .option('-f, --force', 'Overwrite existing Dockerfile')
+    .action(async(appName, options) => {
+      try {
+        const dockerfilePath = await app.generateDockerfileForApp(appName, options);
+        logger.log(chalk.green('\n✅ Dockerfile generated successfully!'));
+        logger.log(chalk.gray(`Location: ${dockerfilePath}`));
+      } catch (error) {
+        handleCommandError(error, 'dockerfile');
+        process.exit(1);
+      }
+    });
 }
 
 module.exports = {