at-builder 1.2.2 → 1.2.4

package/lib/at-deploy.js

@@ -0,0 +1,318 @@
+/* eslint-disable no-undef */
+/* eslint-disable @typescript-eslint/no-require-imports */
+
+/*
+ * Adobe Target Build Deploy Script
+ * --------------------------------
+ * This script automates the deployment of build assets to an Adobe Target activity.
+ *
+ * Features:
+ * - Reads build config and allowed variations from build.config.json in the build folder.
+ * - Dynamically finds and injects built HTML assets for each experience/variation.
+ * - Updates only the allowed experiences in Adobe Target.
+ * - Provides color-coded logs and a summary of what was updated, skipped, or unchanged.
+ * - Can be run in verbose mode to show more details (use -v or --verbose).
+ *
+ * Usage:
+ *   node at-deploy.js [-v|--verbose]
+ *
+ * Environment variables required:
+ *   ACTIVITY_FOLDER_NAME, ADOBE_CLIENT_ID, ADOBE_CLIENT_SECRET
+ *   (and .env file for any secrets)
+ *
+ * Example:
+ *   ACTIVITY_FOLDER_NAME="UPSDDO-XXXX" \
+ *   ADOBE_CLIENT_ID=... ADOBE_CLIENT_SECRET=... node at-deploy.js -v
+ *
+ * Maintainers: Update build.config.json and build output structure as needed for new activities.
+ * 
+ * Author: Upendra Sengar
+ * Date: 2024-03-12
+ */
+
+/* eslint-env node */
+const path = require('path');
+
+const dotenv = require('dotenv');
+
+const PWD = process.env.executionPath || process.cwd();
+
+dotenv.config({ path: path.join(PWD, ".env"), quiet: true });
+
+const { execSync } = require('child_process');
+const axios = require('axios');
+const qs = require('querystring');
+const fs = require('fs');
+
+const { BASE_URL, IMS_TOKEN_URL, IMS_SCOPE } = require(path.join(PWD, 'adobe.config'));
+// Fallback to ANSI codes since chalk 5.x is ESM only
+const chalk = {
+    green: (s) => `\x1b[32m${s}\x1b[0m`,
+    yellow: (s) => `\x1b[33m${s}\x1b[0m`,
+    cyan: (s) => `\x1b[36m${s}\x1b[0m`,
+    red: (s) => `\x1b[31m${s}\x1b[0m`,
+    bold: (s) => `\x1b[1m${s}\x1b[0m`
+};
+
+// Validate required environment variables
+if (!process.env.ACTIVITY_FOLDER_NAME || process.env.ACTIVITY_FOLDER_NAME.trim() === '') {
+    console.error(chalk.red('❌ Error: ACTIVITY_FOLDER_NAME environment variable is required but not set.'));
+    console.error(chalk.yellow('💡 Please set ACTIVITY_FOLDER_NAME in your .env file or run "atb doctor --fix" to check your configuration.'));
+    process.exit(1);
+}
+
+// Build root directory for variations, using same approach as webpack config
+const ACTIVITIES_BASE_FOLDER = process.env.ACTIVITIES_BASE_FOLDER || 'Activities';
+const ACTIVITY_FOLDER = process.env.ACTIVITY_FOLDER_NAME.trim();
+const BUILD_ROOT = path.join(PWD, ACTIVITIES_BASE_FOLDER, ACTIVITY_FOLDER).toString();
+
+// Validate Adobe credentials
+if (!process.env.ADOBE_CLIENT_ID || process.env.ADOBE_CLIENT_ID.trim() === '') {
+    console.error(chalk.red('❌ Error: ADOBE_CLIENT_ID environment variable is required but not set.'));
+    console.error(chalk.yellow('💡 Please set your Adobe Target API credentials in your .env file.'));
+    process.exit(1);
+}
+
+if (!process.env.ADOBE_CLIENT_SECRET || process.env.ADOBE_CLIENT_SECRET.trim() === '') {
+    console.error(chalk.red('❌ Error: ADOBE_CLIENT_SECRET environment variable is required but not set.'));
+    console.error(chalk.yellow('💡 Please set your Adobe Target API credentials in your .env file.'));
+    process.exit(1);
+}
+
+console.log(chalk.cyan(`📦 Deploying activity: ${ACTIVITY_FOLDER}`));
+console.log(chalk.cyan(`📁 Activities folder: ${ACTIVITIES_BASE_FOLDER}`));
+
+// Utility: normalize experience name from folder name
+function normalizeExperienceName(folder) {
+    if (!folder) return '';
+    const name = folder.toLowerCase();
+    if (name === 'vcontrol') return 'control';
+    if (name.startsWith('variation-')) return 'variation ' + name.split('-')[1];
+    return name;
+}
+
+// Read build.config.json for activity id and allowed variations
+function readBuildJson() {
+    const buildJsonPath = path.join(BUILD_ROOT, "shared", 'build.config.json');
+    if (!fs.existsSync(buildJsonPath)) {
+        throw new Error(`build.json not found at ${buildJsonPath}`);
+    }
+    const buildJson = JSON.parse(fs.readFileSync(buildJsonPath, 'utf8'));
+    const activityId = buildJson.activityInfo?.id;
+    if (activityId === null) {
+        throw new Error('Invalid build.config.json: missing activity id');
+    }
+    console.log('buildJson.activityInfo?.variations', buildJson.activityInfo?.variations);
+    // To support older versions , keeping array checks
+    let allowedVariations = buildJson.activityInfo?.variations;
+    if (buildJson.activityInfo?.variations && Array.isArray(buildJson.activityInfo.variations)) {
+        // convert to object
+        allowedVariations = Object.fromEntries((buildJson.activityInfo?.variations || []).map(v => [v, v]));
+    }
+
+    console.log('allowedVariations', allowedVariations);
+
+    if (!activityId || !allowedVariations || Object.keys(allowedVariations).length === 0) {
+        throw new Error('Invalid build.json: missing activity id or variations');
+    }
+    const activityName = buildJson.activityInfo?.name.toLowerCase();
+    if (!activityName) {
+        throw new Error('Invalid build.config.json: missing activity name');
+    }
+    return { activityId, allowedVariations, activityName };
+}
+
+// Dynamically discover build assets for each experience/variation
+function getBuildAssets() {
+    const buildAssets = {};
+    if (!fs.existsSync(BUILD_ROOT)) {
+        console.error('Build root does not exist:', BUILD_ROOT);
+        return buildAssets;
+    }
+    const subdirs = fs.readdirSync(BUILD_ROOT, { withFileTypes: true })
+        .filter(dirent => dirent.isDirectory());
+    for (const dirent of subdirs) {
+        const subdir = dirent.name;
+        const distPath = path.join(BUILD_ROOT, subdir, 'dist', 'at-build.html');
+        if (fs.existsSync(distPath)) {
+            const expName = normalizeExperienceName(subdir);
+            buildAssets[expName] = fs.readFileSync(distPath, 'utf8');
+        }
+    }
+    return buildAssets;
+}
+
+// Fetch Adobe OAuth token using client credentials
+async function fetchAdobeToken() {
+    const data = qs.stringify({
+        grant_type: 'client_credentials',
+        client_id: process.env.ADOBE_CLIENT_ID,
+        client_secret: process.env.ADOBE_CLIENT_SECRET,
+        scope: IMS_SCOPE
+    });
+    const headers = {
+        'Content-Type': 'application/x-www-form-urlencoded'
+    };
+    try {
+        const res = await axios.post(IMS_TOKEN_URL, data, { headers });
+        return res.data.access_token;
+    } catch (err) {
+        console.error('Failed to fetch Adobe token:', err.response ? err.response.data : err.message);
+        process.exit(1);
+    }
+}
+
+// 1. Run the build (calls your build system, e.g. webpack)
+console.log('Running build...');
+execSync('npm run atb:build:prod', { stdio: 'inherit' });
+
+(async () => {
+    try {
+        // Read build config and allowed variations
+        const { activityId, allowedVariations, activityName } = readBuildJson();
+        let listOfAllowedVariations = [];
+
+        listOfAllowedVariations = Object.keys(allowedVariations).map(v => v.toLowerCase());
+
+        const allowedVariationReversedKey = Object.fromEntries(Object.entries(allowedVariations).map(([key, value]) => [value.toLowerCase(), key.toLowerCase()]));
+
+        const API_KEY = process.env.ADOBE_CLIENT_ID;
+        const token = await fetchAdobeToken();
+
+        // 2. Fetch current Adobe Target activity
+        const getActivity = async (activityId) => {
+            const res = await axios.get(`${BASE_URL}${activityId}`, {
+                headers: {
+                    'X-Api-Key': API_KEY,
+                    Accept: 'application/vnd.adobe.target.v3+json',
+                    Authorization: `Bearer ${token}`
+                }
+            });
+            return res.data;
+        };
+
+        // 3. Update activity with new build info
+        const updateActivity = async (activity, activityId) => {
+            if (activity.state === "approved") {
+                /*
+                Status Mapping Logic for UI Display:
+
+                API State     | Start At       | End At         | UI Status
+                -------------------------------------------------------------
+                Approved      | in the past     | in the future   | Live
+                Approved      | in the past     | in the past     | Ended
+                Approved      | in the future   | in the future   | Scheduled
+                Saved         | -               | -               | Inactive
+                Deactivated   | -               | -               | Archived
+                Deleted       | -               | -               | Does Not Appear in the UI
+
+                Notes:
+                - "Start At" and "End At" are datetime values used to determine temporal status.
+                - For states with "-", time values are not evaluated.
+                - Items with "Deleted" status should be filtered out entirely from the UI.
+                */
+
+                throw new Error("Live activity can't be updated");
+            }
+            // Dynamically get build assets
+            const buildAssets = getBuildAssets();
+
+            // Prepare new payload (copy structure)
+            const newPayload = {
+                name: activity.name,
+                options: activity.options,
+                locations: activity.locations,
+                experiences: activity.experiences,
+                metrics: activity.metrics,
+                analytics: activity.analytics
+            };
+
+            if (activityName !== activity.name.toLowerCase()) {
+                throw new Error('Activity name in build.config.json does not match activity name in Adobe Target');
+            }
+
+            const updatedExperiences = [];
+            const skippedExperiences = [];
+            const unchangedExperiences = [];
+            let anyChange = false;
+
+            // For each experience, update only if in allowed variations and asset exists
+            newPayload.experiences.forEach(exp => {
+                let expName = exp.name.trim().toLowerCase();
+                // Added to handle new type of build config
+                if (allowedVariationReversedKey) {
+                    expName = allowedVariationReversedKey[expName] || expName;
+                }
+
+                if (!listOfAllowedVariations.includes(expName)) {
+                    skippedExperiences.push({ name: exp.name, reason: 'Not in allowed variations in build.config.json' });
+                    return;
+                }
+
+                if (!buildAssets[expName]) {
+                    skippedExperiences.push({ name: exp.name, reason: 'No build asset found' });
+                    return;
+                }
+                let changed = false;
+                exp.optionLocations.forEach(ol => {
+                    const { optionLocalId } = ol;
+                    const option = newPayload.options.find(o => o.optionLocalId === optionLocalId);
+                    if (!option) return;
+                    option.offerTemplates.forEach(offerTemplate => {
+                        if (offerTemplate.offerTemplateId === 133) {
+                            offerTemplate.templateParameters.forEach(param => {
+                                if (param.name === 'offerContent') {
+                                    if (param.value !== buildAssets[expName]) {
+                                        param.value = buildAssets[expName];
+                                        changed = true;
+                                        anyChange = true;
+                                    }
+                                }
+                            });
+                        }
+                    });
+                });
+                if (changed) {
+                    updatedExperiences.push(exp.name);
+                } else {
+                    unchangedExperiences.push(exp.name);
+                }
+            });
+
+            // Logging summary
+            console.log(chalk.bold('--- Experience Update Summary ---'));
+            if (updatedExperiences.length > 0) {
+                console.log(chalk.green('Updated experiences:'), updatedExperiences.join(', '));
+            }
+            if (unchangedExperiences.length > 0) {
+                console.log(chalk.cyan('No changes needed for experiences:'), unchangedExperiences.join(', '));
+            }
+            if (skippedExperiences.length > 0) {
+                skippedExperiences.forEach(e => {
+                    console.log(chalk.yellow(`Skipped experience: ${e.name} (${e.reason})`));
+                });
+            }
+            if (!anyChange) {
+                console.log(chalk.cyan('No changes were made to any experience.'));
+            } else {
+                // Uncomment to actually update Adobe Target
+                await axios.put(`${BASE_URL}${activityId}`, newPayload, {
+                    headers: {
+                        'X-Api-Key': API_KEY,
+                        'Content-Type': 'application/vnd.adobe.target.v3+json',
+                        Authorization: `Bearer ${token}`
+                    }
+                });
+                console.log('New build deployed!');
+            }
+            console.log(chalk.bold('---------------------------------'));
+        };
+
+        const activity = await getActivity(activityId);
+        // console.log('Current activity:', activity);
+        await updateActivity(activity, activityId);
+    } catch (err) {
+        console.error(chalk.red('Error:'), err.response ? err.response.data : err.message);
+        process.exit(1);
+    }
+})();

package/package.json

@@ -1,18 +1,19 @@
 {
     "name": "at-builder",
-    "version": "1.2.2",
+    "version": "1.2.4",
     "main": "bin/index.js",
     "bin": {
         "atb": "bin/index.js"
     },
     "scripts": {
-        "build": "tsc -w",
-        "build-prod": "cross-env NODE_ENV=production webpack",
-        "dev": "webpack -- -w",
-        "dev-puppeteer": "webpack -- -w & npm run puppeteer",
-        "test": "echo \"Error: no test specified\" && exit 1",
-        "new-activity": "plop",
-        "puppeteer": "node puppeteer.js $b"
+        "build:atb": "tsc",
+        "build:atb:dev": "tsc -w",
+        "atb:build:prod": "cross-env NODE_ENV=production webpack",
+        "atb:build:dev": "webpack -- -w",
+        "atb:build:dev:puppeteer": "webpack -- -w & npm run puppeteer",
+        "atb:puppeteer": "node puppeteer.js $b",
+        "atb:plop:new:activity": "plop page",
+        "atb:build:deploy": "node lib/at-deploy.js"
     },
     "author": "Upendra Sengar <upendrasengar456@gmail.com>",
     "license": "MIT",
@@ -26,6 +27,7 @@
         "@babel/preset-react": "^7.18.6",
         "@types/node": "^22.13.2",
         "async": "^3.2.3",
+        "axios": "^1.12.2",
         "babel-loader": "^9.2.1",
         "babel-plugin-transform-async-to-generator": "^6.24.1",
         "build": "^0.1.4",
@@ -43,6 +45,7 @@
         "postcss-loader": "^8.1.1",
         "postcss-preset-env": "^10.1.4",
         "puppeteer": "^24.2.0",
+        "querystring": "^0.2.1",
         "readline": "^1.3.0",
         "sass": "^1.53.0",
         "sass-loader": "^16.0.4",

package/plopfile.js

@@ -1,5 +1,11 @@
-const components = require("./.plop/generators/components");
+/* eslint-disable no-undef */
+/* eslint-disable @typescript-eslint/no-require-imports */
 
+const components = require("./.plop/generators/components");
+const path = require('path');
+const dotenv = require('dotenv');
+const PWD = process.env.executionPath || process.cwd();
+dotenv.config({ path: path.join(PWD, ".env") });
 
 module.exports = function (plop) {
     plop.setGenerator('components', components );

package/src/constants/config.ts

@@ -69,6 +69,10 @@ ${formatText("COMMANDS", 'yellow', true)}
     ${formatText("build --prod", 'cyan', true)}   Build for production deployment
     ${formatText("dev", 'cyan', true)}            Start development server with file watching
     ${formatText("dev --browser", 'cyan', true)}  Start development server and open in browser
+    ${formatText("deploy", 'cyan', true)}         Deploy activity to Adobe Target
+    ${formatText("deploy --dry-run", 'cyan', true)} Deploy in dry-run mode without actual deployment
+    ${formatText("doctor", 'cyan', true)}         Diagnose and fix project configuration issues
+    ${formatText("doctor --fix", 'cyan', true)}   Automatically fix detected configuration issues
     
 ${formatText("GLOBAL OPTIONS", 'yellow', true)}
     ${formatText("-v, --verbose", 'green')}       Enable detailed logging
@@ -90,6 +94,18 @@ ${formatText("EXAMPLES", 'yellow', true)}
     
     ${formatText("# Development server with browser", 'gray')}
     ${formatText("atb dev --browser", 'white')}
+    
+    ${formatText("# Deploy to Adobe Target", 'gray')}
+    ${formatText("atb deploy", 'white')}
+    
+    ${formatText("# Deploy in dry-run mode", 'gray')}
+    ${formatText("atb deploy --dry-run", 'white')}
+    
+    ${formatText("# Check project configuration", 'gray')}
+    ${formatText("atb doctor", 'white')}
+    
+    ${formatText("# Auto-fix configuration issues", 'gray')}
+    ${formatText("atb doctor --fix", 'white')}
 
 ${formatText("WORKFLOW", 'yellow', true)}
     ${formatText("1.", 'cyan')} Run ${formatText("atb init", 'white')} to set up project configuration
@@ -97,6 +113,7 @@ ${formatText("WORKFLOW", 'yellow', true)}
     ${formatText("3.", 'cyan')} Develop variations in ${formatText("/Activities/{name}/Variation-*/", 'gray')}
     ${formatText("4.", 'cyan')} Run ${formatText("atb build", 'white')} for development testing
     ${formatText("5.", 'cyan')} Run ${formatText("atb build --prod", 'white')} for Adobe Target deployment
+    ${formatText("6.", 'cyan')} Run ${formatText("atb deploy", 'white')} to deploy to Adobe Target
 
 ${formatText("SUPPORT", 'yellow', true)}
     Repository: ${formatText("https://github.com/upesenga/at-builder", 'blue')}
@@ -114,6 +131,7 @@ export const setupEnv = async (basePath) => {
     if (!fs.existsSync(envPath)) {
         // Define the content of the .env file
         const envContent = `
+ACTIVITIES_BASE_FOLDER="Activities"
 ACTIVITY_FOLDER_NAME=""
 PUPPETEER_LANDING_PAGE=""
 TARGET_URL=""
@@ -121,6 +139,10 @@ LOGIN_URL=""
 VARIATION="Variation-1"
 NODE_ENV="development"
 VERBOSE=false
+
+# Adobe Target Deployment Configuration
+ADOBE_CLIENT_ID=""
+ADOBE_CLIENT_SECRET=""
     `;
         // Write the content to the .env file
         fs.writeFileSync(envPath, envContent.trim(), 'utf8');
@@ -129,6 +151,7 @@ VERBOSE=false
         console.log('.env file already exists!');
     }
     createWatchConfig(basePath);
+    createAdobeConfig(basePath);
 }
 
 
@@ -151,6 +174,34 @@ const createWatchConfig = (basePath) => {
     }
 }
 
+const createAdobeConfig = (basePath) => {
+    // Path to the adobe.config.js file
+    const adobeConfigPath = path.join(basePath, 'adobe.config.js');
+
+    // Default content for adobe.config.js
+    const adobeConfigContent = `/**
+ * Adobe Target API Configuration
+ * 
+ * Configuration constants for Adobe Target API integration.
+ * These values are used by the deployment script to connect to Adobe Target.
+ */
+
+module.exports = {
+    BASE_URL_NEW: 'https://mc.adobe.io/ups/target/',
+    BASE_URL: 'https://mc.adobe.io/ups/target/activities/ab/',
+    IMS_TOKEN_URL: 'https://ims-na1.adobelogin.com/ims/token/v3',
+    IMS_SCOPE: 'openid,AdobeID,target_sdk,additional_info.projectedProductContext'
+};`;
+
+    // Check if the adobe.config.js file already exists
+    if (!fs.existsSync(adobeConfigPath)) {
+        fs.writeFileSync(adobeConfigPath, adobeConfigContent, 'utf8');
+        console.log('adobe.config.js file created successfully!');
+    } else {
+        console.log('adobe.config.js file already exists!');
+    }
+}
+
 /**
  * Reads and returns environment variables from the specified .env file
  * @param {string} basePath - The base path where the .env file is located

package/src/index.ts

@@ -4,6 +4,7 @@ import path from "path";
 import fs from "fs";
 import { Command } from 'commander';
 import { getVersion, getHelpInfo, setupEnv } from "./constants/config";
+import { runDiagnostics, fixIssues } from "./services/doctor";
 import logger from "./services/logger";
 /**
  * Checks if the .env file exists at the current working directory
@@ -17,7 +18,9 @@ const checkEnvFile = () => {
         fs.accessSync(path.join(process.cwd(), ".env"), fs.constants.R_OK);
         logger.info("checkEnvFile", ".env file found");
     } catch (error) {
-        // If the file does not exist, throw an error
+        // If the file does not exist, provide helpful guidance
+        console.error('\x1b[31m%s\x1b[0m', `❌ Error: .env file not found at ${process.cwd()}`);
+        console.error('\x1b[33m%s\x1b[0m', '💡 Run "atb init" to create .env file or "atb doctor --fix" to diagnose and fix configuration issues.');
         logger.error("checkEnvFile", `Error: Couldn't find .env file at location ${process.cwd()}`);
         throw error;
     }
@@ -78,6 +81,25 @@ const setupCommander = async () => {
             await handleDev(options.browser, globalOpts.verbose);
         });
 
+    program
+        .command('deploy')
+        .description('Deploy activity to Adobe Target using at-deploy.js')
+        .option('--dry-run', 'Run deployment in dry-run mode without actual deployment')
+        .action(async (options, command) => {
+            const globalOpts = command.parent.opts();
+            checkEnvFile();
+            await handleDeploy(options.dryRun, globalOpts.verbose);
+        });
+
+    program
+        .command('doctor')
+        .description('Diagnose and fix project configuration issues')
+        .option('--fix', 'Automatically fix detected issues')
+        .action(async (options, command) => {
+            const globalOpts = command.parent.opts();
+            await handleDoctor(options.fix, globalOpts.verbose);
+        });
+
     await program.parseAsync(process.argv);
     
     logger.info("setupCommander", "Commander setup complete");
@@ -135,7 +157,7 @@ const handleInit = async (verbose: boolean): Promise<void> => {
  */
 const handleNew = async (verbose: boolean): Promise<void> => {
     if (verbose) logger.info("verbose", "Creating new activity");
-    runCommand(["run", "new-activity"], productionEnv);
+    runCommand(["run", "atb:plop:new:activity"], productionEnv);
 };
 
 /**
@@ -147,10 +169,10 @@ const handleBuild = async (prod: boolean, verbose: boolean): Promise<void> => {
     if (prod) {
         process.env['NODE_ENV'] = 'production';
         logger.info("handleBuild", "Running build with production environment");
-        runCommand(['run', 'build-prod'], productionEnv);
+        runCommand(['run', 'atb:build:prod'], productionEnv);
     } else {
         logger.info("handleBuild", "Running build with development environment");
-        runCommand(['run', 'dev'], productionEnv);
+        runCommand(['run', 'atb:build:dev'], productionEnv);
     }
 };
 
@@ -160,12 +182,67 @@ const handleBuild = async (prod: boolean, verbose: boolean): Promise<void> => {
 const handleDev = async (browser: boolean, verbose: boolean): Promise<void> => {
     if (verbose) logger.info("verbose", `Starting development server with browser=${browser}`);
     
-    const commandArr = ['run', browser ? 'dev-puppeteer' : 'dev'];
+    const commandArr = ['run', browser ? 'atb:build:dev:puppeteer' : 'atb:build:dev'];
     logger.info("handleDev", `Running command: ${commandArr.join(', ')}`);
     
     runCommand(commandArr, productionEnv);
 };
 
+/**
+ * Handles the deploy command
+ */
+const handleDeploy = async (dryRun: boolean, verbose: boolean): Promise<void> => {
+    if (verbose) logger.info("verbose", `Deploying to Adobe Target with dry-run=${dryRun}`);
+    
+    logger.info("handleDeploy", "Running Adobe Target deployment");
+    
+    runCommand(['run', 'atb:build:deploy'], productionEnv);
+};
+
+/**
+ * Handles the doctor command
+ */
+const handleDoctor = async (autoFix: boolean, verbose: boolean): Promise<void> => {
+    if (verbose) logger.info("verbose", `Running diagnostics with auto-fix=${autoFix}`);
+    
+    logger.info("handleDoctor", "Diagnosing project configuration");
+    
+    try {
+        // Run diagnostics
+        const issues = await runDiagnostics(process.cwd(), verbose);
+        
+        if (issues.length === 0) {
+            console.log("✅ No issues found. Your project configuration is healthy!");
+            return;
+        }
+        
+        // Display issues
+        console.log(`\n🔍 Found ${issues.length} issue(s):\n`);
+        issues.forEach((issue, index) => {
+            console.log(`${index + 1}. ${issue.severity === 'error' ? '❌' : '⚠️'} ${issue.message}`);
+            if (issue.suggestion) {
+                console.log(`   💡 ${issue.suggestion}`);
+            }
+        });
+        
+        if (autoFix) {
+            console.log('\n🔧 Attempting to fix issues...\n');
+            const fixed = await fixIssues(issues, process.cwd(), verbose);
+            console.log(`\n✅ Fixed ${fixed} issue(s).`);
+            
+            if (fixed < issues.length) {
+                console.log(`⚠️ ${issues.length - fixed} issue(s) require manual attention.`);
+            }
+        } else {
+            console.log('\n💡 Run `atb doctor --fix` to automatically fix resolvable issues.');
+        }
+        
+    } catch (error) {
+        logger.error("handleDoctor", `Doctor command failed: ${error.message}`);
+        process.exit(1);
+    }
+};
+
 // Command execution logic
 /**
  * Main command execution entry point