@wdio/browserstack-service 8.48.0 → 8.48.3

package/build/service.js

@@ -8,7 +8,7 @@ import got from 'got';
 import { getBrowserDescription, getBrowserCapabilities, isBrowserstackCapability, getParentSuiteName, isBrowserstackSession, patchConsoleLogs, shouldAddServiceVersion, isTrue, normalizeTestReportingConfig, normalizeTestReportingEnvVariables } from './util.js';
 import InsightsHandler from './insights-handler.js';
 import TestReporter from './reporter.js';
-import { DEFAULT_OPTIONS, PERF_MEASUREMENT_ENV } from './constants.js';
+import { DEFAULT_OPTIONS, NOT_ALLOWED_KEYS_IN_CAPS, PERF_MEASUREMENT_ENV } from './constants.js';
 import CrashReporter from './crash-reporter.js';
 import AccessibilityHandler from './accessibility-handler.js';
 import { BStackLogger } from './bstackLogger.js';
@@ -20,6 +20,7 @@ import { shouldProcessEventForTesthub } from './testHub/utils.js';
 import AiHandler from './ai-handler.js';
 import PerformanceTester from './instrumentation/performance/performance-tester.js';
 import * as PERFORMANCE_SDK_EVENTS from './instrumentation/performance/constants.js';
+import { EVENTS } from './instrumentation/performance/constants.js';
 import { BrowserstackCLI } from './cli/index.js';
 import { TestFrameworkState } from './cli/states/testFrameworkState.js';
 import { HookState } from './cli/states/hookState.js';
@@ -94,6 +95,7 @@ export default class BrowserstackService {
         return fn(this._caps);
     }
     async beforeSession(config, capabilities) {
+        PerformanceTester.start(PERFORMANCE_SDK_EVENTS.DRIVER_EVENT.INIT);
         // if no user and key is specified even though a browserstack service was
         // provided set user and key with values so that the session request
         // will fail
@@ -107,13 +109,19 @@ export default class BrowserstackService {
         this._config.user = config.user;
         this._config.key = config.key;
         try {
-            if (CLIUtils.checkCLISupportedFrameworks(this._config.framework)) {
+            // Detect if multi-remote and disable CLI for those sessions
+            if (CLIUtils.checkCLISupportedFrameworks(this._config.framework) && process.env.BROWSERSTACK_IS_MULTIREMOTE !== 'true') {
                 // Connect to Browserstack CLI from worker
                 await BrowserstackCLI.getInstance().bootstrap(this._options, this._config);
                 // Get the nearest hub and update it in config
+                PerformanceTester.start(PERFORMANCE_SDK_EVENTS.EVENTS.SDK_FIND_NEAREST_HUB);
                 const hubUrl = BrowserstackCLI.getInstance().getConfig().hubUrl;
                 if (hubUrl) {
                     this._config.hostname = new URL(hubUrl).hostname;
+                    PerformanceTester.end(PERFORMANCE_SDK_EVENTS.EVENTS.SDK_FIND_NEAREST_HUB);
+                }
+                else {
+                    PerformanceTester.end(PERFORMANCE_SDK_EVENTS.EVENTS.SDK_FIND_NEAREST_HUB, false, 'Hub URL not found');
                 }
             }
             if (BrowserstackCLI.getInstance().isRunning()) {
@@ -121,13 +129,30 @@ export default class BrowserstackService {
                 const instance = AutomationFramework.getTrackedInstance();
                 const caps = AutomationFramework.getState(instance, AutomationFrameworkConstants.KEY_CAPABILITIES);
                 Object.assign(capabilities, caps);
+                // Strip CLI-only options that BrowserStack hub doesn't accept
+                const bstackOptions = capabilities['bstack:options'];
+                if (bstackOptions && typeof bstackOptions === 'object') {
+                    NOT_ALLOWED_KEYS_IN_CAPS.forEach(key => delete bstackOptions[key]);
+                }
+                NOT_ALLOWED_KEYS_IN_CAPS.forEach(key => delete capabilities[`browserstack.${key}`]);
             }
         }
         catch (err) {
             BStackLogger.error(`Error while connecting to Browserstack CLI: ${err}`);
-        }
+            PerformanceTester.end(PERFORMANCE_SDK_EVENTS.DRIVER_EVENT.INIT, false, util.format(err));
+            throw err;
+        }
+        PerformanceTester.end(PERFORMANCE_SDK_EVENTS.DRIVER_EVENT.INIT);
+        // Start tracking device allocation - this measures the gap between beforeSession end and before start
+        // This captures the time WebDriverIO takes to create the remote session with BrowserStack
+        PerformanceTester.start(PERFORMANCE_SDK_EVENTS.EVENTS.SDK_DEVICE_ALLOCATION);
+        BStackLogger.debug('Device allocation tracking started - waiting for WebDriverIO to create remote session');
     }
     async before(caps, specs, browser) {
+        // End device allocation tracking - remote session is now created and browser object is available
+        PerformanceTester.end(PERFORMANCE_SDK_EVENTS.EVENTS.SDK_DEVICE_ALLOCATION, true, 'Device allocated and session created');
+        BStackLogger.debug('Device allocation tracking ended - remote session created successfully');
+        PerformanceTester.start(PERFORMANCE_SDK_EVENTS.DRIVER_EVENT.PRE_INITIALIZE);
         // added to maintain backward compatibility with webdriverIO v5
         this._browser = browser ? browser : globalThis.browser;
         PerformanceTester.browser = this._browser;
@@ -174,6 +199,28 @@ export default class BrowserstackService {
                     if (BrowserstackCLI.getInstance().isRunning()) {
                         await BrowserstackCLI.getInstance().getAutomationFramework().trackEvent(AutomationFrameworkState.CREATE, HookState.POST, { browser: this._browser, hubUrl: this._config.hostname });
                         this._insightsHandler.setGitConfigPath();
+                        /**
+                         * SDK-6277: register the command/result listeners in the CLI/binary flow too,
+                         * so the user's saveScreenshot()/takeScreenshot() command result is captured and
+                         * forwarded for screenshot-on-failure. Without this the screenshot is dropped in v8.
+                         * (browserCommand routes the screenshot over gRPC in CLI mode — see insights-handler.)
+                         */
+                        // 'client:beforeCommand' only records the command synchronously — no await needed.
+                        this._browser.on('command', (command) => {
+                            if (shouldProcessEventForTesthub('')) {
+                                this._insightsHandler?.browserCommand('client:beforeCommand', Object.assign(command, { sessionId }), this._currentTest);
+                            }
+                        });
+                        this._browser.on('result', (result) => {
+                            if (shouldProcessEventForTesthub('')) {
+                                // 'client:afterCommand' is async in CLI mode (forwards the screenshot to the
+                                // binary over gRPC). Handle the returned promise so a failed upload is logged
+                                // rather than dropped. (o11yClassErrorHandler also routes method errors to
+                                // processError; this .catch makes the call-site handling explicit.)
+                                this._insightsHandler?.browserCommand('client:afterCommand', Object.assign(result, { sessionId }), this._currentTest)?.catch((err) => BStackLogger.debug(`Error forwarding afterCommand in CLI mode: ${err}`));
+                            }
+                        });
+                        PerformanceTester.end(PERFORMANCE_SDK_EVENTS.DRIVER_EVENT.PRE_INITIALIZE);
                         return;
                     }
                     await this._insightsHandler.before();
@@ -212,7 +259,11 @@ export default class BrowserstackService {
                 }
             }
         }
-        return await this._printSessionURL();
+        PerformanceTester.end(PERFORMANCE_SDK_EVENTS.DRIVER_EVENT.PRE_INITIALIZE);
+        PerformanceTester.start(PERFORMANCE_SDK_EVENTS.DRIVER_EVENT.POST_INITIALIZE);
+        const result = await this._printSessionURL();
+        PerformanceTester.end(PERFORMANCE_SDK_EVENTS.DRIVER_EVENT.POST_INITIALIZE);
+        return result;
     }
     /**
      * Set the default job name at the suite level to make sure we account
@@ -295,6 +346,7 @@ export default class BrowserstackService {
     }
     async after(result) {
         PerformanceTester.start(PERFORMANCE_SDK_EVENTS.HOOK_EVENTS.AFTER);
+        PerformanceTester.start(PERFORMANCE_SDK_EVENTS.DRIVER_EVENT.QUIT);
         try {
             if (BrowserstackCLI.getInstance().isRunning()) {
                 await BrowserstackCLI.getInstance().getAutomationFramework().trackEvent(AutomationFrameworkState.EXECUTE, HookState.POST, {});
@@ -362,12 +414,31 @@ export default class BrowserstackService {
                     });
                 }
             })();
+            // Track Listener cleanup
+            PerformanceTester.start(EVENTS.SDK_LISTENER_WORKER_END);
             await Listener.getInstance().onWorkerEnd();
+            PerformanceTester.end(EVENTS.SDK_LISTENER_WORKER_END, true);
+            // Track Percy teardown (only if CLI is not running)
             if (!BrowserstackCLI.getInstance().isRunning()) {
-                await this._percyHandler?.teardown();
+                PerformanceTester.start(EVENTS.SDK_PERCY_TEARDOWN);
+                try {
+                    await this._percyHandler?.teardown();
+                    PerformanceTester.end(EVENTS.SDK_PERCY_TEARDOWN, true);
+                }
+                catch (error) {
+                    PerformanceTester.end(EVENTS.SDK_PERCY_TEARDOWN, false, util.format(error));
+                }
             }
+            // Track worker data save
+            PerformanceTester.start(EVENTS.SDK_WORKER_SAVE_DATA);
             this.saveWorkerData();
+            PerformanceTester.end(EVENTS.SDK_WORKER_SAVE_DATA, true);
+            PerformanceTester.end(PERFORMANCE_SDK_EVENTS.DRIVER_EVENT.QUIT);
             PerformanceTester.end(PERFORMANCE_SDK_EVENTS.HOOK_EVENTS.AFTER);
+            // Give the performance observer time to process the last few events
+            // before disconnecting in stopAndGenerate()
+            // await new Promise(resolve => setTimeout(resolve, 100))
+            // Track performance report generation (this is the big operation!)
             await PerformanceTester.stopAndGenerate('performance-service.html');
             if (process.env[PERF_MEASUREMENT_ENV]) {
                 PerformanceTester.calculateTimes([
@@ -387,6 +458,7 @@ export default class BrowserstackService {
         }
         catch (error) {
             BStackLogger.error(`Error in after hook: ${error}`);
+            PerformanceTester.end(PERFORMANCE_SDK_EVENTS.DRIVER_EVENT.QUIT, false, util.format(error));
             PerformanceTester.end(PERFORMANCE_SDK_EVENTS.HOOK_EVENTS.AFTER, false, util.format(error));
             await PerformanceTester.stopAndGenerate('performance-service.html');
         }

package/build/testorchestration/apply-orchestration.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Applies test orchestration to the WebdriverIO test run
+ * This function is the main entry point for the orchestration integration
+ */
+export declare function applyOrchestrationIfEnabled(specs: string[], config: Record<string, any>): Promise<string[]>;
+export default applyOrchestrationIfEnabled;
+//# sourceMappingURL=apply-orchestration.d.ts.map

package/build/testorchestration/apply-orchestration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"apply-orchestration.d.ts","sourceRoot":"","sources":["../../src/testorchestration/apply-orchestration.ts"],"names":[],"mappings":"AAIA;;;GAGG;AACH,wBAAsB,2BAA2B,CAC7C,KAAK,EAAE,MAAM,EAAE,EACf,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAC5B,OAAO,CAAC,MAAM,EAAE,CAAC,CA4CnB;AAED,eAAe,2BAA2B,CAAA"}

package/build/testorchestration/apply-orchestration.js

@@ -0,0 +1,42 @@
+import { performance } from 'node:perf_hooks';
+import { TestOrchestrationHandler } from './testorcherstrationhandler.js';
+import { BStackLogger } from '../bstackLogger.js';
+import { isValidEnabledValue } from '../util.js';
+/**
+ * Applies test orchestration to the WebdriverIO test run
+ * This function is the main entry point for the orchestration integration
+ */
+export async function applyOrchestrationIfEnabled(specs, config) {
+    // Initialize orchestration handler
+    const orchestrationHandler = TestOrchestrationHandler.getInstance(config);
+    if (!orchestrationHandler) {
+        BStackLogger.debug('Orchestration handler is not initialized. Skipping orchestration.');
+        return specs;
+    }
+    // Check if runSmartSelection is enabled in config
+    const runSmartSelectionEnabled = isValidEnabledValue(config?.testOrchestrationOptions?.runSmartSelection?.enabled);
+    if (!runSmartSelectionEnabled) {
+        BStackLogger.info('runSmartSelection is not enabled in config. Skipping orchestration.');
+        return specs;
+    }
+    const startTime = performance.now();
+    // if (orchestrationHandler.testOrderingEnabled()) {
+    BStackLogger.info('Test orchestration is enabled. Attempting to reorder test files.');
+    // Get the test files from the specs - pass them as received
+    const testFiles = specs;
+    BStackLogger.info(`Test files to be reordered: ${testFiles.join(', ')}`);
+    // Reorder the test files
+    const orderedFiles = await orchestrationHandler.reorderTestFiles(testFiles);
+    if (orderedFiles && orderedFiles.length > 0) {
+        BStackLogger.info(`Tests reordered using orchestration: ${orderedFiles.join(', ')}`);
+        // Return the ordered files as the new specs
+        orchestrationHandler.addToOrderingInstrumentationData('timeTakenToApply', Math.floor(performance.now() - startTime) // Time in milliseconds
+        );
+        return orderedFiles;
+    }
+    BStackLogger.info('No test files were reordered by orchestration.');
+    orchestrationHandler.addToOrderingInstrumentationData('timeTakenToApply', Math.floor(performance.now() - startTime) // Time in milliseconds
+    );
+    return specs;
+}
+export default applyOrchestrationIfEnabled;

package/build/testorchestration/helpers.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Get host information for the test orchestration
+ */
+export declare function getHostInfo(): {
+    hostname: string;
+    platform: NodeJS.Platform;
+    architecture: NodeJS.Architecture;
+    release: string;
+    username: string;
+};
+/**
+ * Get git metadata
+ */
+export declare function getGitMetadata(): Record<string, any>;
+/**
+ * Get Git metadata for AI selection
+ * @param multiRepoSource Array of repository paths for multi-repo setup
+ */
+export declare function getGitMetadataForAISelection(folders?: string[]): any[];
+//# sourceMappingURL=helpers.d.ts.map

package/build/testorchestration/helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../src/testorchestration/helpers.ts"],"names":[],"mappings":"AAUA;;GAEG;AACH,wBAAgB,WAAW;;;;;;EAQ1B;AA0ED;;GAEG;AACH,wBAAgB,cAAc,IAAI,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAyFpD;AA8FD;;;GAGG;AACH,wBAAgB,4BAA4B,CAAC,OAAO,GAAE,MAAM,EAAO,GAAG,GAAG,EAAE,CA4K1E"}

package/build/testorchestration/helpers.js

@@ -0,0 +1,412 @@
+import os from 'node:os';
+import path from 'node:path';
+import { execSync } from 'node:child_process';
+import logger from '@wdio/logger';
+const log = logger('wdio-browserstack-service:helpers');
+// Constants
+const MAX_GIT_META_DATA_SIZE_IN_BYTES = 512 * 1024; // 512 KB
+/**
+ * Get host information for the test orchestration
+ */
+export function getHostInfo() {
+    return {
+        hostname: os.hostname(),
+        platform: process.platform,
+        architecture: process.arch,
+        release: os.release(),
+        username: os.userInfo().username
+    };
+}
+/**
+ * Format git author information
+ */
+function gitAuthor(name, email) {
+    if (!name && !email) {
+        return '';
+    }
+    return `${name} (${email})`;
+}
+/**
+ * Get the size of a JSON object in bytes
+ */
+function getSizeOfJsonObjectInBytes(obj) {
+    try {
+        const jsonString = JSON.stringify(obj);
+        return Buffer.byteLength(jsonString, 'utf8');
+    }
+    catch (e) {
+        log.error(`Error calculating object size: ${e}`);
+        return 0;
+    }
+}
+/**
+ * Truncate a string to reduce its size by the specified number of bytes
+ */
+function truncateString(str, bytesToTruncate) {
+    if (!str || bytesToTruncate <= 0) {
+        return str;
+    }
+    const originalBytes = Buffer.byteLength(str, 'utf8');
+    const targetBytes = Math.max(0, originalBytes - bytesToTruncate);
+    if (targetBytes >= originalBytes) {
+        return str;
+    }
+    // Perform binary search to find the right truncation point
+    let left = 0;
+    let right = str.length;
+    while (left < right) {
+        const mid = Math.floor((left + right) / 2);
+        const truncated = str.substring(0, mid);
+        const bytes = Buffer.byteLength(truncated, 'utf8');
+        if (bytes <= targetBytes) {
+            left = mid + 1;
+        }
+        else {
+            right = mid;
+        }
+    }
+    return str.substring(0, left - 1) + '...';
+}
+/**
+ * Check and truncate VCS info if needed
+ */
+function checkAndTruncateVcsInfo(gitMetaData) {
+    const gitMetaDataSizeInBytes = getSizeOfJsonObjectInBytes(gitMetaData);
+    if (gitMetaDataSizeInBytes && gitMetaDataSizeInBytes > MAX_GIT_META_DATA_SIZE_IN_BYTES) {
+        const truncateSize = gitMetaDataSizeInBytes - MAX_GIT_META_DATA_SIZE_IN_BYTES;
+        const truncatedCommitMessage = truncateString(gitMetaData.commit_message, truncateSize);
+        gitMetaData.commit_message = truncatedCommitMessage;
+        log.info(`The commit has been truncated. Size of commit after truncation is ${getSizeOfJsonObjectInBytes(gitMetaData) / 1024} KB`);
+    }
+    return gitMetaData;
+}
+/**
+ * Get git metadata
+ */
+export function getGitMetadata() {
+    try {
+        // Find git repo root
+        const rootOutput = execSync('git rev-parse --show-toplevel').toString().trim();
+        const commonDirOutput = execSync('git rev-parse --git-common-dir').toString().trim();
+        // Get basic git info
+        const sha = execSync('git rev-parse HEAD').toString().trim();
+        const shortSha = execSync('git rev-parse --short HEAD').toString().trim();
+        const branch = execSync('git rev-parse --abbrev-ref HEAD').toString().trim();
+        let tag = '';
+        try {
+            tag = execSync('git describe --all --tags --exact-match').toString().trim();
+        }
+        catch (e) {
+            // Tag might not exist
+        }
+        // Get commit info
+        const commitAuthorName = execSync('git log -1 --pretty=%an').toString().trim();
+        const commitAuthorEmail = execSync('git log -1 --pretty=%ae').toString().trim();
+        const commitAuthorDate = execSync('git log -1 --pretty=%aI').toString().trim();
+        const committerName = execSync('git log -1 --pretty=%cn').toString().trim();
+        const committerEmail = execSync('git log -1 --pretty=%ce').toString().trim();
+        const committerDate = execSync('git log -1 --pretty=%cI').toString().trim();
+        const commitMessage = execSync('git log -1 --pretty=%B').toString().trim();
+        // Get last tag and commits since
+        let lastTag = '';
+        let commitsSinceLastTag = '';
+        try {
+            lastTag = execSync('git describe --tags --abbrev=0 --always').toString().trim();
+            commitsSinceLastTag = execSync(`git rev-list ${sha}..${lastTag} --count`).toString().trim();
+        }
+        catch (e) {
+            // Last tag might not exist
+        }
+        // Get remotes
+        const remotesOutput = execSync('git remote -v').toString().trim();
+        const remoteLines = remotesOutput.split('\n');
+        const remotes = [];
+        const processedRemotes = new Set();
+        for (const line of remoteLines) {
+            const parts = line.split(/\s+/);
+            if (parts.length >= 2) {
+                const remoteName = parts[0];
+                const remoteUrl = parts[1];
+                // Only process each remote once (git remote -v shows fetch and push)
+                const key = `${remoteName}:${remoteUrl}`;
+                if (!processedRemotes.has(key)) {
+                    processedRemotes.add(key);
+                    remotes.push({
+                        name: remoteName,
+                        url: remoteUrl
+                    });
+                }
+            }
+        }
+        const info = {
+            sha,
+            short_sha: shortSha,
+            branch,
+            tag,
+            committer: gitAuthor(committerName, committerEmail),
+            committer_date: committerDate,
+            author: gitAuthor(commitAuthorName, commitAuthorEmail),
+            author_date: commitAuthorDate,
+            commit_message: commitMessage,
+            root: rootOutput,
+            common_git_dir: commonDirOutput,
+            worktree_git_dir: commonDirOutput,
+            last_tag: lastTag,
+            commits_since_last_tag: commitsSinceLastTag
+        };
+        const gitMetaData = {
+            name: 'git',
+            ...info,
+            remotes
+        };
+        return checkAndTruncateVcsInfo(gitMetaData);
+    }
+    catch (e) {
+        log.error(`Error getting git metadata: ${e}`);
+        return {};
+    }
+}
+/**
+ * Check if a git metadata result is valid
+ */
+function isValidGitResult(result) {
+    return (Array.isArray(result.filesChanged) &&
+        result.filesChanged.length > 0 &&
+        Array.isArray(result.authors) &&
+        result.authors.length > 0);
+}
+/**
+ * Get base branch from repository
+ */
+function getBaseBranch() {
+    try {
+        // Try to get the default branch from origin/HEAD symbolic ref (works for most providers)
+        try {
+            const originHeadOutput = execSync('git symbolic-ref refs/remotes/origin/HEAD').toString().trim();
+            if (originHeadOutput.startsWith('refs/remotes/origin/')) {
+                return originHeadOutput.replace('refs/remotes/', '');
+            }
+        }
+        catch (e) {
+            // Symbolic ref might not exist
+        }
+        // Fallback: use the first branch in local heads
+        try {
+            const branchesOutput = execSync('git branch').toString().trim();
+            const branches = branchesOutput.split('\n').filter(Boolean);
+            if (branches.length > 0) {
+                // Remove the '* ' from current branch if present and return first branch
+                const firstBranch = branches[0].replace(/^\*\s+/, '').trim();
+                return firstBranch;
+            }
+        }
+        catch (e) {
+            // Branches might not exist
+        }
+        // Fallback: use the first remote branch if available
+        try {
+            const remoteBranchesOutput = execSync('git branch -r').toString().trim();
+            const remoteBranches = remoteBranchesOutput.split('\n').filter(Boolean);
+            for (const branch of remoteBranches) {
+                const cleanBranch = branch.trim();
+                if (cleanBranch.startsWith('origin/') && !cleanBranch.includes('HEAD')) {
+                    return cleanBranch;
+                }
+            }
+        }
+        catch (e) {
+            // Remote branches might not exist
+        }
+    }
+    catch (e) {
+        log.debug(`Error finding base branch: ${e}`);
+    }
+    return null;
+}
+/**
+ * Get changed files from commits
+ */
+function getChangedFilesFromCommits(commitHashes) {
+    const changedFiles = new Set();
+    try {
+        for (const commit of commitHashes) {
+            try {
+                // Check if commit has parents
+                const parentsOutput = execSync(`git log -1 --pretty=%P ${commit}`).toString().trim();
+                const parents = parentsOutput.split(' ').filter(Boolean);
+                for (const parent of parents) {
+                    const diffOutput = execSync(`git diff --name-only ${parent} ${commit}`).toString().trim();
+                    const files = diffOutput.split('\n').filter(Boolean);
+                    for (const file of files) {
+                        changedFiles.add(file);
+                    }
+                }
+            }
+            catch (e) {
+                log.debug(`Error processing commit ${commit}: ${e}`);
+            }
+        }
+    }
+    catch (e) {
+        log.debug(`Error getting changed files from commits: ${e}`);
+    }
+    return Array.from(changedFiles);
+}
+/**
+ * Get Git metadata for AI selection
+ * @param multiRepoSource Array of repository paths for multi-repo setup
+ */
+export function getGitMetadataForAISelection(folders = []) {
+    if (folders && folders.length === 0) {
+        return [];
+    }
+    if (folders === null) {
+        folders = [process.cwd()];
+    }
+    // Deduplicate folders to avoid calculating PR diff multiple times for the same source
+    // Normalize paths using path.resolve to handle relative paths, trailing slashes, etc.
+    const uniqueFolders = [...new Set(folders.map(f => path.resolve(f)))];
+    log.debug(`Processing ${uniqueFolders.length} unique folders out of ${folders.length} total`);
+    const results = [];
+    for (const folder of uniqueFolders) {
+        const originalDir = process.cwd();
+        try {
+            // Initialize the result structure
+            const result = {
+                prId: '',
+                filesChanged: [],
+                authors: [],
+                prDate: '',
+                commitMessages: [],
+                prTitle: '',
+                prDescription: '',
+                prRawDiff: ''
+            };
+            // Change directory to the folder
+            process.chdir(folder);
+            // Get current branch and latest commit
+            const currentBranch = execSync('git rev-parse --abbrev-ref HEAD').toString().trim();
+            const latestCommit = execSync('git rev-parse HEAD').toString().trim();
+            result.prId = latestCommit;
+            // Find base branch
+            const baseBranch = getBaseBranch();
+            log.debug(`Base branch for comparison: ${baseBranch}`);
+            let commits = [];
+            if (baseBranch) {
+                try {
+                    // Get changed files between base branch and current branch
+                    const changedFilesOutput = execSync(`git diff --name-only ${baseBranch}..${currentBranch}`).toString().trim();
+                    log.debug(`Changed files between ${baseBranch} and ${currentBranch}: ${changedFilesOutput}`);
+                    result.filesChanged = changedFilesOutput.split('\n').filter(f => f.trim());
+                    // Get commits between base branch and current branch
+                    const commitsOutput = execSync(`git log ${baseBranch}..${currentBranch} --pretty=%H`).toString().trim();
+                    commits = commitsOutput.split('\n').filter(Boolean);
+                }
+                catch (e) {
+                    log.debug('Failed to get changed files from branch comparison. Falling back to recent commits.');
+                    // Fallback to recent commits
+                    const recentCommitsOutput = execSync('git log -10 --pretty=%H').toString().trim();
+                    commits = recentCommitsOutput.split('\n').filter(Boolean);
+                    if (commits.length > 0) {
+                        result.filesChanged = getChangedFilesFromCommits(commits.slice(0, 5));
+                    }
+                }
+            }
+            else {
+                // Fallback to recent commits
+                const recentCommitsOutput = execSync('git log -10 --pretty=%H').toString().trim();
+                commits = recentCommitsOutput.split('\n').filter(Boolean);
+                if (commits.length > 0) {
+                    result.filesChanged = getChangedFilesFromCommits(commits.slice(0, 5));
+                }
+            }
+            // Process commit authors and messages
+            const authorsSet = new Set();
+            const commitMessages = [];
+            // Only process commits if we have them
+            if (commits.length > 0) {
+                for (const commit of commits) {
+                    try {
+                        const commitMessage = execSync(`git log -1 --pretty=%B ${commit}`).toString().trim();
+                        log.debug(`Processing commit: ${commitMessage}`);
+                        const authorName = execSync(`git log -1 --pretty=%an ${commit}`).toString().trim();
+                        authorsSet.add(authorName || 'Unknown');
+                        commitMessages.push({
+                            message: commitMessage.trim(),
+                            user: authorName || 'Unknown'
+                        });
+                    }
+                    catch (e) {
+                        log.debug(`Error processing commit ${commit}: ${e}`);
+                    }
+                }
+            }
+            // If we have no commits but have changed files, add a fallback author
+            if (commits.length === 0 && result.filesChanged.length > 0) {
+                try {
+                    // Try to get current git user as fallback
+                    const fallbackAuthor = execSync('git config user.name').toString().trim() || 'Unknown';
+                    authorsSet.add(fallbackAuthor);
+                    log.debug(`Added fallback author: ${fallbackAuthor}`);
+                }
+                catch (e) {
+                    authorsSet.add('Unknown');
+                    log.debug('Added Unknown as fallback author');
+                }
+            }
+            result.authors = Array.from(authorsSet);
+            result.commitMessages = commitMessages;
+            // Get commit date
+            if (latestCommit) {
+                const commitDate = execSync(`git log -1 --pretty=%cd --date=format:'%Y-%m-%d' ${latestCommit}`).toString().trim();
+                result.prDate = commitDate.replace(/'/g, '');
+            }
+            // Set PR title and description from latest commit if not already set
+            if ((!result.prTitle || result.prTitle.trim() === '') && latestCommit) {
+                try {
+                    const latestCommitMessage = execSync(`git log -1 --pretty=%B ${latestCommit}`).toString().trim();
+                    const messageLines = latestCommitMessage.trim().split('\n');
+                    result.prTitle = messageLines[0] || '';
+                    if (messageLines.length > 2) {
+                        result.prDescription = messageLines.slice(2).join('\n').trim();
+                    }
+                }
+                catch (e) {
+                    log.debug(`Error extracting commit message for PR title: ${e}`);
+                }
+            }
+            // Reset directory
+            process.chdir(originalDir);
+            results.push(result);
+        }
+        catch (e) {
+            log.error(`Exception in populating Git metadata for AI selection (folder: ${folder}): ${e}`);
+            // Reset directory if needed
+            try {
+                process.chdir(originalDir);
+            }
+            catch (dirError) {
+                log.error(`Error resetting directory: ${dirError}`);
+            }
+        }
+    }
+    // Filter out results with empty filesChanged
+    const filteredResults = results.filter(isValidGitResult);
+    // Map to required output format
+    const formattedResults = filteredResults.map((result) => ({
+        prId: result.prId || '',
+        filesChanged: Array.isArray(result.filesChanged) ? result.filesChanged : [],
+        authors: Array.isArray(result.authors) ? result.authors : [],
+        prDate: result.prDate || '',
+        commitMessages: Array.isArray(result.commitMessages)
+            ? result.commitMessages.map((cm) => ({
+                message: cm.message || '',
+                user: cm.user || ''
+            }))
+            : [],
+        prTitle: result.prTitle || '',
+        prDescription: result.prDescription || '',
+        prRawDiff: result.prRawDiff || ''
+    }));
+    return formattedResults;
+}