phantomx-tool-client 1.1.5 → 2.1.0

package/dist/githubOperationsHanlder.js

@@ -64,19 +64,6 @@ function executeShell(command) {
         });
     });
 }
-// ---------------------------------------------------------------------------
-// Per-repo async mutex — serialises all git remote set-url operations so that
-// concurrent tool calls never race on .git/config.lock for the same repo.
-// ---------------------------------------------------------------------------
-const repoLocks = new Map();
-function withRepoLock(repoName, fn) {
-    var _a;
-    const prev = (_a = repoLocks.get(repoName)) !== null && _a !== void 0 ? _a : Promise.resolve();
-    let releaseLock;
-    const lockAcquired = new Promise(res => { releaseLock = res; });
-    repoLocks.set(repoName, prev.then(() => lockAcquired));
-    return prev.then(() => fn()).finally(() => releaseLock());
-}
 // Use the official 'octokit' package import via require to avoid missing types for '@octokit/rest'
 const { Octokit } = require('octokit');
 const logger = (0, Logger_1.createLogger)('GithubOperationsService');
@@ -610,26 +597,25 @@ class GithubOperationsService {
         const repoPath = `${tool_server_1.folderPath}/${repoName}`;
         const installationToken = await fetchInstallationToken();
         const gitOrgName = await getGithubOrganizationName();
-        return withRepoLock(repoName, async () => {
-            try {
-                logger.info('Getting repository origin/default branch', { repoName });
-                // Set token URL, query origin, restore URL — single pipeline to prevent lock races.
-                const result = await executeShell(`cd ${repoPath} && rm -f .git/config.lock && ` +
-                    `git remote set-url origin https://x-access-token:${installationToken}@github.com/${gitOrgName}/${repoName}.git && ` +
-                    `sudo git remote show origin | grep 'HEAD branch' | awk '{print $NF}' && ` +
-                    `git remote set-url origin https://github.com/${gitOrgName}/${repoName}.git`);
-                if (!result.success || !result.output.trim()) {
-                    throw new Error(`Failed to get origin branch for repo '${repoName}': ${result.error || result.output}`);
-                }
-                const originBranch = result.output.trim();
-                logger.success('Repository origin branch retrieved', { repoName, originBranch });
-                return {
-                    repoName,
-                    originBranch
-                };
-            }
-            finally { }
-        }); // end withRepoLock
+        try {
+            logger.info('Getting repository origin/default branch', { repoName });
+            // Set authenticated remote URL
+            await executeShell(`cd ${repoPath} && sudo git remote set-url origin https://x-access-token:${installationToken}@github.com/${gitOrgName}/${repoName}.git`);
+            // Fetch remote HEAD to find the default branch
+            const result = await executeShell(`cd ${repoPath} && sudo git remote show origin | grep 'HEAD branch' | awk '{print $NF}'`);
+            // Restore unauthenticated remote URL
+            await executeShell(`cd ${repoPath} && sudo git remote set-url origin https://github.com/${gitOrgName}/${repoName}.git`);
+            if (!result.success || !result.output.trim()) {
+                throw new Error(`Failed to get origin branch for repo '${repoName}': ${result.error || result.output}`);
+            }
+            const originBranch = result.output.trim();
+            logger.success('Repository origin branch retrieved', { repoName, originBranch });
+            return {
+                repoName,
+                originBranch
+            };
+        }
+        finally { }
     }
     /**
      * List branches for a repository
@@ -650,38 +636,40 @@ class GithubOperationsService {
         const repoPath = `${tool_server_1.folderPath}/${repoName}`;
         const installationToken = await fetchInstallationToken();
         const gitOrgName = await getGithubOrganizationName();
-        return withRepoLock(repoName, async () => {
-            try {
-                // Get current local branch name
-                let result = await executeShell(`cd ${repoPath} && sudo git rev-parse --abbrev-ref HEAD`);
-                if (!result.success) {
-                    throw new Error(`Failed to get current branch: ${result.error}`);
-                }
-                const currentBranch = result.output.trim();
-                logger.info('starting git pull operation', { repoName, currentBranch });
-                // Token-URL, fetch, pull, restore URL — all in one pipeline to prevent
-                // concurrent operations from racing on .git/config.lock.
-                result = await executeShell(`cd ${repoPath} && rm -f .git/config.lock && ` +
-                    `git remote set-url origin https://x-access-token:${installationToken}@github.com/${gitOrgName}/${repoName}.git && ` +
-                    `sudo git fetch origin && ` +
-                    `sudo git pull --no-rebase origin ${currentBranch} ; ` +
-                    `git remote set-url origin https://github.com/${gitOrgName}/${repoName}.git`);
-                if (!result.success && result.code !== 128) {
-                    throw new Error(`Failed to pull branch ${currentBranch}: ${result.error}`);
-                }
-                logger.success('Git pull completed successfully', { repoName, currentBranch });
-                // Get merge conflicts
-                const mergeConflicts = await this.getMergeConflicts(repoName);
-                return {
-                    repoName,
-                    branchName: currentBranch,
-                    lastCommit: result.output.trim(),
-                    mergeConflicts
-                };
+        try {
+            // Get current local branch name
+            let result = await executeShell(`cd ${repoPath} && sudo git rev-parse --abbrev-ref HEAD`);
+            if (!result.success) {
+                throw new Error(`Failed to get current branch: ${result.error}`);
             }
-            finally {
+            const currentBranch = result.output.trim();
+            logger.info('starting git pull operation', { repoName, currentBranch });
+            // Set remote url with token
+            result = await executeShell(`cd ${repoPath} && sudo git remote set-url origin https://x-access-token:${installationToken}@github.com/${gitOrgName}/${repoName}.git`);
+            if (!result.success) {
+                throw new Error(`Failed to set remote URL: ${result.error}`);
             }
-        }); // end withRepoLock
+            result = await executeShell(`cd ${repoPath} && sudo git fetch origin`);
+            if (!result.success) {
+                throw new Error(`Failed to fetch from remote: ${result.error}`);
+            }
+            result = await executeShell(`cd ${repoPath} && sudo git pull --no-rebase origin ${currentBranch}`);
+            if (!result.success && result.code !== 128) {
+                throw new Error(`Failed to pull branch ${currentBranch}: ${result.error}`);
+            }
+            await executeShell(`cd ${repoPath} && sudo git remote set-url origin https://github.com/${gitOrgName}/${repoName}.git`);
+            logger.success('Git pull completed successfully', { repoName, currentBranch });
+            // Get merge conflicts
+            const mergeConflicts = await this.getMergeConflicts(socket, repoName);
+            return {
+                repoName,
+                branchName: currentBranch,
+                lastCommit: result.output.trim(),
+                mergeConflicts
+            };
+        }
+        finally {
+        }
     }
     /**
      * Push repository to remote
@@ -690,58 +678,55 @@ class GithubOperationsService {
         const repoPath = `${tool_server_1.folderPath}/${repoName}`;
         const installationToken = await fetchInstallationToken();
         const gitOrgName = await getGithubOrganizationName();
-        return withRepoLock(repoName, async () => {
-            try {
-                logger.info('Starting git push operation', { repoName });
-                // Combine all commands into a single SSH call
-                const combinedCommand = `
+        try {
+            logger.info('Starting git push operation', { repoName });
+            // Combine all commands into a single SSH call
+            const combinedCommand = `
                 cd ${repoPath} &&
-                rm -f .git/config.lock &&
                 BRANCH=$(sudo git rev-parse --abbrev-ref HEAD) &&
                 COMMITS_AHEAD=$(sudo git rev-list --count origin/$BRANCH..HEAD 2>/dev/null || echo 0) &&
                 if [ "$COMMITS_AHEAD" = "0" ]; then
                     echo "ERROR:NO_COMMITS";
                     exit 1;
                 fi &&
-                git remote set-url origin https://x-access-token:${installationToken}@github.com/${gitOrgName}/${repoName}.git &&
+                sudo git remote set-url origin https://x-access-token:${installationToken}@github.com/${gitOrgName}/${repoName}.git &&
                 sudo git push origin $BRANCH &&
-                git remote set-url origin https://github.com/${gitOrgName}/${repoName}.git &&
+                sudo git remote set-url origin https://github.com/${gitOrgName}/${repoName}.git &&
                 COMMIT_HASH=$(sudo git rev-parse HEAD) &&
                 echo "BRANCH:$BRANCH" &&
                 echo "COMMITS_AHEAD:$COMMITS_AHEAD" &&
                 echo "COMMIT_HASH:$COMMIT_HASH"
             `.replace(/\n\s+/g, ' ');
-                const result = await executeShell(combinedCommand);
-                if (!result.success) {
-                    if (result.output && result.output.includes('ERROR:NO_COMMITS')) {
-                        throw new Error('No commits to push');
-                    }
-                    throw new Error('Failed to push repository');
-                }
-                // Parse output
-                const output = result.output;
-                const branchMatch = output.match(/BRANCH:([^\n]+)/);
-                const commitsAheadMatch = output.match(/COMMITS_AHEAD:(\d+)/);
-                const commitHashMatch = output.match(/COMMIT_HASH:([a-f0-9]+)/);
-                const currentBranch = branchMatch ? branchMatch[1].trim() : 'unknown';
-                const commitsAhead = commitsAheadMatch ? parseInt(commitsAheadMatch[1]) : 0;
-                const commitHash = commitHashMatch ? commitHashMatch[1].trim() : 'unknown';
-                logger.success('Git push completed successfully', { repoName, currentBranch, commitHash, commitsAhead });
-                // Emit socket event to refresh repo on client (only when called by AI agent)
-                if (socket) {
-                    socket.emit('refresh_repo', { repoName });
+            const result = await executeShell(combinedCommand);
+            if (!result.success) {
+                if (result.output && result.output.includes('ERROR:NO_COMMITS')) {
+                    throw new Error('No commits to push');
                 }
-                return {
-                    repoName,
-                    branchName: currentBranch,
-                    commitHash,
-                    commitsAhead,
-                    pushedAt: new Date().toISOString()
-                };
+                throw new Error('Failed to push repository');
             }
-            finally {
+            // Parse output
+            const output = result.output;
+            const branchMatch = output.match(/BRANCH:([^\n]+)/);
+            const commitsAheadMatch = output.match(/COMMITS_AHEAD:(\d+)/);
+            const commitHashMatch = output.match(/COMMIT_HASH:([a-f0-9]+)/);
+            const currentBranch = branchMatch ? branchMatch[1].trim() : 'unknown';
+            const commitsAhead = commitsAheadMatch ? parseInt(commitsAheadMatch[1]) : 0;
+            const commitHash = commitHashMatch ? commitHashMatch[1].trim() : 'unknown';
+            logger.success('Git push completed successfully', { repoName, currentBranch, commitHash, commitsAhead });
+            // Emit socket event to refresh repo on client (only when called by AI agent)
+            if (socket) {
+                socket.emit('refresh_repo', { repoName });
             }
-        }); // end withRepoLock
+            return {
+                repoName,
+                branchName: currentBranch,
+                commitHash,
+                commitsAhead,
+                pushedAt: new Date().toISOString()
+            };
+        }
+        finally {
+        }
     }
     /**
      * Check repository status
@@ -750,24 +735,15 @@ class GithubOperationsService {
         const repoPath = `${tool_server_1.folderPath}/${repoName}`;
         const installationToken = await fetchInstallationToken();
         const gitOrgName = await getGithubOrganizationName();
-        // const repoPath = 'mnt/f/PhantomX-workspace/93943752-2576-44ee-9b57-4b6fb3130fe4/AI_CODER_REMOTE'
-        // const installationToken =  "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";
-        // const gitOrgName = "AI-PLAYGROUNDS";
-        return withRepoLock(repoName, async () => {
-            try {
-                logger.info('Checking repository status', { repoName });
-                // Combine all git commands into a single SSH call
-                // Remove any stale .git/config.lock before touching remote config
-                // (a crashed/interrupted previous run can leave this lock behind).
-                // Also avoid sudo for git remote set-url so the lock file is never
-                // created as root-owned, which would block subsequent cleanup.
-                const combinedCommand = `
+        try {
+            logger.info('Checking repository status', { repoName });
+            // Combine all git commands into a single SSH call
+            const combinedCommand = `
                 cd ${repoPath} &&
-                rm -f .git/config.lock &&
                 BRANCH=$(sudo git rev-parse --abbrev-ref HEAD) &&
-                git remote set-url origin https://x-access-token:${installationToken}@github.com/${gitOrgName}/${repoName}.git &&
+                sudo git remote set-url origin https://x-access-token:${installationToken}@github.com/${gitOrgName}/${repoName}.git &&
                 sudo git fetch origin &&
-                git remote set-url origin https://github.com/${gitOrgName}/${repoName}.git &&
+                sudo git remote set-url origin https://github.com/${gitOrgName}/${repoName}.git &&
                 BEHIND=$(sudo git rev-list --count HEAD..origin/$BRANCH 2>/dev/null || echo 0) &&
                 AHEAD=$(sudo git rev-list --count origin/$BRANCH..HEAD 2>/dev/null || echo 0) &&
                 STATUS=$(sudo git status --porcelain) &&
@@ -780,55 +756,54 @@ class GithubOperationsService {
                 echo "CURRENT:$CURRENT_HASH" &&
                 echo "REMOTE:$REMOTE_HASH"
             `.replace(/\n\s+/g, ' ');
-                const result = await executeShell(combinedCommand);
-                if (!result.success) {
-                    throw new Error('Failed to check repository status: ' + result.error);
-                }
-                // Parse the output
-                const output = result.output;
-                const branchMatch = output.match(/BRANCH:([^\n]+)/);
-                const behindMatch = output.match(/BEHIND:(\d+)/);
-                const aheadMatch = output.match(/AHEAD:(\d+)/);
-                const statusMatch = output.match(/STATUS:([\s\S]*?)(?=CURRENT:|$)/);
-                const currentMatch = output.match(/CURRENT:([a-f0-9]+)/);
-                const remoteMatch = output.match(/REMOTE:([a-f0-9]+|unknown)/);
-                const currentBranch = branchMatch ? branchMatch[1].trim() : 'unknown';
-                const commitsBehind = behindMatch ? parseInt(behindMatch[1]) : 0;
-                const commitsAhead = aheadMatch ? parseInt(aheadMatch[1]) : 0;
-                const statusOutput = statusMatch ? statusMatch[1].trim() : '';
-                const hasUncommittedChanges = statusOutput.length > 0;
-                const currentCommitHash = currentMatch ? currentMatch[1].trim() : 'unknown';
-                const remoteCommitHash = remoteMatch ? remoteMatch[1].trim() : 'unknown';
-                const isUpToDate = commitsBehind === 0 && commitsAhead === 0;
-                const needsPull = commitsBehind > 0;
-                const needsPush = commitsAhead > 0;
-                logger.info('Repository status checked', {
-                    repoName,
-                    commitsBehind,
-                    commitsAhead,
-                    hasUncommittedChanges,
-                    isUpToDate
-                });
-                // Check for merge conflicts
-                const mergeConflicts = await this.getMergeConflicts(repoName);
-                return {
-                    repoName,
-                    branchName: currentBranch,
-                    currentCommitHash,
-                    remoteCommitHash,
-                    commitsBehind,
-                    commitsAhead,
-                    hasUncommittedChanges,
-                    isUpToDate,
-                    needsPull,
-                    needsPush,
-                    mergeConflicts,
-                    status: isUpToDate ? 'up-to-date' : (needsPull && needsPush ? 'diverged' : needsPull ? 'behind' : 'ahead')
-                };
-            }
-            finally {
+            const result = await executeShell(combinedCommand);
+            if (!result.success) {
+                throw new Error('Failed to check repository status');
             }
-        }); // end withRepoLock
+            // Parse the output
+            const output = result.output;
+            const branchMatch = output.match(/BRANCH:([^\n]+)/);
+            const behindMatch = output.match(/BEHIND:(\d+)/);
+            const aheadMatch = output.match(/AHEAD:(\d+)/);
+            const statusMatch = output.match(/STATUS:([\s\S]*?)(?=CURRENT:|$)/);
+            const currentMatch = output.match(/CURRENT:([a-f0-9]+)/);
+            const remoteMatch = output.match(/REMOTE:([a-f0-9]+|unknown)/);
+            const currentBranch = branchMatch ? branchMatch[1].trim() : 'unknown';
+            const commitsBehind = behindMatch ? parseInt(behindMatch[1]) : 0;
+            const commitsAhead = aheadMatch ? parseInt(aheadMatch[1]) : 0;
+            const statusOutput = statusMatch ? statusMatch[1].trim() : '';
+            const hasUncommittedChanges = statusOutput.length > 0;
+            const currentCommitHash = currentMatch ? currentMatch[1].trim() : 'unknown';
+            const remoteCommitHash = remoteMatch ? remoteMatch[1].trim() : 'unknown';
+            const isUpToDate = commitsBehind === 0 && commitsAhead === 0;
+            const needsPull = commitsBehind > 0;
+            const needsPush = commitsAhead > 0;
+            logger.info('Repository status checked', {
+                repoName,
+                commitsBehind,
+                commitsAhead,
+                hasUncommittedChanges,
+                isUpToDate
+            });
+            // Check for merge conflicts
+            const mergeConflicts = await this.getMergeConflicts(socket, repoName);
+            return {
+                repoName,
+                branchName: currentBranch,
+                currentCommitHash,
+                remoteCommitHash,
+                commitsBehind,
+                commitsAhead,
+                hasUncommittedChanges,
+                isUpToDate,
+                needsPull,
+                needsPush,
+                mergeConflicts,
+                status: isUpToDate ? 'up-to-date' : (needsPull && needsPush ? 'diverged' : needsPull ? 'behind' : 'ahead')
+            };
+        }
+        finally {
+        }
     }
     /**
      * Get repository history
@@ -1074,186 +1049,183 @@ class GithubOperationsService {
         const repoPath = `${tool_server_1.folderPath}/${repoName}`;
         const installationToken = await fetchInstallationToken();
         const gitOrgName = await getGithubOrganizationName();
-        return withRepoLock(repoName, async () => {
-            try {
-                logger.info('Creating pull request', { repoName, targetBranch });
-                // Combine commands into a single SSH call, with remote URL set/unset
-                const combinedCommand = `
+        try {
+            logger.info('Creating pull request', { repoName, targetBranch });
+            // Combine commands into a single SSH call, with remote URL set/unset
+            const combinedCommand = `
                 cd ${repoPath} &&
-                rm -f .git/config.lock &&
-                git remote set-url origin https://x-access-token:${installationToken}@github.com/${gitOrgName}/${repoName}.git &&
+                sudo git remote set-url origin https://x-access-token:${installationToken}@github.com/${gitOrgName}/${repoName}.git &&
                 HEAD_BRANCH=$(sudo git rev-parse --abbrev-ref HEAD) &&
                 sudo git fetch origin ${targetBranch} 2>/dev/null &&
                 COMMITS_AHEAD=$(sudo git rev-list --count origin/${targetBranch}..$HEAD_BRANCH 2>/dev/null || echo 0) &&
                 if [ "$COMMITS_AHEAD" = "0" ]; then
                     echo "ERROR:NO_COMMITS:$HEAD_BRANCH";
-                    git remote set-url origin https://github.com/${gitOrgName}/${repoName}.git;
+                    sudo git remote set-url origin https://github.com/${gitOrgName}/${repoName}.git;
                     exit 1;
                 fi &&
                 echo "HEAD_BRANCH:$HEAD_BRANCH" &&
                 echo "COMMITS_AHEAD:$COMMITS_AHEAD" &&
-                git remote set-url origin https://github.com/${gitOrgName}/${repoName}.git
+                sudo git remote set-url origin https://github.com/${gitOrgName}/${repoName}.git
             `.replace(/\n\s+/g, ' ');
-                let result = await executeShell(combinedCommand);
-                const output = result.output || '';
-                const headBranchMatch = output.match(/HEAD_BRANCH:([^\n]+)/);
-                const commitsAheadMatch = output.match(/COMMITS_AHEAD:(\d+)/);
-                const errorMatch = output.match(/ERROR:NO_COMMITS:([^\n]+)/);
-                let headBranch = headBranchMatch ? headBranchMatch[1].trim() : 'unknown';
-                const commitsAhead = commitsAheadMatch ? parseInt(commitsAheadMatch[1]) : 0;
-                if (!result.success && errorMatch) {
-                    headBranch = errorMatch[1].trim();
-                }
-                // using 'octokit' package (already installed, @octokit/rest is not installed)
-                const { Octokit } = require('octokit');
-                const octokit = new Octokit({
-                    auth: installationToken
+            let result = await executeShell(combinedCommand);
+            const output = result.output || '';
+            const headBranchMatch = output.match(/HEAD_BRANCH:([^\n]+)/);
+            const commitsAheadMatch = output.match(/COMMITS_AHEAD:(\d+)/);
+            const errorMatch = output.match(/ERROR:NO_COMMITS:([^\n]+)/);
+            let headBranch = headBranchMatch ? headBranchMatch[1].trim() : 'unknown';
+            const commitsAhead = commitsAheadMatch ? parseInt(commitsAheadMatch[1]) : 0;
+            if (!result.success && errorMatch) {
+                headBranch = errorMatch[1].trim();
+            }
+            // using 'octokit' package (already installed, @octokit/rest is not installed)
+            const { Octokit } = require('octokit');
+            const octokit = new Octokit({
+                auth: installationToken
+            });
+            // Always check for existing PR first even if there are no new commits
+            try {
+                const existingPRs = await octokit.rest.pulls.list({
+                    owner: gitOrgName,
+                    repo: repoName,
+                    head: `${gitOrgName}:${headBranch}`,
+                    base: targetBranch,
+                    state: 'open'
                 });
-                // Always check for existing PR first even if there are no new commits
-                try {
-                    const existingPRs = await octokit.rest.pulls.list({
-                        owner: gitOrgName,
-                        repo: repoName,
-                        head: `${gitOrgName}:${headBranch}`,
-                        base: targetBranch,
-                        state: 'open'
-                    });
-                    if (existingPRs.data.length > 0) {
-                        const existingPR = existingPRs.data[0];
-                        logger.info('Pull request already exists', {
-                            repoName,
-                            prNumber: existingPR.number,
-                            prUrl: existingPR.html_url
-                        });
-                        const resultData = {
-                            repoName,
-                            headBranch,
-                            targetBranch,
-                            prNumber: existingPR.number,
-                            prUrl: existingPR.html_url,
-                            prTitle: existingPR.title,
-                            commitsAhead,
-                            createdAt: existingPR.created_at,
-                            alreadyExists: true
-                        };
-                        // Emit socket event to refresh PR status on client
-                        if (socket) {
-                            socket.emit('refresh_pr_status', { repoName, prNumber: existingPR.number });
-                        }
-                        // the socket server our main server will automatically update the pr metadata in db when i recvs the result of the given tool.
-                        //   this.updatePRMetadata(userId, resultData);
-                        return resultData;
-                    }
-                }
-                catch (fetchError) {
-                    logger.error('Failed to check for existing PR', fetchError);
-                }
-                // No existing PR found - check if we have commits to create one
-                if (!result.success) {
-                    if (errorMatch) {
-                        throw new Error(`No commits to create PR. Branch '${headBranch}' is not ahead of '${targetBranch}'`);
-                    }
-                    throw new Error('Failed to prepare pull request');
-                }
-                // Create new PR
-                const prTitle = title || `Merge ${headBranch} into ${targetBranch}`;
-                const prBody = body || `This pull request merges changes from ${headBranch} into ${targetBranch}.\n\nCreated by AI-Playgrounds`;
-                try {
-                    const prResponse = await octokit.rest.pulls.create({
-                        owner: gitOrgName,
-                        repo: repoName,
-                        title: prTitle,
-                        body: prBody,
-                        head: headBranch,
-                        base: targetBranch
-                    });
-                    const prUrl = prResponse.data.html_url;
-                    const prNumber = prResponse.data.number;
-                    logger.success('Pull request created successfully', {
+                if (existingPRs.data.length > 0) {
+                    const existingPR = existingPRs.data[0];
+                    logger.info('Pull request already exists', {
                         repoName,
-                        prNumber,
-                        prUrl
+                        prNumber: existingPR.number,
+                        prUrl: existingPR.html_url
                     });
-                    // taskInfo.status = TaskStatus.Completed;
-                    // taskInfo.nonRunningSince = new Date();
-                    // //updating the task status in the db
-                    // let dbService = await getDBService();
-                    // let taskHanlder = dbService.getRepository<Task>(ds.UserInfo.get(userId as any)?.dbName, CollectionNames.TASKS);
-                    // taskHanlder.updateOne({
-                    //     taskId: taskId
-                    // },
-                    //     {
-                    //         "$set": {
-                    //             status: TaskStatus.Completed
-                    //         }
-                    //     });
                     const resultData = {
                         repoName,
                         headBranch,
                         targetBranch,
-                        prNumber,
-                        prUrl,
-                        prTitle,
+                        prNumber: existingPR.number,
+                        prUrl: existingPR.html_url,
+                        prTitle: existingPR.title,
                         commitsAhead,
-                        createdAt: new Date().toISOString()
+                        createdAt: existingPR.created_at,
+                        alreadyExists: true
                     };
-                    // // Emit socket event to refresh PR status on client
-                    // if (socket) {
-                    //     socket.emit('refresh_pr_status', { repoName, prNumber });
-                    // }
-                    // // Update database asynchronously (non-blocking)
-                    // this.updatePRMetadata(userId, resultData);
+                    // Emit socket event to refresh PR status on client
+                    if (socket) {
+                        socket.emit('refresh_pr_status', { repoName, prNumber: existingPR.number });
+                    }
+                    // the socket server our main server will automatically update the pr metadata in db when i recvs the result of the given tool.
+                    //   this.updatePRMetadata(userId, resultData);
                     return resultData;
                 }
-                catch (prError) {
-                    // Check if PR already exists
-                    if (prError.status === 422) {
-                        // Fetch existing PR
-                        try {
-                            const existingPRs = await octokit.rest.pulls.list({
-                                owner: gitOrgName,
-                                repo: repoName,
-                                head: `${gitOrgName}:${headBranch}`,
-                                base: targetBranch,
-                                state: 'open'
+            }
+            catch (fetchError) {
+                logger.error('Failed to check for existing PR', fetchError);
+            }
+            // No existing PR found - check if we have commits to create one
+            if (!result.success) {
+                if (errorMatch) {
+                    throw new Error(`No commits to create PR. Branch '${headBranch}' is not ahead of '${targetBranch}'`);
+                }
+                throw new Error('Failed to prepare pull request');
+            }
+            // Create new PR
+            const prTitle = title || `Merge ${headBranch} into ${targetBranch}`;
+            const prBody = body || `This pull request merges changes from ${headBranch} into ${targetBranch}.\n\nCreated by AI-Playgrounds`;
+            try {
+                const prResponse = await octokit.rest.pulls.create({
+                    owner: gitOrgName,
+                    repo: repoName,
+                    title: prTitle,
+                    body: prBody,
+                    head: headBranch,
+                    base: targetBranch
+                });
+                const prUrl = prResponse.data.html_url;
+                const prNumber = prResponse.data.number;
+                logger.success('Pull request created successfully', {
+                    repoName,
+                    prNumber,
+                    prUrl
+                });
+                // taskInfo.status = TaskStatus.Completed;
+                // taskInfo.nonRunningSince = new Date();
+                // //updating the task status in the db
+                // let dbService = await getDBService();
+                // let taskHanlder = dbService.getRepository<Task>(ds.UserInfo.get(userId as any)?.dbName, CollectionNames.TASKS);
+                // taskHanlder.updateOne({
+                //     taskId: taskId
+                // },
+                //     {
+                //         "$set": {
+                //             status: TaskStatus.Completed
+                //         }
+                //     });
+                const resultData = {
+                    repoName,
+                    headBranch,
+                    targetBranch,
+                    prNumber,
+                    prUrl,
+                    prTitle,
+                    commitsAhead,
+                    createdAt: new Date().toISOString()
+                };
+                // // Emit socket event to refresh PR status on client
+                // if (socket) {
+                //     socket.emit('refresh_pr_status', { repoName, prNumber });
+                // }
+                // // Update database asynchronously (non-blocking)
+                // this.updatePRMetadata(userId, resultData);
+                return resultData;
+            }
+            catch (prError) {
+                // Check if PR already exists
+                if (prError.status === 422) {
+                    // Fetch existing PR
+                    try {
+                        const existingPRs = await octokit.rest.pulls.list({
+                            owner: gitOrgName,
+                            repo: repoName,
+                            head: `${gitOrgName}:${headBranch}`,
+                            base: targetBranch,
+                            state: 'open'
+                        });
+                        if (existingPRs.data.length > 0) {
+                            const existingPR = existingPRs.data[0];
+                            logger.info('Pull request already exists', {
+                                repoName,
+                                prNumber: existingPR.number,
+                                prUrl: existingPR.html_url
                             });
-                            if (existingPRs.data.length > 0) {
-                                const existingPR = existingPRs.data[0];
-                                logger.info('Pull request already exists', {
-                                    repoName,
-                                    prNumber: existingPR.number,
-                                    prUrl: existingPR.html_url
-                                });
-                                const resultData = {
-                                    repoName,
-                                    headBranch,
-                                    targetBranch,
-                                    prNumber: existingPR.number,
-                                    prUrl: existingPR.html_url,
-                                    prTitle: existingPR.title,
-                                    commitsAhead,
-                                    createdAt: existingPR.created_at,
-                                    alreadyExists: true
-                                };
-                                // Emit socket event to refresh PR status on client
-                                if (socket) {
-                                    socket.emit('refresh_pr_status', { repoName, prNumber: existingPR.number });
-                                }
-                                // Update database asynchronously (non-blocking)
-                                //   this.updatePRMetadata(userId, resultData);
-                                return resultData;
+                            const resultData = {
+                                repoName,
+                                headBranch,
+                                targetBranch,
+                                prNumber: existingPR.number,
+                                prUrl: existingPR.html_url,
+                                prTitle: existingPR.title,
+                                commitsAhead,
+                                createdAt: existingPR.created_at,
+                                alreadyExists: true
+                            };
+                            // Emit socket event to refresh PR status on client
+                            if (socket) {
+                                socket.emit('refresh_pr_status', { repoName, prNumber: existingPR.number });
                             }
+                            // Update database asynchronously (non-blocking)
+                            //   this.updatePRMetadata(userId, resultData);
+                            return resultData;
                         }
-                        catch (fetchError) {
-                            logger.error('Failed to fetch existing PR', fetchError);
-                        }
                     }
-                    throw prError;
+                    catch (fetchError) {
+                        logger.error('Failed to fetch existing PR', fetchError);
+                    }
                 }
+                throw prError;
             }
-            finally {
-            }
-        }); // end withRepoLock
+        }
+        finally {
+        }
     }
     /**
      * Check if pull request exists
@@ -1262,37 +1234,35 @@ class GithubOperationsService {
         const repoPath = `${tool_server_1.folderPath}/${repoName}`;
         const installationToken = await fetchInstallationToken();
         const gitOrgName = await getGithubOrganizationName();
-        return withRepoLock(repoName, async () => {
-            try {
-                const trimmedSourceBranch = (sourceBranch || '').trim();
-                const trimmedTargetBranch = (targetBranch || '').trim();
-                if (!trimmedSourceBranch || !trimmedTargetBranch) {
-                    throw new Error('Both sourceBranch and targetBranch are required');
-                }
-                if (trimmedSourceBranch === trimmedTargetBranch) {
-                    throw new Error('sourceBranch and targetBranch cannot be the same');
-                }
-                logger.info('Starting branch merge operation', {
-                    repoName,
-                    sourceBranch: trimmedSourceBranch,
-                    targetBranch: trimmedTargetBranch,
-                    pushToRemote
-                });
-                let result = await executeShell(`cd ${repoPath} && rm -f .git/config.lock && ` +
-                    `git remote set-url origin https://x-access-token:${installationToken}@github.com/${gitOrgName}/${repoName}.git`);
-                if (!result.success) {
-                    throw new Error(`Failed to set authenticated remote URL: ${result.error || result.output || 'Unknown error'}`);
-                }
-                const fetchResult = await executeShell(`cd ${repoPath} && sudo git fetch origin --prune`);
-                if (!fetchResult.success) {
-                    throw new Error(`Failed to fetch remote branches: ${fetchResult.error || fetchResult.output || 'Unknown error'}`);
-                }
-                const resolvedSource = await this.resolveBranchReference(repoPath, repoName, trimmedSourceBranch);
-                const resolvedTarget = await this.resolveBranchReference(repoPath, repoName, trimmedTargetBranch);
-                const targetLocalBranch = resolvedTarget.displayBranch;
-                const safeTargetLocalBranch = this.escapeSingleQuotedShell(targetLocalBranch);
-                const safeSourceRef = this.escapeSingleQuotedShell(resolvedSource.resolvedRef);
-                const prepareBranchCommand = `
+        try {
+            const trimmedSourceBranch = (sourceBranch || '').trim();
+            const trimmedTargetBranch = (targetBranch || '').trim();
+            if (!trimmedSourceBranch || !trimmedTargetBranch) {
+                throw new Error('Both sourceBranch and targetBranch are required');
+            }
+            if (trimmedSourceBranch === trimmedTargetBranch) {
+                throw new Error('sourceBranch and targetBranch cannot be the same');
+            }
+            logger.info('Starting branch merge operation', {
+                repoName,
+                sourceBranch: trimmedSourceBranch,
+                targetBranch: trimmedTargetBranch,
+                pushToRemote
+            });
+            let result = await executeShell(`cd ${repoPath} && sudo git remote set-url origin https://x-access-token:${installationToken}@github.com/${gitOrgName}/${repoName}.git`);
+            if (!result.success) {
+                throw new Error(`Failed to set authenticated remote URL: ${result.error || result.output || 'Unknown error'}`);
+            }
+            const fetchResult = await executeShell(`cd ${repoPath} && sudo git fetch origin --prune`);
+            if (!fetchResult.success) {
+                throw new Error(`Failed to fetch remote branches: ${fetchResult.error || fetchResult.output || 'Unknown error'}`);
+            }
+            const resolvedSource = await this.resolveBranchReference(repoPath, repoName, trimmedSourceBranch);
+            const resolvedTarget = await this.resolveBranchReference(repoPath, repoName, trimmedTargetBranch);
+            const targetLocalBranch = resolvedTarget.displayBranch;
+            const safeTargetLocalBranch = this.escapeSingleQuotedShell(targetLocalBranch);
+            const safeSourceRef = this.escapeSingleQuotedShell(resolvedSource.resolvedRef);
+            const prepareBranchCommand = `
                 cd ${repoPath} &&
                 TARGET_LOCAL='${safeTargetLocalBranch}' &&
                 if sudo git show-ref --verify --quiet "refs/heads/$TARGET_LOCAL"; then
@@ -1307,178 +1277,174 @@ class GithubOperationsService {
                     sudo git pull --ff-only origin "$TARGET_LOCAL" 2>/dev/null || true;
                 fi
             `.replace(/\n\s+/g, ' ');
-                result = await executeShell(prepareBranchCommand);
-                if (!result.success) {
-                    throw new Error(`Failed to prepare target branch for merge: ${result.error || result.output || 'Unknown error'}`);
-                }
-                const mergeCommand = `cd ${repoPath} && SOURCE_REF='${safeSourceRef}' && sudo git merge --no-ff --no-edit "$SOURCE_REF"`;
-                const mergeResult = await executeShell(mergeCommand);
-                if (!mergeResult.success) {
-                    const conflictResult = await executeShell(`cd ${repoPath} && sudo git diff --name-only --diff-filter=U`);
-                    const conflictFiles = (conflictResult.output || '')
-                        .split('\n')
-                        .map((line) => line.trim())
-                        .filter((line) => line.length > 0);
-                    if (conflictFiles.length > 0) {
-                        logger.warn('Merge completed with conflicts', {
-                            repoName,
-                            sourceBranch: resolvedSource.displayBranch,
-                            targetBranch: targetLocalBranch,
-                            conflictFiles
-                        });
-                        return {
-                            repoName,
-                            sourceBranch: resolvedSource.displayBranch,
-                            targetBranch: targetLocalBranch,
-                            merged: false,
-                            hasConflicts: true,
-                            conflictFiles,
-                            currentBranch: targetLocalBranch,
-                            pushedToRemote: false,
-                            mergedAt: new Date().toISOString(),
-                            message: `Merge has conflicts. Resolve conflicts in target branch '${targetLocalBranch}'.`
-                        };
-                    }
-                    throw new Error(`Failed to merge branches: ${mergeResult.error || mergeResult.output || 'Unknown error'}`);
-                }
-                const summaryResult = await executeShell(`cd ${repoPath} && COMMIT_HASH=$(sudo git rev-parse HEAD) && CURRENT_BRANCH=$(sudo git rev-parse --abbrev-ref HEAD) && echo "COMMIT_HASH:$COMMIT_HASH" && echo "CURRENT_BRANCH:$CURRENT_BRANCH"`);
-                if (!summaryResult.success) {
-                    throw new Error(`Merge succeeded but failed to fetch merge summary: ${summaryResult.error || summaryResult.output || 'Unknown error'}`);
+            result = await executeShell(prepareBranchCommand);
+            if (!result.success) {
+                throw new Error(`Failed to prepare target branch for merge: ${result.error || result.output || 'Unknown error'}`);
+            }
+            const mergeCommand = `cd ${repoPath} && SOURCE_REF='${safeSourceRef}' && sudo git merge --no-ff --no-edit "$SOURCE_REF"`;
+            const mergeResult = await executeShell(mergeCommand);
+            if (!mergeResult.success) {
+                const conflictResult = await executeShell(`cd ${repoPath} && sudo git diff --name-only --diff-filter=U`);
+                const conflictFiles = (conflictResult.output || '')
+                    .split('\n')
+                    .map((line) => line.trim())
+                    .filter((line) => line.length > 0);
+                if (conflictFiles.length > 0) {
+                    logger.warn('Merge completed with conflicts', {
+                        repoName,
+                        sourceBranch: resolvedSource.displayBranch,
+                        targetBranch: targetLocalBranch,
+                        conflictFiles
+                    });
+                    return {
+                        repoName,
+                        sourceBranch: resolvedSource.displayBranch,
+                        targetBranch: targetLocalBranch,
+                        merged: false,
+                        hasConflicts: true,
+                        conflictFiles,
+                        currentBranch: targetLocalBranch,
+                        pushedToRemote: false,
+                        mergedAt: new Date().toISOString(),
+                        message: `Merge has conflicts. Resolve conflicts in target branch '${targetLocalBranch}'.`
+                    };
                 }
-                const summaryOutput = summaryResult.output || '';
-                const commitHashMatch = summaryOutput.match(/COMMIT_HASH:([^\n]+)/);
-                const currentBranchMatch = summaryOutput.match(/CURRENT_BRANCH:([^\n]+)/);
-                const commitHash = commitHashMatch ? commitHashMatch[1].trim() : '';
-                const currentBranch = currentBranchMatch ? currentBranchMatch[1].trim() : targetLocalBranch;
-                let pushedToRemote = false;
-                if (pushToRemote) {
-                    const pushResult = await executeShell(`cd ${repoPath} && sudo git push origin '${safeTargetLocalBranch}'`);
-                    if (!pushResult.success) {
-                        throw new Error(`Merge succeeded but push failed: ${pushResult.error || pushResult.output || 'Unknown error'}`);
-                    }
-                    pushedToRemote = true;
+                throw new Error(`Failed to merge branches: ${mergeResult.error || mergeResult.output || 'Unknown error'}`);
+            }
+            const summaryResult = await executeShell(`cd ${repoPath} && COMMIT_HASH=$(sudo git rev-parse HEAD) && CURRENT_BRANCH=$(sudo git rev-parse --abbrev-ref HEAD) && echo "COMMIT_HASH:$COMMIT_HASH" && echo "CURRENT_BRANCH:$CURRENT_BRANCH"`);
+            if (!summaryResult.success) {
+                throw new Error(`Merge succeeded but failed to fetch merge summary: ${summaryResult.error || summaryResult.output || 'Unknown error'}`);
+            }
+            const summaryOutput = summaryResult.output || '';
+            const commitHashMatch = summaryOutput.match(/COMMIT_HASH:([^\n]+)/);
+            const currentBranchMatch = summaryOutput.match(/CURRENT_BRANCH:([^\n]+)/);
+            const commitHash = commitHashMatch ? commitHashMatch[1].trim() : '';
+            const currentBranch = currentBranchMatch ? currentBranchMatch[1].trim() : targetLocalBranch;
+            let pushedToRemote = false;
+            if (pushToRemote) {
+                const pushResult = await executeShell(`cd ${repoPath} && sudo git push origin '${safeTargetLocalBranch}'`);
+                if (!pushResult.success) {
+                    throw new Error(`Merge succeeded but push failed: ${pushResult.error || pushResult.output || 'Unknown error'}`);
                 }
-                logger.success('Branch merge completed successfully', {
+                pushedToRemote = true;
+            }
+            logger.success('Branch merge completed successfully', {
+                repoName,
+                sourceBranch: resolvedSource.displayBranch,
+                targetBranch: targetLocalBranch,
+                commitHash,
+                pushedToRemote
+            });
+            if (socket) {
+                socket.emit('refresh_repo', { repoName });
+            }
+            return {
+                repoName,
+                sourceBranch: resolvedSource.displayBranch,
+                targetBranch: targetLocalBranch,
+                merged: true,
+                hasConflicts: false,
+                conflictFiles: [],
+                currentBranch,
+                commitHash,
+                pushedToRemote,
+                mergedAt: new Date().toISOString(),
+                message: pushedToRemote
+                    ? `Merged '${resolvedSource.displayBranch}' into '${targetLocalBranch}' and pushed to remote.`
+                    : `Merged '${resolvedSource.displayBranch}' into '${targetLocalBranch}' locally.`
+            };
+        }
+        finally {
+            try {
+                await executeShell(`cd ${repoPath} && sudo git remote set-url origin https://github.com/${gitOrgName}/${repoName}.git`);
+            }
+            catch (restoreError) {
+                logger.error('Failed to restore unauthenticated remote URL after merge operation', {
                     repoName,
-                    sourceBranch: resolvedSource.displayBranch,
-                    targetBranch: targetLocalBranch,
-                    commitHash,
-                    pushedToRemote
+                    error: restoreError instanceof Error ? restoreError.message : String(restoreError)
                 });
-                if (socket) {
-                    socket.emit('refresh_repo', { repoName });
-                }
-                return {
-                    repoName,
-                    sourceBranch: resolvedSource.displayBranch,
-                    targetBranch: targetLocalBranch,
-                    merged: true,
-                    hasConflicts: false,
-                    conflictFiles: [],
-                    currentBranch,
-                    commitHash,
-                    pushedToRemote,
-                    mergedAt: new Date().toISOString(),
-                    message: pushedToRemote
-                        ? `Merged '${resolvedSource.displayBranch}' into '${targetLocalBranch}' and pushed to remote.`
-                        : `Merged '${resolvedSource.displayBranch}' into '${targetLocalBranch}' locally.`
-                };
             }
-            finally {
-                try {
-                    await executeShell(`cd ${repoPath} && git remote set-url origin https://github.com/${gitOrgName}/${repoName}.git`);
-                }
-                catch (restoreError) {
-                    logger.error('Failed to restore unauthenticated remote URL after merge operation', {
-                        repoName,
-                        error: restoreError instanceof Error ? restoreError.message : String(restoreError)
-                    });
-                }
-            }
-        }); // end withRepoLock
+        }
     }
     async checkPullRequestExists(repoName, targetBranch) {
         const repoPath = `${tool_server_1.folderPath}/${repoName}`;
         const installationToken = await fetchInstallationToken();
         const gitOrgName = await getGithubOrganizationName();
-        return withRepoLock(repoName, async () => {
-            try {
-                logger.info('Checking if PR exists', { repoName, targetBranch });
-                // Get current branch and commits ahead
-                const combinedCommand = `
+        try {
+            logger.info('Checking if PR exists', { repoName, targetBranch });
+            // Get current branch and commits ahead
+            const combinedCommand = `
                 cd ${repoPath} &&
-                rm -f .git/config.lock &&
-                git remote set-url origin https://x-access-token:${installationToken}@github.com/${gitOrgName}/${repoName}.git &&
+                sudo git remote set-url origin https://x-access-token:${installationToken}@github.com/${gitOrgName}/${repoName}.git &&
                 HEAD_BRANCH=$(sudo git rev-parse --abbrev-ref HEAD) &&
                 sudo git fetch origin --prune 2>/dev/null || true &&
                 sudo git fetch origin ${targetBranch} 2>/dev/null || true &&
                 COMMITS_AHEAD=$(sudo git rev-list --count origin/${targetBranch}..$HEAD_BRANCH 2>/dev/null || echo 0) &&
-                git remote set-url origin https://github.com/${gitOrgName}/${repoName}.git &&
+                sudo git remote set-url origin https://github.com/${gitOrgName}/${repoName}.git &&
                 echo "HEAD_BRANCH:$HEAD_BRANCH" &&
                 echo "COMMITS_AHEAD:$COMMITS_AHEAD"
             `.replace(/\n\s+/g, ' ');
-                const result = await executeShell(combinedCommand);
-                // Check for command execution failure
-                if (!result.success) {
-                    logger.error('Failed to check PR status', {
-                        repoName,
-                        error: result.error,
-                        code: result.code,
-                        output: result.output
-                    });
-                    throw new Error(`Failed to check PR status: ${result.error}`);
-                }
-                const output = result.output || '';
-                const headBranchMatch = output.match(/HEAD_BRANCH:([^\n]+)/);
-                const commitsAheadMatch = output.match(/COMMITS_AHEAD:(\d+)/);
-                const headBranch = headBranchMatch ? headBranchMatch[1].trim() : 'unknown';
-                const commitsAhead = commitsAheadMatch ? parseInt(commitsAheadMatch[1]) : 0;
-                logger.info('Branch info retrieved', { headBranch, commitsAhead });
-                // Check for existing PR - using 'octokit' package (already installed)
-                const { Octokit } = require('octokit');
-                const octokit = new Octokit({
-                    auth: installationToken
+            const result = await executeShell(combinedCommand);
+            // Check for command execution failure
+            if (!result.success) {
+                logger.error('Failed to check PR status', {
+                    repoName,
+                    error: result.error,
+                    code: result.code,
+                    output: result.output
                 });
-                const existingPRs = await octokit.rest.pulls.list({
-                    owner: gitOrgName,
-                    repo: repoName,
-                    head: `${gitOrgName}:${headBranch}`,
-                    base: targetBranch,
-                    state: 'open'
+                throw new Error(`Failed to check PR status: ${result.error}`);
+            }
+            const output = result.output || '';
+            const headBranchMatch = output.match(/HEAD_BRANCH:([^\n]+)/);
+            const commitsAheadMatch = output.match(/COMMITS_AHEAD:(\d+)/);
+            const headBranch = headBranchMatch ? headBranchMatch[1].trim() : 'unknown';
+            const commitsAhead = commitsAheadMatch ? parseInt(commitsAheadMatch[1]) : 0;
+            logger.info('Branch info retrieved', { headBranch, commitsAhead });
+            // Check for existing PR - using 'octokit' package (already installed)
+            const { Octokit } = require('octokit');
+            const octokit = new Octokit({
+                auth: installationToken
+            });
+            const existingPRs = await octokit.rest.pulls.list({
+                owner: gitOrgName,
+                repo: repoName,
+                head: `${gitOrgName}:${headBranch}`,
+                base: targetBranch,
+                state: 'open'
+            });
+            if (existingPRs.data.length > 0) {
+                const existingPR = existingPRs.data[0];
+                logger.info('Pull request exists', {
+                    repoName,
+                    prNumber: existingPR.number,
+                    prUrl: existingPR.html_url
                 });
-                if (existingPRs.data.length > 0) {
-                    const existingPR = existingPRs.data[0];
-                    logger.info('Pull request exists', {
-                        repoName,
-                        prNumber: existingPR.number,
-                        prUrl: existingPR.html_url
-                    });
-                    return {
-                        repoName,
-                        headBranch,
-                        targetBranch,
-                        prExists: true,
-                        prNumber: existingPR.number,
-                        prUrl: existingPR.html_url,
-                        prTitle: existingPR.title,
-                        commitsAhead,
-                        createdAt: existingPR.created_at
-                    };
-                }
-                else {
-                    logger.info('No pull request found', { repoName, headBranch, targetBranch });
-                    return {
-                        repoName,
-                        headBranch,
-                        targetBranch,
-                        prExists: false,
-                        commitsAhead
-                    };
-                }
+                return {
+                    repoName,
+                    headBranch,
+                    targetBranch,
+                    prExists: true,
+                    prNumber: existingPR.number,
+                    prUrl: existingPR.html_url,
+                    prTitle: existingPR.title,
+                    commitsAhead,
+                    createdAt: existingPR.created_at
+                };
             }
-            finally {
+            else {
+                logger.info('No pull request found', { repoName, headBranch, targetBranch });
+                return {
+                    repoName,
+                    headBranch,
+                    targetBranch,
+                    prExists: false,
+                    commitsAhead
+                };
             }
-        }); // end withRepoLock
+        }
+        finally {
+        }
     }
     /**
      * Get commit list with commit IDs for a branch
@@ -1977,7 +1943,7 @@ class GithubOperationsService {
     /**
      * Helper method to get merge conflicts
      */
-    async getMergeConflicts(repoName) {
+    async getMergeConflicts(socket, repoName) {
         return new Promise((resolve) => {
             this.getMergeConflictsImplementation(repoName, tool_server_1.folderPath).then((mergeData) => {
                 resolve(mergeData);