@aws/lsp-codewhisperer 0.0.96 → 0.0.97

package/out/language-server/netTransform/atxTransformHandler.js

@@ -1,18 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ATXTransformHandler = exports.ArtifactWorkspaceName = void 0;
-const fs = require("fs");
-const archiver = require("archiver");
-const got_1 = require("got");
+exports.ATXTransformHandler = void 0;
 const path = require("path");
-const crypto = require("crypto");
-const AdmZip = require("adm-zip");
 const artifactManager_1 = require("./artifactManager");
 const elastic_gumby_frontend_client_1 = require("@amazon/elastic-gumby-frontend-client");
 const AtxTokenServiceManager_1 = require("../../shared/amazonQServiceManager/AtxTokenServiceManager");
 const constants_1 = require("../../shared/constants");
 const uuid_1 = require("uuid");
-exports.ArtifactWorkspaceName = 'artifactWorkspace';
+const utils_1 = require("./utils");
 /**
  * ATX Transform Handler - Business logic for ATX FES Transform operations
  * Parallel to RTS TransformHandler but uses AtxTokenServiceManager and ATX FES APIs
@@ -23,80 +18,62 @@ class ATXTransformHandler {
     logging;
     runtime;
     atxClient = null;
-    cachedApplicationUrl = null;
     cachedHitl = null;
     constructor(serviceManager, workspace, logging, runtime) {
         this.serviceManager = serviceManager;
         this.workspace = workspace;
         this.logging = logging;
         this.runtime = runtime;
-        this.serviceManager.registerCacheCallback(() => this.clearApplicationUrlCache());
+        this.serviceManager.registerCacheCallback(() => this.onProfileUpdate());
     }
     /**
      * Initialize ATX FES client
      */
     async initializeAtxClient() {
         try {
-            this.logging.log('DEBUG-ATX-INIT: Starting ATX client initialization');
+            this.logging.log('ATX: Starting client initialization');
             let region = process.env[constants_1.ATX_FES_REGION_ENV_VAR];
-            this.logging.log(`DEBUG-ATX-INIT: Environment region: ${region || 'not set'}`);
             if (!region) {
                 // Try to get region from active profile
                 region = await this.getRegionFromProfile();
-                if (region) {
-                    this.logging.log(`DEBUG-ATX-INIT: Using region from active profile: ${region}`);
-                }
-                else {
-                    this.logging.log('DEBUG-ATX-INIT: No region available - cannot initialize client without region');
-                    this.logging.log('DEBUG-ATX-INIT: Profile selection or multi-region discovery needed first');
+                if (!region) {
+                    this.logging.error('ATX: No region available - cannot initialize client');
                     return false;
                 }
             }
             const endpoint = process.env.TCP_ENDPOINT || (0, constants_1.getAtxEndPointByRegion)(region);
-            this.logging.log(`DEBUG-ATX-INIT: Using region-specific endpoint for ${region}: ${endpoint}`);
-            this.clearApplicationUrlCache();
-            this.logging.log('DEBUG-ATX-INIT: Cleared application URL cache');
-            this.logging.log('DEBUG-ATX-INIT: About to create ElasticGumbyFrontendClient');
+            this.logging.log(`ATX: Using region ${region} with endpoint ${endpoint}`);
             this.atxClient = new elastic_gumby_frontend_client_1.ElasticGumbyFrontendClient({
                 region: region,
                 endpoint: endpoint,
             });
-            this.logging.log('DEBUG-ATX-INIT: ElasticGumbyFrontendClient created successfully');
+            this.logging.log('ATX: Client initialization completed');
             return true;
         }
         catch (error) {
-            const region = process.env[constants_1.ATX_FES_REGION_ENV_VAR] || constants_1.DEFAULT_ATX_FES_REGION;
-            const endpoint = process.env.TCP_ENDPOINT || constants_1.DEFAULT_ATX_FES_ENDPOINT_URL;
-            this.logging.log(`DEBUG-ATX-INIT: Failed to initialize with region: ${region}, endpoint: ${endpoint}. Error: ${error}`);
+            this.logging.error(`ATX: Failed to initialize client: ${String(error)}`);
             return false;
         }
     }
     async getRegionFromProfile() {
         try {
-            this.logging.log('DEBUG-ATX-REGION: Starting getRegionFromProfile()');
             if (!this.serviceManager.hasValidCredentials()) {
-                this.logging.log('DEBUG-ATX-REGION: No valid credentials, returning undefined');
                 return undefined;
             }
-            this.logging.log('DEBUG-ATX-REGION: Valid credentials found');
             // Get active profile applicationURL and extract region from it
             const atxServiceManager = AtxTokenServiceManager_1.AtxTokenServiceManager.getInstance();
             const applicationUrl = atxServiceManager.getActiveApplicationUrl();
             if (applicationUrl) {
-                this.logging.log(`DEBUG-ATX-REGION: Found applicationURL: ${applicationUrl}`);
                 // Extract region from applicationURL: https://xxx.transform.REGION.on.aws
                 const urlMatch = applicationUrl.match(/\.transform(?:-gamma)?\.([^.]+)\.on\.aws/);
                 if (urlMatch && urlMatch[1]) {
-                    const region = urlMatch[1];
-                    this.logging.log(`DEBUG-ATX-REGION: Extracted region from applicationURL: ${region}`);
-                    return region;
+                    return urlMatch[1];
                 }
             }
-            this.logging.log('DEBUG-ATX-REGION: No active applicationURL, using default region');
             return constants_1.DEFAULT_ATX_FES_REGION;
         }
         catch (error) {
-            this.logging.log(`DEBUG-ATX-REGION: Error in getRegionFromProfile: ${String(error)}`);
+            this.logging.error(`ATX: Error getting region from profile: ${String(error)}`);
             return undefined;
         }
     }
@@ -132,61 +109,41 @@ class ATXTransformHandler {
      */
     async getActiveTransformProfileApplicationUrl() {
         try {
-            // Return cached URL if available (avoids expensive profile discovery)
-            if (this.cachedApplicationUrl) {
-                this.logging.log(`DEBUG-ATX-URL: Using cached applicationUrl: ${this.cachedApplicationUrl}`);
-                return this.cachedApplicationUrl;
-            }
             // Get applicationUrl from service manager (cached from configuration)
             const applicationUrl = this.serviceManager.getActiveApplicationUrl();
             if (!applicationUrl) {
-                this.logging.error('DEBUG-ATX-URL: No applicationUrl found in service manager cache');
-                this.logging.error('DEBUG-ATX-URL: Profile not selected or not cached yet');
+                this.logging.error('ATX: No applicationUrl found - profile not selected');
                 return null;
             }
-            this.logging.log(`DEBUG-ATX-URL: Using service manager applicationUrl: ${applicationUrl}`);
-            // Cache the applicationUrl for future use
-            this.cachedApplicationUrl = applicationUrl;
             return applicationUrl;
         }
         catch (error) {
-            this.logging.error(`DEBUG-ATX-URL: Error getting applicationUrl: ${String(error)}`);
+            this.logging.error(`ATX: Error getting applicationUrl: ${String(error)}`);
             return null;
         }
     }
     /**
-     * Clear cached applicationUrl (for token refresh scenarios)
+     * Reset atx client (for profile update scenarios)
      */
-    clearApplicationUrlCache() {
-        this.cachedApplicationUrl = null;
+    onProfileUpdate() {
+        this.atxClient = null;
     }
     /**
      * Verify session (internal LSP method called before each ATX API)
      */
     async verifySession() {
         try {
-            this.logging.log('DEBUG-ATX: VerifySession operation started');
-            this.logging.log('DEBUG-ATX: About to call initializeAtxClient()');
             if (!(await this.initializeAtxClient())) {
-                this.logging.error('DEBUG-ATX: Failed to initialize client for verifySession');
+                this.logging.error('ATX: Failed to initialize client for session verification');
                 return false;
             }
-            this.logging.log('DEBUG-ATX: initializeAtxClient() completed successfully');
-            // Log authentication details for debugging
-            this.logging.log('DEBUG-ATX: About to call getBearerToken()');
-            const bearerToken = await this.serviceManager.getBearerToken();
-            this.logging.log('DEBUG-ATX: getBearerToken() completed');
-            this.logging.log('DEBUG-ATX: About to call getActiveTransformProfileApplicationUrl()');
-            const applicationUrl = await this.getActiveTransformProfileApplicationUrl();
-            this.logging.log('DEBUG-ATX: getActiveTransformProfileApplicationUrl() completed');
-            this.logging.log(`DEBUG-ATX: VerifySession - applicationUrl: ${applicationUrl || 'null'}`);
-            this.logging.log(`DEBUG-ATX: VerifySession - bearer token length: ${bearerToken ? bearerToken.length : 0} characters`);
-            // Always return true like reference repo
-            this.logging.log(`DEBUG-ATX: VerifySession successful`);
+            // Verify authentication details
+            await this.serviceManager.getBearerToken();
+            await this.getActiveTransformProfileApplicationUrl();
             return true;
         }
         catch (error) {
-            this.logging.error(`DEBUG-ATX: VerifySession error: ${String(error)}`);
+            this.logging.error(`ATX: Session verification error: ${String(error)}`);
             return false;
         }
     }
@@ -195,16 +152,15 @@ class ATXTransformHandler {
      */
     async listWorkspaces() {
         try {
-            this.logging.log('DEBUG-ATX: ListWorkspaces operation started');
+            this.logging.log('ATX: Starting ListWorkspaces operation');
             if (!this.atxClient && !(await this.initializeAtxClient())) {
                 throw new Error('ATX FES client not initialized');
             }
             const { ListWorkspacesCommand } = await Promise.resolve().then(() => require('@amazon/elastic-gumby-frontend-client'));
             const command = new ListWorkspacesCommand({});
             await this.addAuthToCommand(command);
-            this.logging.log('DEBUG-ATX: Sending ListWorkspaces command to ATX FES');
             const response = await this.atxClient.send(command);
-            this.logging.log(`DEBUG-ATX: ListWorkspaces API returned ${response.items?.length || 0} workspaces`);
+            this.logging.log(`ATX: ListWorkspaces completed - found ${response.items?.length || 0} workspaces`);
             this.logging.log(`ATX: ListWorkspaces RequestId: ${response.$metadata?.requestId}`);
             // Convert ATX API format to IDE expected format
             const workspaces = (response.items || []).map(workspace => ({
@@ -212,11 +168,10 @@ class ATXTransformHandler {
                 Name: workspace.name,
                 CreatedDate: new Date().toISOString(), // Use current date since createdDate not available
             }));
-            this.logging.log(`DEBUG-ATX: Converted workspaces: ${JSON.stringify(workspaces, null, 2)}`);
             return workspaces;
         }
         catch (error) {
-            this.logging.error(`DEBUG-ATX: ListWorkspaces error: ${String(error)}`);
+            this.logging.error(`ATX: ListWorkspaces error: ${String(error)}`);
             return [];
         }
     }
@@ -225,7 +180,7 @@ class ATXTransformHandler {
      */
     async createWorkspace(workspaceName) {
         try {
-            this.logging.log(`DEBUG-ATX: CreateWorkspace operation started with name: ${workspaceName || 'auto-generated'}`);
+            this.logging.log(`ATX: Starting CreateWorkspace with name: ${workspaceName || 'auto-generated'}`);
             if (!this.atxClient && !(await this.initializeAtxClient())) {
                 throw new Error('ATX FES client not initialized');
             }
@@ -235,23 +190,21 @@ class ATXTransformHandler {
                 description: workspaceName ? `Workspace: ${workspaceName}` : 'Auto-generated workspace',
             });
             await this.addAuthToCommand(command);
-            this.logging.log('DEBUG-ATX: Sending CreateWorkspace command to ATX FES');
             const response = await this.atxClient.send(command);
-            this.logging.log(`DEBUG-ATX: CreateWorkspace API returned workspaceId: ${response.workspace?.id}`);
             this.logging.log(`ATX: CreateWorkspace RequestId: ${response.$metadata?.requestId}`);
             if (response.workspace?.id && response.workspace?.name) {
                 const result = {
                     workspaceId: response.workspace.id,
                     workspaceName: response.workspace.name,
                 };
-                this.logging.log(`DEBUG-ATX: CreateWorkspace success: ${JSON.stringify(result)}`);
+                this.logging.log(`ATX: CreateWorkspace completed successfully: ${response.workspace.id}`);
                 return result;
             }
-            this.logging.log('DEBUG-ATX: CreateWorkspace failed - no workspace in response');
+            this.logging.error('ATX: CreateWorkspace failed - no workspace in response');
             return null;
         }
         catch (error) {
-            this.logging.error(`DEBUG-ATX: CreateWorkspace error: ${String(error)}`);
+            this.logging.error(`ATX: CreateWorkspace error: ${String(error)}`);
             return null;
         }
     }
@@ -260,15 +213,13 @@ class ATXTransformHandler {
      */
     async listOrCreateWorkspace(request) {
         try {
-            this.logging.log('DEBUG-ATX: ListOrCreateWorkspace consolidated operation started');
-            this.logging.log(`DEBUG-ATX: Request: ${JSON.stringify(request, null, 2)}`);
+            this.logging.log('ATX: Starting ListOrCreateWorkspace operation');
             // Call verifySession ONCE at the beginning
             if (!(await this.verifySession())) {
-                this.logging.error('DEBUG-ATX: VerifySession failed for listOrCreateWorkspace');
+                this.logging.error('ATX: Session verification failed for listOrCreateWorkspace');
                 return null;
             }
             // Always get list of existing workspaces
-            this.logging.log('DEBUG-ATX: Getting list of existing workspaces');
             const workspaces = await this.listWorkspaces();
             const response = {
                 AvailableWorkspaces: workspaces,
@@ -276,7 +227,6 @@ class ATXTransformHandler {
             };
             // Optionally create new workspace
             if (request.CreateWorkspaceName !== undefined) {
-                this.logging.log(`DEBUG-ATX: Creating new workspace: ${request.CreateWorkspaceName || 'auto-generated'}`);
                 const newWorkspace = await this.createWorkspace(request.CreateWorkspaceName);
                 if (newWorkspace) {
                     response.CreatedWorkspace = {
@@ -289,15 +239,13 @@ class ATXTransformHandler {
                         Name: newWorkspace.workspaceName,
                         CreatedDate: new Date().toISOString(),
                     });
-                    this.logging.log(`DEBUG-ATX: Added new workspace to available list`);
                 }
             }
-            this.logging.log(`DEBUG-ATX: ListOrCreateWorkspace completed - ${response.AvailableWorkspaces.length} workspaces available`);
-            this.logging.log(`DEBUG-ATX: Final response: ${JSON.stringify(response, null, 2)}`);
+            this.logging.log(`ATX: ListOrCreateWorkspace completed - ${response.AvailableWorkspaces.length} workspaces available`);
             return response;
         }
         catch (error) {
-            this.logging.error(`DEBUG-ATX: ListOrCreateWorkspace error: ${String(error)}`);
+            this.logging.error(`ATX: ListOrCreateWorkspace error: ${String(error)}`);
             return null;
         }
     }
@@ -306,16 +254,11 @@ class ATXTransformHandler {
      */
     async createJob(request) {
         try {
-            this.logging.log(`DEBUG-ATX-CREATE-JOB: CreateJob operation started for workspace: ${request.workspaceId}`);
-            this.logging.log(`DEBUG-ATX-CREATE-JOB: jobName: ${request.jobName || 'auto-generated'}`);
+            this.logging.log(`ATX: Starting CreateJob for workspace: ${request.workspaceId}`);
             // Call ATX FES createJob API
-            this.logging.log('DEBUG-ATX-CREATE-JOB: initializing ATX client...');
-            await this.initializeAtxClient();
-            if (!this.atxClient) {
-                throw new Error('ATX client not initialized');
+            if (!this.atxClient && !(await this.initializeAtxClient())) {
+                throw new Error('ATX FES client not initialized');
             }
-            this.logging.log('DEBUG-ATX-CREATE-JOB: ATX client initialized successfully');
-            this.logging.log(`DEBUG-ATX-CREATE-JOB: creating CreateJobCommand with targetFramework ${request.targetFramework}`);
             const command = new elastic_gumby_frontend_client_1.CreateJobCommand({
                 workspaceId: request.workspaceId,
                 objective: JSON.stringify({ target_framework: request.targetFramework || 'net10.0' }),
@@ -324,47 +267,33 @@ class ATXTransformHandler {
                 intent: 'LANGUAGE_UPGRADE',
                 idempotencyToken: (0, uuid_1.v4)(),
             });
-            this.logging.log('DEBUG-ATX-CREATE-JOB: command created, adding auth...');
             await this.addAuthToCommand(command);
-            this.logging.log('DEBUG-ATX-CREATE-JOB: auth added, sending command...');
             const response = (await this.atxClient.send(command));
-            this.logging.log(`DEBUG-ATX-CREATE-JOB: API returned jobId: ${response.jobId}, status: ${response.status}`);
+            this.logging.log(`ATX: CreateJob completed - jobId: ${response.jobId}, status: ${response.status}`);
             this.logging.log(`ATX: CreateJob RequestId: ${response.$metadata?.requestId}`);
             if (response.jobId && response.status) {
                 return { jobId: response.jobId, status: response.status };
             }
-            this.logging.error('DEBUG-ATX-CREATE-JOB: API returned null jobId or status');
+            this.logging.error('ATX: CreateJob failed - no jobId or status in response');
             return null;
         }
         catch (error) {
-            this.logging.error(`DEBUG-ATX-CREATE-JOB: Error: ${String(error)}`);
+            this.logging.error(`ATX: CreateJob error: ${String(error)}`);
             return null;
         }
     }
-    /**
-     * Calculate SHA256 hash of file contents using streaming (matches reference repo)
-     */
-    static async getSha256Async(fileName) {
-        const hasher = crypto.createHash('sha256');
-        const stream = fs.createReadStream(fileName);
-        for await (const chunk of stream) {
-            hasher.update(chunk);
-        }
-        return hasher.digest('base64');
-    }
     /**
      * Create artifact upload URL
      */
     async createArtifactUploadUrl(workspaceId, jobId, filePath, categoryType, fileType) {
         try {
-            this.logging.log(`DEBUG-ATX-UPLOAD-URL: CreateArtifactUploadUrl operation started for job: ${jobId}`);
+            this.logging.log(`ATX: Starting CreateArtifactUploadUrl for job: ${jobId}`);
             // Initialize ATX client
-            await this.initializeAtxClient();
-            if (!this.atxClient) {
-                throw new Error('ATX client not initialized');
+            if (!this.atxClient && !(await this.initializeAtxClient())) {
+                throw new Error('ATX FES client not initialized');
             }
             // Calculate file checksum - exact reference repo implementation
-            const sha256 = await ATXTransformHandler.getSha256Async(filePath);
+            const sha256 = await utils_1.Utils.getSha256Async(filePath);
             const command = new elastic_gumby_frontend_client_1.CreateArtifactUploadUrlCommand({
                 workspaceId: workspaceId,
                 jobId: jobId,
@@ -380,7 +309,7 @@ class ATXTransformHandler {
             const result = (await this.atxClient.send(command));
             this.logging.log(`ATX: CreateArtifactUploadUrl RequestId: ${result.$metadata?.requestId}`);
             if (result && result.artifactId && result.s3PreSignedUrl) {
-                this.logging.log(`DEBUG-ATX-UPLOAD-URL: SUCCESS - Upload URL created`);
+                this.logging.log(`ATX: CreateArtifactUploadUrl completed successfully`);
                 return {
                     uploadId: result.artifactId,
                     uploadUrl: result.s3PreSignedUrl,
@@ -388,12 +317,12 @@ class ATXTransformHandler {
                 };
             }
             else {
-                this.logging.error('DEBUG-ATX-UPLOAD-URL: Missing artifactId or s3PreSignedUrl in response');
+                this.logging.error('ATX: CreateArtifactUploadUrl failed - missing artifactId or s3PreSignedUrl');
                 return null;
             }
         }
         catch (error) {
-            this.logging.error(`DEBUG-ATX-UPLOAD-URL: Error: ${String(error)}`);
+            this.logging.error(`ATX: CreateArtifactUploadUrl error: ${String(error)}`);
             return null;
         }
     }
@@ -402,11 +331,10 @@ class ATXTransformHandler {
      */
     async completeArtifactUpload(workspaceId, jobId, artifactId) {
         try {
-            this.logging.log(`DEBUG-ATX-COMPLETE-UPLOAD: CompleteArtifactUpload operation started for artifact: ${artifactId}`);
+            this.logging.log(`ATX: Starting CompleteArtifactUpload for artifact: ${artifactId}`);
             // Initialize ATX client
-            await this.initializeAtxClient();
-            if (!this.atxClient) {
-                throw new Error('ATX client not initialized');
+            if (!this.atxClient && !(await this.initializeAtxClient())) {
+                throw new Error('ATX FES client not initialized');
             }
             const command = new elastic_gumby_frontend_client_1.CompleteArtifactUploadCommand({
                 workspaceId: workspaceId,
@@ -415,11 +343,11 @@ class ATXTransformHandler {
             });
             await this.addAuthToCommand(command);
             const result = (await this.atxClient.send(command));
-            this.logging.log(`DEBUG-ATX-COMPLETE-UPLOAD: Upload completed successfully`);
+            this.logging.log(`ATX: CompleteArtifactUpload completed successfully`);
             return { success: true };
         }
         catch (error) {
-            this.logging.error(`DEBUG-ATX-COMPLETE-UPLOAD: Error: ${String(error)}`);
+            this.logging.error(`ATX: CompleteArtifactUpload error: ${String(error)}`);
             return null;
         }
     }
@@ -428,11 +356,10 @@ class ATXTransformHandler {
      */
     async startJob(workspaceId, jobId) {
         try {
-            this.logging.log(`DEBUG-ATX-START-JOB: StartJob operation started for job: ${jobId}`);
+            this.logging.log(`ATX: Starting job: ${jobId}`);
             // Initialize ATX client
-            await this.initializeAtxClient();
-            if (!this.atxClient) {
-                throw new Error('ATX client not initialized');
+            if (!this.atxClient && !(await this.initializeAtxClient())) {
+                throw new Error('ATX FES client not initialized');
             }
             const command = new elastic_gumby_frontend_client_1.StartJobCommand({
                 workspaceId: workspaceId,
@@ -441,11 +368,11 @@ class ATXTransformHandler {
             await this.addAuthToCommand(command);
             const result = (await this.atxClient.send(command));
             this.logging.log(`ATX: StartJob RequestId: ${result.$metadata?.requestId}`);
-            this.logging.log(`DEBUG-ATX-START-JOB: Job started successfully`);
+            this.logging.log(`ATX: Job started successfully`);
             return { success: true };
         }
         catch (error) {
-            this.logging.error(`DEBUG-ATX-START-JOB: Error: ${String(error)}`);
+            this.logging.error(`ATX: StartJob error: ${String(error)}`);
             return null;
         }
     }
@@ -454,73 +381,18 @@ class ATXTransformHandler {
      */
     async createZip(request) {
         try {
-            this.logging.log('DEBUG-ATX: Creating ZIP file from solution');
-            const workspacePath = this.getWorkspacePath(request.SolutionRootPath);
+            this.logging.log('ATX: Starting ZIP file creation from solution');
+            const workspacePath = utils_1.Utils.getWorkspacePath(request.SolutionRootPath);
             const artifactManager = new artifactManager_1.ArtifactManager(this.workspace, this.logging, workspacePath, request.SolutionRootPath);
             const zipFilePath = await artifactManager.createZip(request);
-            this.logging.log(`DEBUG-ATX: ZIP file created successfully: ${zipFilePath}`);
+            this.logging.log(`ATX: ZIP file created successfully: ${zipFilePath}`);
             return zipFilePath;
         }
         catch (error) {
-            this.logging.error(`DEBUG-ATX: createZip error: ${String(error)}`);
+            this.logging.error(`ATX: createZip error: ${String(error)}`);
             throw error;
         }
     }
-    /**
-     * Create workspace path like RTS does: {solutionRoot}/artifactWorkspace/{uuid}
-     */
-    getWorkspacePath(solutionRootPath) {
-        const { v4: uuidv4 } = require('uuid');
-        const randomPath = uuidv4().substring(0, 8);
-        const path = require('path');
-        const workspacePath = path.join(solutionRootPath, 'artifactWorkspace', randomPath);
-        if (!fs.existsSync(workspacePath)) {
-            fs.mkdirSync(workspacePath, { recursive: true });
-        }
-        return workspacePath;
-    }
-    /**
-     * Upload artifact to S3 using presigned URL and headers from ATX FES
-     */
-    async uploadArtifact(s3PreSignedUrl, filePath, requestHeaders) {
-        try {
-            this.logging.log(`DEBUG-ATX: Starting S3 upload to ${s3PreSignedUrl}`);
-            this.logging.log(`DEBUG-ATX: File path: ${filePath}`);
-            const headers = {};
-            // Add required headers from ATX FES response
-            if (requestHeaders) {
-                Object.keys(requestHeaders).forEach(key => {
-                    const value = requestHeaders[key];
-                    // Handle array values (take first element)
-                    headers[key] = Array.isArray(value) ? value[0] : value;
-                });
-            }
-            this.logging.log(`DEBUG-ATX: S3 Upload headers: ${JSON.stringify(Object.keys(headers))}`);
-            // Create file stream
-            const fileStream = fs.createReadStream(filePath);
-            // Upload to S3 using PUT request
-            const got = (await Promise.resolve().then(() => require('got'))).default;
-            const response = await got.put(s3PreSignedUrl, {
-                body: fileStream,
-                headers: headers,
-                timeout: { request: 300000 }, // 5 minutes timeout
-                retry: { limit: 0 },
-            });
-            this.logging.log(`DEBUG-ATX: S3 Upload response status: ${response.statusCode} ${response.statusMessage}`);
-            if (response.statusCode === 200) {
-                this.logging.log('DEBUG-ATX: S3 Upload SUCCESS');
-                return true;
-            }
-            else {
-                this.logging.error(`DEBUG-ATX: S3 Upload failed with status ${response.statusCode}`);
-                return false;
-            }
-        }
-        catch (error) {
-            this.logging.error(`DEBUG-ATX: S3 Upload error: ${String(error)}`);
-            return false;
-        }
-    }
     /**
      * Start ATX Transform - Orchestrates the full workflow
      * Step 1: CreateJob ✅
@@ -528,9 +400,8 @@ class ATXTransformHandler {
      */
     async startTransform(request) {
         try {
-            this.logging.log(`DEBUG-ATX-START: StartTransform workflow started for workspace: ${request.workspaceId}`);
+            this.logging.log(`ATX: Starting transform workflow for workspace: ${request.workspaceId}`);
             // Step 1: Create transformation job
-            this.logging.log('DEBUG-ATX-START: Step 1 - Creating transformation job');
             const createJobResponse = await this.createJob({
                 workspaceId: request.workspaceId,
                 jobName: request.jobName || 'Transform Job',
@@ -539,43 +410,32 @@ class ATXTransformHandler {
             if (!createJobResponse?.jobId) {
                 throw new Error('Failed to create ATX transformation job');
             }
-            this.logging.log(`DEBUG-ATX-START: Step 1 - Created job: ${createJobResponse.jobId} with status: ${createJobResponse.status}`);
             // Step 2: Create ZIP file
-            this.logging.log('DEBUG-ATX-START: Step 2 - Creating ZIP file from solution');
             const zipFilePath = await this.createZip(request.startTransformRequest);
             if (!zipFilePath) {
                 throw new Error('Failed to create ZIP file for ATX transformation');
             }
-            this.logging.log(`DEBUG-ATX-START: Step 2 - Created ZIP file: ${zipFilePath}`);
             // Step 3: Create artifact upload URL
-            this.logging.log('DEBUG-ATX-START: Step 3 - Creating artifact upload URL');
             const uploadResponse = await this.createArtifactUploadUrl(request.workspaceId, createJobResponse.jobId, zipFilePath, elastic_gumby_frontend_client_1.CategoryType.CUSTOMER_INPUT, elastic_gumby_frontend_client_1.FileType.ZIP);
             if (!uploadResponse?.uploadUrl) {
                 throw new Error('Failed to create artifact upload URL');
             }
-            this.logging.log(`DEBUG-ATX-START: Step 3 - Created upload URL with uploadId: ${uploadResponse.uploadId}`);
             // Step 4: Upload ZIP file to S3
-            this.logging.log('DEBUG-ATX-START: Step 4 - Uploading ZIP file to S3');
-            const uploadSuccess = await this.uploadArtifact(uploadResponse.uploadUrl, zipFilePath, uploadResponse.requestHeaders);
+            const uploadSuccess = await utils_1.Utils.uploadArtifact(uploadResponse.uploadUrl, zipFilePath, uploadResponse.requestHeaders, this.logging);
             if (!uploadSuccess) {
                 throw new Error('Failed to upload ZIP file to S3');
             }
-            this.logging.log('DEBUG-ATX-START: Step 4 - Successfully uploaded ZIP file to S3');
             // Step 5: Complete artifact upload
-            this.logging.log('DEBUG-ATX-START: Step 5 - Completing artifact upload');
             const completeResponse = await this.completeArtifactUpload(request.workspaceId, createJobResponse.jobId, uploadResponse.uploadId);
             if (!completeResponse?.success) {
                 throw new Error('Failed to complete artifact upload');
             }
-            this.logging.log('DEBUG-ATX-START: Step 5 - Successfully completed artifact upload');
             // Step 6: Start the transformation job
-            this.logging.log('DEBUG-ATX-START: Step 6 - Starting transformation job');
             const startJobResponse = await this.startJob(request.workspaceId, createJobResponse.jobId);
             if (!startJobResponse?.success) {
                 throw new Error('Failed to start ATX transformation job');
             }
-            this.logging.log('DEBUG-ATX-START: Step 6 - Successfully started transformation job');
-            this.logging.log('DEBUG-ATX-START: Full workflow completed successfully!');
+            this.logging.log('ATX: Transform workflow completed successfully');
             return {
                 TransformationJobId: createJobResponse.jobId,
                 ArtifactPath: zipFilePath,
@@ -583,16 +443,13 @@ class ATXTransformHandler {
             };
         }
         catch (error) {
-            this.logging.error(`DEBUG-ATX-START: StartTransform workflow error: ${String(error)}`);
+            this.logging.error(`ATX: StartTransform workflow error: ${String(error)}`);
             return null;
         }
     }
-    async sleep(duration = 0) {
-        return new Promise(r => setTimeout(r, Math.max(duration, 0)));
-    }
     async getJob(workspaceId, jobId) {
         try {
-            this.logging.log(`Getting job: ${jobId} in workspace: ${workspaceId}`);
+            this.logging.log(`ATX: Getting job: ${jobId} in workspace: ${workspaceId}`);
             if (!this.atxClient && !(await this.initializeAtxClient())) {
                 this.logging.error('ATX: GetJob client not initialized');
                 return null;
@@ -604,7 +461,7 @@ class ATXTransformHandler {
             });
             await this.addAuthToCommand(command);
             const response = await this.atxClient.send(command);
-            this.logging.log(`ATX: GetJob SUCCESS - Job status: ${response.job?.statusDetails?.status}`);
+            this.logging.log(`ATX: GetJob completed - Job status: ${response.job?.statusDetails?.status}`);
             return response.job || null;
         }
         catch (error) {
@@ -614,7 +471,7 @@ class ATXTransformHandler {
     }
     async createArtifactDownloadUrl(workspaceId, jobId, artifactId) {
         try {
-            this.logging.log(`DEBUG-ATX-UPLOAD-URL: CreateArtifactDownloadUrl operation started for job: ${jobId}`);
+            this.logging.log(`ATX: Starting CreateArtifactDownloadUrl for job: ${jobId}`);
             if (!this.atxClient && !(await this.initializeAtxClient())) {
                 throw new Error('ATX client not initialized');
             }
@@ -626,7 +483,7 @@ class ATXTransformHandler {
             await this.addAuthToCommand(command);
             const result = (await this.atxClient.send(command));
             if (result && result.s3PreSignedUrl) {
-                this.logging.log(`ATX: DownloadArtifactUrl SUCCESS - Download URL created`);
+                this.logging.log(`ATX: CreateArtifactDownloadUrl completed successfully`);
                 const normalizedHeaders = {};
                 if (result.requestHeaders) {
                     for (const [key, value] of Object.entries(result.requestHeaders)) {
@@ -639,21 +496,20 @@ class ATXTransformHandler {
                 };
             }
             else {
-                this.logging.error('ATX: DownloadArtifactUrl - Missing s3PreSignedUrl in response');
+                this.logging.error('ATX: CreateArtifactDownloadUrl failed - missing s3PreSignedUrl');
                 return null;
             }
         }
         catch (error) {
-            this.logging.error(`DEBUG-ATX-UPLOAD-URL: Error: ${String(error)}`);
+            this.logging.error(`ATX: CreateArtifactDownloadUrl error: ${String(error)}`);
             return null;
         }
     }
     async listHitls(workspaceId, jobId) {
         try {
-            this.logging.log('=== ATX FES ListHitls Operation (FES Client) ===');
-            this.logging.log(`Listing Hitls for job: ${jobId} in workspace: ${workspaceId}`);
+            this.logging.log(`ATX: Starting ListHitls for job: ${jobId}`);
             if (!this.atxClient && !(await this.initializeAtxClient())) {
-                this.logging.error('ListHitls: Failed to initialize ATX client');
+                this.logging.error('ATX: Failed to initialize client for ListHitls');
                 return null;
             }
             const command = new elastic_gumby_frontend_client_1.ListHitlTasksCommand({
@@ -666,20 +522,19 @@ class ATXTransformHandler {
             });
             await this.addAuthToCommand(command);
             const result = await this.atxClient.send(command);
-            this.logging.log(`ListHitls: SUCCESS - Found ${result.hitlTasks?.length || 0} HITL_FROM_USER artifacts`);
+            this.logging.log(`ATX: ListHitls completed - Found ${result.hitlTasks?.length || 0} tasks`);
             return result.hitlTasks || [];
         }
         catch (error) {
-            this.logging.error(`ListHitls error: ${String(error)}`);
+            this.logging.error(`ATX: ListHitls error: ${String(error)}`);
             return null;
         }
     }
     async submitHitl(workspaceId, jobId, taskId, humanArtifactId) {
         try {
-            this.logging.log('=== ATX FES SubmitHitl Operation (FES Client) ===');
-            this.logging.log(`Updating Hitl: ${taskId} for job: ${jobId} in workspace: ${workspaceId}`);
+            this.logging.log(`ATX: Starting SubmitHitl for task: ${taskId}`);
             if (!this.atxClient && !(await this.initializeAtxClient())) {
-                this.logging.error('SubmitHitl: Failed to initialize ATX client');
+                this.logging.error('ATX: Failed to initialize client for SubmitHitl');
                 return null;
             }
             const command = new elastic_gumby_frontend_client_1.SubmitCriticalHitlTaskCommand({
@@ -693,20 +548,19 @@ class ATXTransformHandler {
             });
             await this.addAuthToCommand(command);
             const result = await this.atxClient.send(command);
-            this.logging.log(`SubmitHitl: SUCCESS - task status: ${result.status || 'UNKNOWN'} `);
+            this.logging.log(`ATX: SubmitHitl completed - task status: ${result.status || 'UNKNOWN'}`);
             return result;
         }
         catch (error) {
-            this.logging.error(`ListHitls error: ${String(error)}`);
+            this.logging.error(`ATX: SubmitHitl error: ${String(error)}`);
             return null;
         }
     }
     async getHitl(workspaceId, jobId, taskId) {
         try {
-            this.logging.log('=== ATX FES Get Hitl Operation (FES Client) ===');
-            this.logging.log(`Getting Hitl: ${jobId} in workspace: ${workspaceId}`);
+            this.logging.log(`ATX: Getting Hitl task: ${taskId}`);
             if (!this.atxClient && !(await this.initializeAtxClient())) {
-                this.logging.error('GetHitl: Failed to initialize ATX client');
+                this.logging.error('ATX: Failed to initialize client for GetHitl');
                 return null;
             }
             const command = new elastic_gumby_frontend_client_1.GetHitlTaskCommand({
@@ -716,63 +570,56 @@ class ATXTransformHandler {
             });
             await this.addAuthToCommand(command);
             const result = await this.atxClient.send(command);
-            this.logging.log(`GetHitl: SUCCESS - Job data received`);
+            this.logging.log(`ATX: GetHitl completed successfully`);
             return result.task || null;
         }
         catch (error) {
-            this.logging.error(`GetHitl error: ${String(error)}`);
+            this.logging.error(`ATX: GetHitl error: ${String(error)}`);
             return null;
         }
     }
     async pollHitlTask(workspaceId, jobId, taskId) {
-        this.logging.log('Starting polling for hitl after upload');
+        this.logging.log('ATX: Starting polling for hitl after upload');
         try {
             var count = 0;
             while (count < 100) {
                 const jobStatus = await this.getHitl(workspaceId, jobId, taskId);
-                this.logging.log(`Hitl Polling get status: ${jobStatus?.status}`);
+                this.logging.log(`ATX: Hitl polling status: ${jobStatus?.status}`);
                 if (jobStatus && jobStatus.status == 'CLOSED') {
-                    this.logging.log('Hitl Polling get status CLOSED');
                     return 'Validation Success!';
                 }
                 else if (jobStatus && jobStatus.status == 'CLOSED_PENDING_NEXT_TASK') {
-                    // Fallback to placeholder if API call fails
-                    this.logging.log('Hitl Polling get status CLOSED_PENDING_NEXT_TASK');
                     return 'Submitted plan did not pass validation, please check the plan for details....';
                 }
                 else if (jobStatus && jobStatus.status == 'CANCELLED') {
-                    // Fallback to placeholder if API call fails
-                    this.logging.log('Hitl Polling get status CANCELLED');
                     return 'Timeout occured during planning, proceeding with default plan....';
                 }
                 else {
-                    this.logging.log('Hitl polling in progress....');
-                    await this.sleep(10 * 1000);
+                    await utils_1.Utils.sleep(10 * 1000);
                     count++;
                 }
             }
-            this.logging.log('Returning null, 100 polls and no approve or reject');
+            this.logging.log('ATX: Hitl polling timeout after 100 attempts');
             return null;
         }
         catch (error) {
-            this.logging.error(`Hitl polling error: ${String(error)}`);
+            this.logging.error(`ATX: Hitl polling error: ${String(error)}`);
             return null;
         }
     }
     async getHitlAgentArtifact(workspaceId, jobId, solutionRootPath) {
         try {
-            this.logging.log('=== ATX FES Get Hitl Agent Artifact Operation (FES Client) ===');
-            this.logging.log(`Getting Hitl Agent Artifact: ${jobId} in workspace: ${workspaceId}`);
+            this.logging.log(`ATX: Getting Hitl Agent Artifact for job: ${jobId}`);
             if (!this.atxClient && !(await this.initializeAtxClient())) {
-                this.logging.error('GetHitlAgentArtifact: Failed to initialize ATX client');
+                this.logging.error('ATX: Failed to initialize client for GetHitlAgentArtifact');
                 return null;
             }
             const hitls = await this.listHitls(workspaceId, jobId);
             if (hitls && hitls.length != 1) {
-                this.logging.log(`ATX FES Job ${jobId} - Found ${hitls.length} hitls`);
+                this.logging.log(`ATX: Found ${hitls.length} hitls (expected 1)`);
             }
             else if (!hitls) {
-                this.logging.log(`ATX FES Job ${jobId} - no or many hitls available for download (expects 1 hitl)`);
+                this.logging.error(`ATX: No hitls available for download`);
                 throw new Error('no or many HITLE_FROM_USER artifacts available for download (expects 1 artifact)');
             }
             const hitl = hitls[0];
@@ -781,15 +628,15 @@ class ATXTransformHandler {
             if (!downloadInfo) {
                 throw new Error('Failed to get ATX FES download URL');
             }
-            this.logging.log(`ATX FES Job ${jobId} - Artifact download URL created: ${downloadInfo.s3PresignedUrl}`);
-            const pathToDownload = path.join(solutionRootPath, exports.ArtifactWorkspaceName, jobId);
-            await this.downloadAndExtractArchive(downloadInfo.s3PresignedUrl, downloadInfo.requestHeaders, pathToDownload, 'transformation-plan-download.zip');
+            const pathToDownload = path.join(solutionRootPath, utils_1.workspaceFolderName, jobId);
+            await utils_1.Utils.downloadAndExtractArchive(downloadInfo.s3PresignedUrl, downloadInfo.requestHeaders, pathToDownload, 'transformation-plan-download.zip', this.logging);
             const planPath = path.join(pathToDownload, 'transformation-plan.md');
             const reportPath = path.join(pathToDownload, 'assessment-report.md');
+            this.logging.log(`ATX: GetHitlAgentArtifact completed successfully`);
             return { PlanPath: planPath, ReportPath: reportPath };
         }
         catch (error) {
-            this.logging.error(`GetHitlAgentArtifact error: ${String(error)}`);
+            this.logging.error(`ATX: GetHitlAgentArtifact error: ${String(error)}`);
             return null;
         }
     }
@@ -798,15 +645,14 @@ class ATXTransformHandler {
      */
     async getTransformInfo(request) {
         try {
-            this.logging.log(`DEBUG-ATX-GET-INFO: getTransformInfo called with: ${JSON.stringify(request)}`);
+            this.logging.log(`ATX: Getting transform info for job: ${request.TransformationJobId}`);
             const job = await this.getJob(request.WorkspaceId, request.TransformationJobId);
             if (!job) {
-                this.logging.log(`DEBUG-ATX-GET-INFO: Get Job returned null`);
+                this.logging.error(`ATX: Job not found: ${request.TransformationJobId}`);
                 return null;
             }
             const jobStatus = job.statusDetails?.status;
             if (jobStatus === 'COMPLETED') {
-                this.logging.log(`DEBUG-ATX-GET-INFO: Job completed successfully`);
                 const pathToArtifact = await this.downloadFinalArtifact(request.WorkspaceId, request.TransformationJobId, request.SolutionRootPath);
                 const plan = await this.getTransformationPlan(request.WorkspaceId, request.TransformationJobId, request.SolutionRootPath);
                 return {
@@ -820,7 +666,6 @@ class ATXTransformHandler {
                 };
             }
             else if (jobStatus === 'FAILED') {
-                this.logging.log(`DEBUG-ATX-GET-INFO: Job failed`);
                 return {
                     TransformationJob: {
                         WorkspaceId: request.WorkspaceId,
@@ -832,7 +677,6 @@ class ATXTransformHandler {
                 };
             }
             else if (jobStatus === 'STOPPING' || jobStatus === 'STOPPED') {
-                this.logging.log(`DEBUG-ATX-GET-INFO: Job stopping`);
                 return {
                     TransformationJob: {
                         WorkspaceId: request.WorkspaceId,
@@ -843,7 +687,6 @@ class ATXTransformHandler {
                 };
             }
             else if (jobStatus === 'PLANNED') {
-                this.logging.log(`DEBUG-ATX-GET-INFO: Job in PLANNED`);
                 const plan = await this.getTransformationPlan(request.WorkspaceId, request.TransformationJobId, request.SolutionRootPath);
                 return {
                     TransformationJob: {
@@ -855,7 +698,6 @@ class ATXTransformHandler {
                 };
             }
             else if (jobStatus === 'AWAITING_HUMAN_INPUT') {
-                this.logging.log(`DEBUG-ATX-GET-INFO: Job in AWAITING_HUMAN_INPUT`);
                 const response = await this.getHitlAgentArtifact(request.WorkspaceId, request.TransformationJobId, request.SolutionRootPath);
                 return {
                     TransformationJob: {
@@ -868,7 +710,6 @@ class ATXTransformHandler {
                 };
             }
             else {
-                this.logging.log(`DEBUG-ATX-GET-INFO: Job in PLANNING`);
                 await this.listWorklogs(request.WorkspaceId, request.TransformationJobId, request.SolutionRootPath);
                 return {
                     TransformationJob: {
@@ -880,46 +721,44 @@ class ATXTransformHandler {
             }
         }
         catch (error) {
-            this.logging.error(`ATX: Get TransformInfo error: ${String(error)}`);
+            this.logging.error(`ATX: GetTransformInfo error: ${String(error)}`);
             return null;
         }
     }
     async uploadPlan(request) {
-        this.logging.info('Starting upload plan');
+        this.logging.log('ATX: Starting upload plan');
         if (!this.cachedHitl) {
             this.logging.error('ATX: UploadPlan error: No cached hitl');
             return null;
         }
         try {
-            const pathToZip = path.join(path.dirname(request.PlanPath), 'transformation-plan-upload.md');
-            await this.zipFile(request.PlanPath, pathToZip);
+            const pathToZip = path.join(path.dirname(request.PlanPath), 'transformation-plan-upload.zip');
+            await utils_1.Utils.zipFile(request.PlanPath, pathToZip);
             const uploadInfo = await this.createArtifactUploadUrl(request.WorkspaceId, request.TransformationJobId, pathToZip, elastic_gumby_frontend_client_1.CategoryType.HITL_FROM_USER, elastic_gumby_frontend_client_1.FileType.ZIP);
             if (!uploadInfo) {
-                this.logging.error('ATX: UploadPlan error: Failed to get ATX upload URL');
+                this.logging.error('ATX: UploadPlan error: Failed to get upload URL');
                 return null;
             }
-            this.logging.log(`ATX: UploadPlan: Artifact upload URL created: ${uploadInfo.uploadUrl}`);
-            const uploadSuccess = await this.uploadArtifact(uploadInfo.uploadUrl, pathToZip, uploadInfo.requestHeaders);
+            const uploadSuccess = await utils_1.Utils.uploadArtifact(uploadInfo.uploadUrl, pathToZip, uploadInfo.requestHeaders, this.logging);
             if (!uploadSuccess) {
                 throw new Error('Failed to upload ZIP file to S3');
-                return null;
             }
             const completeResponse = await this.completeArtifactUpload(request.WorkspaceId, request.TransformationJobId, uploadInfo.uploadId);
             if (!completeResponse?.success) {
                 throw new Error('Failed to complete artifact upload');
             }
-            this.logging.info('Uploaded plan, submitting hitl');
+            this.logging.log('ATX: Plan uploaded, submitting hitl');
             const submitHitl = await this.submitHitl(request.WorkspaceId, request.TransformationJobId, this.cachedHitl, uploadInfo.uploadId);
             if (!submitHitl) {
                 throw new Error('Failed to submit hitl');
             }
-            this.logging.info('Submitted hitl, polling for status');
+            this.logging.log('ATX: Hitl submitted, polling for status');
             const validation = await this.pollHitlTask(request.WorkspaceId, request.TransformationJobId, this.cachedHitl);
             if (!validation) {
                 throw new Error('Failed to poll hitl task');
             }
             if (validation === 'Submitted plan did not pass validation, please check the plan for details....') {
-                const response = await this.getHitlAgentArtifact(request.WorkspaceId, request.TransformationJobId, path.dirname(request.PlanPath));
+                const response = await this.getHitlAgentArtifact(request.WorkspaceId, request.TransformationJobId, path.dirname(path.dirname(path.dirname(request.PlanPath))));
                 return {
                     VerificationStatus: false,
                     Message: validation,
@@ -965,37 +804,32 @@ class ATXTransformHandler {
     }
     async downloadFinalArtifact(workspaceId, jobId, solutionRootPath) {
         try {
-            this.logging.log('=== ATX FES Download Export Result Archive ===');
-            this.logging.log(`Called with jobId: ${jobId}, solutionRootPath: ${solutionRootPath}`);
-            this.logging.log(`Listing CUSTOMER_OUTPUT artifacts for job: ${jobId}`);
+            this.logging.log(`ATX: Starting download final artifact for job: ${jobId}`);
             const artifacts = await this.listArtifacts(workspaceId, jobId);
             if (!artifacts || artifacts.length === 0) {
                 throw new Error('No CUSTOMER_OUTPUT artifacts available for download');
             }
             const artifact = artifacts[0];
             const artifactId = artifact.artifactId;
-            this.logging.log(`Found artifact: ${artifactId}, size: ${artifact.sizeInBytes} bytes`);
-            this.logging.log(`Creating download URL for artifactId: ${artifactId}`);
+            this.logging.log(`ATX: Found artifact: ${artifactId}, size: ${artifact.sizeInBytes} bytes`);
             const downloadInfo = await this.createArtifactDownloadUrl(workspaceId, jobId, artifactId);
             if (!downloadInfo) {
                 throw new Error('Failed to get ATX FES download URL');
             }
-            this.logging.log(`ATX FES Job ${jobId} - Artifact download URL created: ${downloadInfo.s3PresignedUrl}`);
-            const pathToDownload = path.join(solutionRootPath, exports.ArtifactWorkspaceName, jobId);
-            await this.downloadAndExtractArchive(downloadInfo.s3PresignedUrl, downloadInfo.requestHeaders, pathToDownload, 'ExportResultsArchive.zip');
+            const pathToDownload = path.join(solutionRootPath, utils_1.workspaceFolderName, jobId);
+            await utils_1.Utils.downloadAndExtractArchive(downloadInfo.s3PresignedUrl, downloadInfo.requestHeaders, pathToDownload, 'ExportResultsArchive.zip', this.logging);
+            this.logging.log(`ATX: Download final artifact completed successfully`);
             return pathToDownload;
         }
         catch (error) {
-            this.logging.error(`ATX FES download failed: ${String(error)}`);
+            this.logging.error(`ATX: Download final artifact failed: ${String(error)}`);
             return null;
         }
     }
     async getTransformationPlan(workspaceId, jobId, solutionRootPath) {
-        this.logging.log('Using ATX FES for Transform profile - real ListJobPlanSteps');
         try {
             // Get real plan steps from ATX FES (only if job status >= PLANNED)
             const planSteps = await this.getATXFESJobPlanSteps(workspaceId, jobId);
-            this.logging.log(`dbu ListWorklog all ${JSON.stringify(planSteps)}`);
             if (planSteps) {
                 this.logging.log(`ATX FES: Found ${planSteps.length} transformation steps`);
                 // Sort steps by score (primary) and startTime (tiebreaker) to match RTS ordering
@@ -1008,7 +842,6 @@ class ATXTransformHandler {
                     const timeB = b.startTime ? new Date(b.startTime).getTime() : 0;
                     return timeA - timeB;
                 });
-                this.logging.log(`PlanSteps response: ` + JSON.stringify(planSteps));
                 // Return in exact same format as RTS with all required fields
                 const transformationPlan = {
                     transformationSteps: planSteps.map((step, index) => {
@@ -1038,10 +871,8 @@ class ATXTransformHandler {
                                         substepStatus = 'IN_PROGRESS'; // No NOT_STARTED option in ProgressUpdate enum
                                         break;
                                 }
-                                this.logging.log(`this is progres update for step ${JSON.stringify(step)} and has substep is ${JSON.stringify(substep)}`);
                                 // Map nested progress updates (3rd level)
                                 const nestedProgressUpdates = (substep.substeps || []).map((nestedUpdate) => {
-                                    this.logging.log(`Found nested progress update: ${nestedUpdate.stepName} with status: ${nestedUpdate.status}`);
                                     let nestedStatus = 'IN_PROGRESS';
                                     switch (nestedUpdate.status) {
                                         case 'SUCCEEDED':
@@ -1069,7 +900,6 @@ class ATXTransformHandler {
                                         stepId: nestedUpdate.stepId ?? undefined,
                                     };
                                 });
-                                this.logging.log(`Substep ${substep.stepName} has ${nestedProgressUpdates.length} nested progress updates`);
                                 return {
                                     name: substep.stepName || 'Unknown Substep',
                                     description: substep.description || '',
@@ -1095,7 +925,6 @@ class ATXTransformHandler {
                             // Use ATX step data directly without hardcoded ordering
                             const stepNumber = index + 1;
                             const stepName = `Step ${stepNumber} - ${step.stepName || 'Unknown Step'}`;
-                            this.logging.log(`ATX Step ${stepNumber}: ${step.stepName} (${step.status} → ${mappedStatus}) with ${progressUpdates.length} substeps`);
                             return {
                                 id: step.stepId || `step-${stepNumber}`,
                                 name: stepName,
@@ -1107,7 +936,7 @@ class ATXTransformHandler {
                             };
                         }
                         catch (error) {
-                            this.logging.error(`ATX FES: Error mapping step ${index}: ${error instanceof Error ? error.message : 'Unknown error'}`);
+                            this.logging.error(`ATX FES: Error mapping step ${index}: ${String(error)}`);
                             // Return a safe fallback step
                             const stepNumber = index + 1;
                             return {
@@ -1129,9 +958,6 @@ class ATXTransformHandler {
                     this.logging.log(`ATX FES: Could not get worklog for workspaces: ${workspaceId}, job id: ${jobId}`);
                 }
                 this.logging.log(`ATX FES: Successfully mapped ${transformationPlan.transformationSteps?.length || 0} steps`);
-                if (transformationPlan.transformationSteps?.[0]) {
-                    this.logging.log(`ATX FES: First step mapped - id: ${transformationPlan.transformationSteps[0].id}, name: ${transformationPlan.transformationSteps[0].name}`);
-                }
                 return transformationPlan;
             }
             else {
@@ -1142,7 +968,7 @@ class ATXTransformHandler {
             }
         }
         catch (error) {
-            this.logging.error(`ATX FES getTransformationPlan error: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            this.logging.error(`ATX FES getTransformationPlan error: ${String(error)}`);
             // Return empty plan on error
             return {
                 transformationSteps: [],
@@ -1156,7 +982,6 @@ class ATXTransformHandler {
             if (result) {
                 const steps = result || [];
                 this.logging.log(`ListJobPlanSteps: SUCCESS - Found ${steps.length} plan steps with substeps`);
-                this.logging.log(`PlanSteps are  ${JSON.stringify(result)}`);
                 return steps;
             }
             return null;
@@ -1171,9 +996,9 @@ class ATXTransformHandler {
      */
     async listJobPlanSteps(workspaceId, jobId) {
         try {
-            this.logging.log('=== ATX FES ListJobPlanSteps Operation (FES Client) ===');
+            this.logging.log(`ATX: Starting ListJobPlanSteps for job: ${jobId}`);
             if (!this.atxClient && !(await this.initializeAtxClient())) {
-                this.logging.error('ListJobPlanSteps: Failed to initialize ATX client');
+                this.logging.error('ATX: Failed to initialize client for ListJobPlanSteps');
                 return null;
             }
             // Get root steps first
@@ -1181,7 +1006,6 @@ class ATXTransformHandler {
             if (rootSteps && rootSteps.length > 0) {
                 // For each root step, get its substeps
                 for (const step of rootSteps) {
-                    this.logging.log(`Getting substeps for step: ${step.stepName} (ID: ${step.stepId})`);
                     const substeps = await this.getStepsRecursive(workspaceId, jobId, step.stepId);
                     step.substeps = substeps || [];
                     // Sort substeps by score (primary) and startTime (tiebreaker) to match RTS ordering
@@ -1196,7 +1020,6 @@ class ATXTransformHandler {
                             return timeA - timeB;
                         });
                         for (const substep of step.substeps) {
-                            this.logging.log(`Getting superSubstep for step: ${substep.stepName} (ID: ${substep.stepId})`);
                             const superSubsteps = await this.getStepsRecursive(workspaceId, jobId, substep.stepId);
                             substep.substeps = superSubsteps || [];
                             // Sort substeps by score (primary) and startTime (tiebreaker) to match RTS ordering
@@ -1211,31 +1034,17 @@ class ATXTransformHandler {
                                     return timeA - timeB;
                                 });
                             }
-                            this.logging.log(`Step ${substep.stepName}: Found ${substep.substeps.length} substeps`);
-                            // Log substep details for debugging
-                            if (substep.substeps.length > 0) {
-                                substep.substeps.forEach((superSubstep, index) => {
-                                    this.logging.log(`  SuperSubstep ${index + 1}: ${superSubstep.stepName} (${superSubstep.status || 'No status'})`);
-                                });
-                            }
                         }
                     }
-                    this.logging.log(`Step ${step.stepName}: Found ${step.substeps.length} substeps`);
-                    // Log substep details for debugging
-                    if (step.substeps.length > 0) {
-                        step.substeps.forEach((substep, index) => {
-                            this.logging.log(`  Substep ${index + 1}: ${substep.stepName} (${substep.status || 'No status'})`);
-                        });
-                    }
                 }
-                this.logging.log(`ListJobPlanSteps: SUCCESS - Found ${rootSteps.length} steps with substeps`);
+                this.logging.log(`ATX: ListJobPlanSteps completed - Found ${rootSteps.length} steps with substeps`);
                 return rootSteps;
             }
-            this.logging.log('ListJobPlanSteps: No root steps found');
+            this.logging.log('ATX: ListJobPlanSteps - No root steps found');
             return null;
         }
         catch (error) {
-            this.logging.error(`ListJobPlanSteps error: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            this.logging.error(`ATX: ListJobPlanSteps error: ${String(error)}`);
             return null;
         }
     }
@@ -1253,13 +1062,12 @@ class ATXTransformHandler {
             await this.addAuthToCommand(command);
             const result = await this.atxClient.send(command);
             if (result && result.steps && result.steps.length > 0) {
-                this.logging.log(`Found ${result.steps.length} steps for parent: ${parentStepId}`);
                 return result.steps;
             }
             return null;
         }
         catch (error) {
-            this.logging.error(`Error getting steps for parent ${parentStepId}: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            this.logging.error(`Error getting steps for parent ${parentStepId}: ${String(error)}`);
             return null;
         }
     }
@@ -1268,10 +1076,9 @@ class ATXTransformHandler {
      */
     async listArtifacts(workspaceId, jobId, filter = 'CUSTOMER_OUTPUT') {
         try {
-            this.logging.log('=== ATX FES ListArtifacts Operation (FES Client) ===');
-            this.logging.log(`Listing artifacts for job: ${jobId} in workspace: ${workspaceId}`);
+            this.logging.log(`ATX: Starting ListArtifacts for job: ${jobId}`);
             if (!this.atxClient && !(await this.initializeAtxClient())) {
-                this.logging.error('ListArtifacts: Failed to initialize ATX client');
+                this.logging.error('ATX: Failed to initialize client for ListArtifacts');
                 return null;
             }
             const command = new elastic_gumby_frontend_client_1.ListArtifactsCommand({
@@ -1283,11 +1090,11 @@ class ATXTransformHandler {
             });
             await this.addAuthToCommand(command);
             const result = await this.atxClient.send(command);
-            this.logging.log(`ListArtifacts: SUCCESS - Found ${result.artifacts?.length || 0} CUSTOMER_OUTPUT artifacts`);
+            this.logging.log(`ATX: ListArtifacts completed - Found ${result.artifacts?.length || 0} artifacts`);
             return result.artifacts || [];
         }
         catch (error) {
-            this.logging.error(`ListArtifacts error: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            this.logging.error(`ATX: ListArtifacts error: ${error instanceof Error ? error.message : 'Unknown error'}`);
             return null;
         }
     }
@@ -1296,10 +1103,9 @@ class ATXTransformHandler {
      */
     async listWorklogs(workspaceId, jobId, solutionRootPath, stepId) {
         try {
-            this.logging.log('=== ATX FES ListWorklog Operation (FES Client) ===');
-            this.logging.log(`Listing ListWorklog for job: ${jobId} in workspace: ${workspaceId}`);
+            this.logging.log(`ATX: Starting ListWorklogs for job: ${jobId}`);
             if (!this.atxClient && !(await this.initializeAtxClient())) {
-                this.logging.error('ListWorklog: Failed to initialize ATX client');
+                this.logging.error('ATX: Failed to initialize client for ListWorklogs');
                 return null;
             }
             const command = new elastic_gumby_frontend_client_1.ListWorklogsCommand({
@@ -1315,122 +1121,18 @@ class ATXTransformHandler {
             });
             await this.addAuthToCommand(command);
             const result = await this.atxClient.send(command);
-            this.logging.log(`dbu ListWorklog all ${JSON.stringify(result)}`);
-            this.logging.log(`ListWorklog: SUCCESS - Found ${result.worklogs?.entries.length || 0} wokrlog entries for step ${stepId}`);
-            result.worklogs?.forEach(async (value, index) => {
+            this.logging.log(`ATX: ListWorklogs completed - Found ${result.worklogs?.length || 0} entries`);
+            for (const value of result.worklogs || []) {
                 const currentStepId = value.attributeMap?.STEP_ID || stepId || 'Progress';
-                this.logging.log(`worklog entry: ${value.description}`);
-                await this.saveWorklogsToJson(jobId, currentStepId, value.description || '', solutionRootPath);
-            });
+                await utils_1.Utils.saveWorklogsToJson(jobId, currentStepId, value.description || '', solutionRootPath);
+            }
             return result.worklogs || [];
         }
         catch (error) {
-            this.logging.error(`ListArtifacts error: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            this.logging.error(`ATX: ListWorklogs error: ${String(error)}`);
             return null;
         }
     }
-    /**
-     * Saves worklogs to JSON file with stepId as key and description as value
-     */
-    async saveWorklogsToJson(jobId, stepId, description, solutionRootPath) {
-        try {
-            const worklogDir = path.join(solutionRootPath, exports.ArtifactWorkspaceName, jobId);
-            const worklogPath = path.join(worklogDir, 'worklogs.json');
-            await this.directoryExists(worklogDir);
-            let worklogData = {};
-            // Read existing worklog if it exists
-            if (fs.existsSync(worklogPath)) {
-                const existingData = fs.readFileSync(worklogPath, 'utf8');
-                worklogData = JSON.parse(existingData);
-            }
-            if (stepId == null) {
-                stepId = 'Progress';
-            }
-            // Initialize array if stepId doesn't exist
-            if (!worklogData[stepId]) {
-                worklogData[stepId] = [];
-            }
-            // Add description if not already present
-            if (!worklogData[stepId].includes(description)) {
-                worklogData[stepId].push(description);
-            }
-            // Write back to file
-            fs.writeFileSync(worklogPath, JSON.stringify(worklogData, null, 2));
-        }
-        catch (error) {
-            this.logging.error(`Error saving worklog: ${error instanceof Error ? error.message : 'Unknown error'}`);
-        }
-    }
-    async downloadAndExtractArchive(downloadUrl, requestHeaders, saveToDir, exportName) {
-        const response = await got_1.default.get(downloadUrl, {
-            headers: requestHeaders || {},
-            timeout: { request: 300000 }, // 5 minutes
-            responseType: 'buffer',
-        });
-        // Save, extract, and return paths
-        const buffer = [Buffer.from(response.body)];
-        return await this.extractArchiveFromBuffer(exportName, buffer, saveToDir);
-    }
-    /**
-     * Extracts ZIP archive from buffer using AdmZip
-     */
-    async extractArchiveFromBuffer(exportName, buffer, saveToDir) {
-        const pathToArchive = path.join(saveToDir, exportName);
-        await this.directoryExists(saveToDir);
-        await fs.writeFileSync(pathToArchive, Buffer.concat(buffer));
-        const pathContainingArchive = path.dirname(pathToArchive);
-        const zip = new AdmZip(pathToArchive);
-        const zipEntries = zip.getEntries();
-        await this.extractAllEntriesTo(pathContainingArchive, zipEntries);
-        return pathContainingArchive;
-    }
-    async directoryExists(directoryPath) {
-        try {
-            await fs.promises.access(directoryPath);
-        }
-        catch (error) {
-            this.logging.log(`Directory doesn't exist, creating it: ${directoryPath}`);
-            await fs.promises.mkdir(directoryPath, { recursive: true });
-        }
-    }
-    /**
-     * Extracts all ZIP entries to target directory
-     */
-    async extractAllEntriesTo(pathContainingArchive, zipEntries) {
-        for (const entry of zipEntries) {
-            try {
-                const entryPath = path.join(pathContainingArchive, entry.entryName);
-                if (entry.isDirectory) {
-                    await fs.promises.mkdir(entryPath, { recursive: true });
-                }
-                else {
-                    const parentDir = path.dirname(entryPath);
-                    await fs.promises.mkdir(parentDir, { recursive: true });
-                    await fs.promises.writeFile(entryPath, entry.getData());
-                }
-            }
-            catch (extractError) {
-                if (extractError instanceof Error && 'code' in extractError && extractError.code === 'ENOENT') {
-                    this.logging.log(`Attempted to extract a file that does not exist: ${entry.entryName}`);
-                }
-                else {
-                    throw extractError;
-                }
-            }
-        }
-    }
-    async zipFile(sourceFilePath, outputZipPath) {
-        const archive = archiver('zip', { zlib: { level: 9 } });
-        const stream = fs.createWriteStream(outputZipPath);
-        return new Promise((resolve, reject) => {
-            archive
-                .file(sourceFilePath, { name: path.basename(sourceFilePath) })
-                .on('error', err => reject(err))
-                .pipe(stream);
-            stream.on('close', () => resolve());
-            void archive.finalize();
-        });
-    }
 }
 exports.ATXTransformHandler = ATXTransformHandler;
 //# sourceMappingURL=atxTransformHandler.js.map