phantomx-tool-client 1.0.0

package/dist/githubOperationsHanlder.js

@@ -0,0 +1,1487 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GithubOperationsService = void 0;
+exports.getGithubOrganizationName = getGithubOrganizationName;
+exports.fetchInstallationToken = fetchInstallationToken;
+exports.getRepoList = getRepoList;
+exports.getRepoBranch = getRepoBranch;
+const Logger_1 = require("./Services/Logger");
+const child_process_1 = require("child_process");
+// ---------------------------------------------------------------------------
+// Local bash executor — drop-in replacement for ssh.executeCommand()
+// Returns { success, output, error, code } matching the SSH client response.
+// ---------------------------------------------------------------------------
+function executeShell(command) {
+    return new Promise((resolve) => {
+        const child = (0, child_process_1.spawn)('bash', ['-c', command], {
+            env: process.env,
+            stdio: ['ignore', 'pipe', 'pipe']
+        });
+        let stdout = '';
+        let stderr = '';
+        child.stdout.on('data', (chunk) => { stdout += chunk.toString(); });
+        child.stderr.on('data', (chunk) => { stderr += chunk.toString(); });
+        child.on('close', (code) => {
+            resolve({ success: code === 0, output: stdout, error: stderr, code: code !== null && code !== void 0 ? code : 1 });
+        });
+        child.on('error', (err) => {
+            resolve({ success: false, output: '', error: err.message, code: 1 });
+        });
+    });
+}
+// 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');
+const simple_git_1 = require("simple-git");
+const tool_server_1 = require("./tool-server");
+async function getGithubOrganizationName() {
+    return tool_server_1.githubOrgName;
+}
+async function fetchInstallationToken() {
+    // this is not the installation token but a github PAT token for accessing the github repos
+    // fetching this token from an .env
+    return tool_server_1.githubPATToken;
+}
+async function getRepoList() {
+    let installationToken = await fetchInstallationToken(); //getting the installation Token
+    const resp = await fetch("https://api.github.com/installation/repositories", {
+        headers: {
+            Accept: "application/vnd.github+json",
+            Authorization: `Bearer ${installationToken}`,
+            "X-GitHub-Api-Version": "2022-11-28",
+        },
+    });
+    if (!resp.ok) {
+        throw new Error(`Failed to list repos: ${resp.status} ${await resp.text()}`);
+    }
+    const data = await resp.json();
+    // data.repositories is an array of repo objects
+    return data.repositories.map((repo) => repo.name);
+}
+async function getRepoBranch(owner, repo) {
+    const installationToken = (await fetchInstallationToken()); //getting the installation Token
+    const octokit = new Octokit({ auth: installationToken });
+    try {
+        const branches = await octokit.paginate(octokit.rest.repos.listBranches, {
+            owner,
+            repo,
+            per_page: 100
+        });
+        return branches;
+    }
+    catch (err) {
+        console.log("Error listing branches:", err);
+        throw err;
+    }
+}
+class GithubOperationsService {
+    escapeSingleQuotedShell(value) {
+        return value.replace(/'/g, `'\\''`);
+    }
+    async resolveBranchReference(repoPath, repoName, branchName) {
+        const requestedBranch = (branchName || '').trim();
+        if (!requestedBranch) {
+            throw new Error('Branch name is required');
+        }
+        const candidateRefs = requestedBranch.startsWith('origin/')
+            ? [requestedBranch, requestedBranch.replace(/^origin\//, '')]
+            : [requestedBranch, `origin/${requestedBranch}`];
+        const uniqueCandidates = Array.from(new Set(candidateRefs.filter((candidate) => candidate.trim().length > 0)));
+        for (const candidate of uniqueCandidates) {
+            const safeCandidate = this.escapeSingleQuotedShell(candidate);
+            const branchCheck = await executeShell(`cd ${repoPath} && sudo git rev-parse --verify '${safeCandidate}^{commit}' >/dev/null 2>&1 && echo "BRANCH_OK"`);
+            if (branchCheck.success && (branchCheck.output || '').includes('BRANCH_OK')) {
+                return {
+                    requestedBranch,
+                    resolvedRef: candidate,
+                    displayBranch: candidate.replace(/^origin\//, '')
+                };
+            }
+        }
+        throw new Error(`Branch '${requestedBranch}' not found in repository '${repoName}'`);
+    }
+    /**
+     * Get repository list for an installation
+     */
+    async getRepositoryList() {
+        const repositories = await getRepoList();
+        return {
+            repositories,
+            count: repositories.length
+        };
+    }
+    /**
+     * List branches for a repository
+     */
+    async listBranches(owner, repo) {
+        logger.info(`Fetching branches for ${owner}/${repo} )`);
+        const branches = await getRepoBranch(owner, repo);
+        return {
+            repo,
+            branches,
+            count: branches.length
+        };
+    }
+    /**
+     * Pull repository from remote
+     */
+    async pullRepository(repoName, socket) {
+        const repoPath = `${tool_server_1.folderPath}/${repoName}`;
+        const installationToken = await fetchInstallationToken();
+        const gitOrgName = await getGithubOrganizationName();
+        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 });
+            // 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}`);
+            }
+            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
+     */
+    async pushRepository(repoName, socket) {
+        const repoPath = `${tool_server_1.folderPath}/${repoName}`;
+        const installationToken = await fetchInstallationToken();
+        const gitOrgName = await getGithubOrganizationName();
+        try {
+            logger.info('Starting git push operation', { repoName });
+            // Combine all commands into a single SSH call
+            const combinedCommand = `
+                cd ${repoPath} &&
+                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 &&
+                sudo git remote set-url origin https://x-access-token:${installationToken}@github.com/${gitOrgName}/${repoName}.git &&
+                sudo git push origin $BRANCH &&
+                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 });
+            }
+            return {
+                repoName,
+                branchName: currentBranch,
+                commitHash,
+                commitsAhead,
+                pushedAt: new Date().toISOString()
+            };
+        }
+        finally {
+        }
+    }
+    /**
+     * Check repository status
+     */
+    async checkRepositoryStatus(repoName, socket) {
+        const repoPath = `${tool_server_1.folderPath}/${repoName}`;
+        const installationToken = await fetchInstallationToken();
+        const gitOrgName = await getGithubOrganizationName();
+        try {
+            logger.info('Checking repository status', { repoName });
+            // Combine all git commands into a single SSH call
+            const combinedCommand = `
+                cd ${repoPath} &&
+                BRANCH=$(sudo git rev-parse --abbrev-ref HEAD) &&
+                sudo git remote set-url origin https://x-access-token:${installationToken}@github.com/${gitOrgName}/${repoName}.git &&
+                sudo git fetch origin &&
+                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) &&
+                CURRENT_HASH=$(sudo git rev-parse HEAD) &&
+                REMOTE_HASH=$(sudo git rev-parse origin/$BRANCH 2>/dev/null || echo unknown) &&
+                echo "BRANCH:$BRANCH" &&
+                echo "BEHIND:$BEHIND" &&
+                echo "AHEAD:$AHEAD" &&
+                echo "STATUS:$STATUS" &&
+                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');
+            }
+            // 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
+     */
+    async getRepositoryHistory(repoName, remoteBranchName, limit = 50) {
+        const repoPath = `${tool_server_1.folderPath}/${repoName}`;
+        try {
+            logger.info('Fetching repository history', { repoName, remoteBranchName, limit });
+            const safeLimit = Number.isFinite(limit) ? Math.min(Math.max(limit, 1), 500) : 50;
+            let targetBranch = (remoteBranchName || '').trim();
+            if (!targetBranch) {
+                const branchResult = await executeShell(`cd ${repoPath} && sudo git rev-parse --abbrev-ref HEAD`);
+                if (!branchResult.success) {
+                    throw new Error(`Failed to resolve current branch: ${branchResult.error || branchResult.output || 'Unknown error'}`);
+                }
+                targetBranch = branchResult.output.trim();
+            }
+            const resolvedBranch = await this.resolveBranchReference(repoPath, repoName, targetBranch);
+            const safeResolvedRef = this.escapeSingleQuotedShell(resolvedBranch.resolvedRef);
+            // Get reflog with detailed information
+            let result = await executeShell(`cd ${repoPath} && sudo git reflog -${safeLimit} --date=iso`);
+            if (!result.success) {
+                throw new Error(`Failed to fetch reflog: ${result.error}`);
+            }
+            const reflogEntries = result.output.trim().split('\n').filter((line) => line.trim());
+            // Get commit log with detailed information
+            result = await executeShell(`cd ${repoPath} && sudo git log '${safeResolvedRef}' -${safeLimit} --pretty=format:"%H|%an|%ae|%ad|%s" --date=iso`);
+            if (!result.success) {
+                throw new Error(`Failed to fetch commit log for branch '${resolvedBranch.displayBranch}': ${result.error || result.output || 'Unknown error'}`);
+            }
+            const commitLog = result.output.trim() ? result.output.trim().split('\n').filter((line) => line.trim()) : [];
+            // Parse reflog entries
+            const parsedReflog = reflogEntries.map((entry) => {
+                // Format: hash HEAD@{n}: action: message
+                const match = entry.match(/^([a-f0-9]+)\s+HEAD@\{(\d+)\}:\s+(.+?):\s+(.+)$/);
+                if (match) {
+                    const [, hash, index, action, message] = match;
+                    // Determine action type
+                    let actionType = 'unknown';
+                    let actionDetails = {};
+                    if (action.includes('commit')) {
+                        actionType = 'commit';
+                        actionDetails = { type: action.includes('initial') ? 'initial' : 'regular' };
+                    }
+                    else if (action.includes('pull')) {
+                        actionType = 'pull';
+                        const branchMatch = message.match(/from (.+)/);
+                        actionDetails = { source: branchMatch ? branchMatch[1] : 'unknown' };
+                    }
+                    else if (action.includes('merge')) {
+                        actionType = 'merge';
+                        actionDetails = { message: message };
+                    }
+                    else if (action.includes('checkout')) {
+                        actionType = 'checkout';
+                        const branchMatch = message.match(/to (.+)/);
+                        actionDetails = { branch: branchMatch ? branchMatch[1] : message };
+                    }
+                    else if (action.includes('rebase')) {
+                        actionType = 'rebase';
+                    }
+                    else if (action.includes('reset')) {
+                        actionType = 'reset';
+                        actionDetails = { target: message };
+                    }
+                    else if (action.includes('clone')) {
+                        actionType = 'clone';
+                    }
+                    return {
+                        hash: hash.substring(0, 7),
+                        fullHash: hash,
+                        index: parseInt(index),
+                        action: actionType,
+                        actionRaw: action,
+                        message: message,
+                        details: actionDetails
+                    };
+                }
+                return null;
+            }).filter((entry) => entry !== null);
+            // Parse commit log
+            const parsedCommits = commitLog.map((commit) => {
+                const [hash, author, email, date, message] = commit.split('|');
+                return {
+                    hash: hash.substring(0, 7),
+                    fullHash: hash,
+                    author,
+                    email,
+                    date,
+                    message
+                };
+            });
+            const currentBranch = resolvedBranch.displayBranch;
+            // Get latest commit info
+            result = await executeShell(`cd ${repoPath} && sudo git rev-parse '${safeResolvedRef}'`);
+            const latestCommitHash = result.success ? result.output.trim() : 'unknown';
+            // Get repository statistics
+            result = await executeShell(`cd ${repoPath} && sudo git rev-list --count '${safeResolvedRef}'`);
+            const totalCommits = result.success ? parseInt(result.output.trim()) : 0;
+            logger.success('Repository history fetched successfully', {
+                repoName,
+                branchName: resolvedBranch.displayBranch,
+                reflogEntries: parsedReflog.length,
+                commits: parsedCommits.length
+            });
+            return {
+                repoName,
+                currentBranch,
+                latestCommitHash,
+                totalCommits,
+                reflog: parsedReflog,
+                commits: parsedCommits,
+                summary: {
+                    totalReflogEntries: parsedReflog.length,
+                    totalCommitsShown: parsedCommits.length,
+                    actionTypes: {
+                        commits: parsedReflog.filter((e) => e.action === 'commit').length,
+                        pulls: parsedReflog.filter((e) => e.action === 'pull').length,
+                        merges: parsedReflog.filter((e) => e.action === 'merge').length,
+                        checkouts: parsedReflog.filter((e) => e.action === 'checkout').length,
+                        resets: parsedReflog.filter((e) => e.action === 'reset').length,
+                        rebases: parsedReflog.filter((e) => e.action === 'rebase').length
+                    }
+                }
+            };
+        }
+        finally {
+        }
+    }
+    /**
+     * Commit local changes
+     */
+    async commitLocalChanges(repoName, remoteBranchName, commitMessage, userInfo, socket, userId) {
+        const repoPath = `${tool_server_1.folderPath}/${repoName}`;
+        let commitMsg = commitMessage;
+        if (!commitMessage) {
+            commitMsg = 'Auto-commit by AI-Playgrounds Bot';
+        }
+        try {
+            logger.info('Starting local commit operation', { repoName, remoteBranchName, commitMessage });
+            // Escape commit message for shell safety
+            const commitAuthorName = (userInfo === null || userInfo === void 0 ? void 0 : userInfo.name) || 'Phantom';
+            const commitAuthorEmail = (userInfo === null || userInfo === void 0 ? void 0 : userInfo.email) || 'noreply@ai-playgrounds.com';
+            const escapedCommitMsg = commitMsg.replace(/"/g, '\\"').replace(/`/g, '\\`').replace(/\$/g, '\\$');
+            const escapedAuthorName = commitAuthorName.replace(/"/g, '\\"');
+            const escapedAuthorEmail = commitAuthorEmail.replace(/"/g, '\\"');
+            // Combine all commands into a single SSH call
+            const combinedCommand = `
+                cd ${repoPath} &&
+                sudo git config user.name "${escapedAuthorName}" &&
+                sudo git config user.email "${escapedAuthorEmail}" &&
+                STATUS=$(sudo git status --porcelain) &&
+                if [ -z "$STATUS" ]; then
+                    echo "ERROR:NO_CHANGES";
+                    exit 1;
+                fi &&
+                CHANGED_FILES=$(echo "$STATUS" | wc -l) &&
+                sudo git add . &&
+                sudo git commit -m "${escapedCommitMsg}" &&
+                COMMIT_HASH=$(sudo git rev-parse HEAD) &&
+                SHORT_HASH=$(sudo git rev-parse --short HEAD) &&
+                echo "CHANGED_FILES:$CHANGED_FILES" &&
+                echo "COMMIT_HASH:$COMMIT_HASH" &&
+                echo "SHORT_HASH:$SHORT_HASH"
+            `.replace(/\n\s+/g, ' ');
+            const result = await executeShell(combinedCommand);
+            if (!result.success) {
+                if (result.output && result.output.includes('ERROR:NO_CHANGES')) {
+                    throw new Error('No changes to commit');
+                }
+                throw new Error('Failed to commit local changes');
+            }
+            // Parse output
+            const output = result.output;
+            const changedFilesMatch = output.match(/CHANGED_FILES:(\d+)/);
+            const commitHashMatch = output.match(/COMMIT_HASH:([a-f0-9]+)/);
+            const shortHashMatch = output.match(/SHORT_HASH:([a-f0-9]+)/);
+            const changedFiles = changedFilesMatch ? parseInt(changedFilesMatch[1]) : 0;
+            const commitHash = commitHashMatch ? commitHashMatch[1].trim() : 'unknown';
+            const shortHash = shortHashMatch ? shortHashMatch[1].trim() : commitHash.substring(0, 7);
+            logger.success('Local commit completed successfully', { repoName, commitHash, changedFiles });
+            const resultData = {
+                repoName,
+                branchName: remoteBranchName,
+                commitMessage,
+                commitHash,
+                shortHash,
+                changedFiles,
+                author: commitAuthorName,
+                email: commitAuthorEmail,
+                committedAt: new Date().toISOString()
+            };
+            // Emit socket event to refresh repo on client (only when called by AI agent)
+            if (socket) {
+                socket.emit('refresh_repo', { repoName });
+            }
+            // Update database asynchronously (non-blocking)
+            // if (userId) {
+            //     (async () => {
+            //         try {
+            //             const dbService = await getDBService();
+            //             const dbName = ds.UserInfo.get(userId)?.dbName;
+            //             if (!dbName) throw new Error('User dbName not found');
+            //             const taskRepository = dbService.getRepository(dbName, CollectionNames.TASKS);
+            //             const task = await taskRepository.findOne();
+            //             let gitChanges = (task?.metadata?.github) || {
+            //                 totalAdditions: 0,
+            //                 totalDeletions: 0,
+            //                 totalChangedFiles: 0,
+            //                 pullRequests: [],
+            //                 commits: []
+            //             };
+            //             const commitObj = {
+            //                 id: shortHash,
+            //                 sha: commitHash,
+            //                 message: commitMessage,
+            //                 author: commitAuthorEmail,
+            //                 authorName: commitAuthorName,
+            //                 timestamp: resultData.committedAt,
+            //                 url: undefined,
+            //                 additions: changedFiles,
+            //                 deletions: 0,
+            //                 changedFiles: changedFiles,
+            //                 files: []
+            //             };
+            //             gitChanges.commits.push(commitObj);
+            //             gitChanges.totalChangedFiles += changedFiles;
+            //             await taskRepository.updateOne(, { $set: { 'metadata.github': gitChanges } });
+            //         } catch (err) {
+            //             logger.error('Failed to update task metadata.github for commit', { err });
+            //         }
+            //     })();
+            // }
+            return resultData;
+        }
+        finally {
+        }
+    }
+    /**
+     * Create pull request
+     */
+    async createPullRequest(repoName, targetBranch, title, body, socket) {
+        const repoPath = `${tool_server_1.folderPath}/${repoName}`;
+        const installationToken = await fetchInstallationToken();
+        const gitOrgName = await getGithubOrganizationName();
+        try {
+            logger.info('Creating pull request', { repoName, targetBranch });
+            // Combine commands into a single SSH call, with remote URL set/unset
+            const combinedCommand = `
+                cd ${repoPath} &&
+                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";
+                    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" &&
+                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();
+            }
+            const { Octokit } = require('@octokit/rest');
+            const octokit = new Octokit({
+                auth: installationToken
+            });
+            // Always check for existing PR first even if there are no new commits
+            try {
+                const existingPRs = await octokit.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.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.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 });
+                            }
+                            // Update database asynchronously (non-blocking)
+                            //   this.updatePRMetadata(userId, resultData);
+                            return resultData;
+                        }
+                    }
+                    catch (fetchError) {
+                        logger.error('Failed to fetch existing PR', fetchError);
+                    }
+                }
+                throw prError;
+            }
+        }
+        finally {
+        }
+    }
+    /**
+     * Check if pull request exists
+     */
+    async mergeBranchIntoBranch(repoName, sourceBranch, targetBranch, pushToRemote = false, socket) {
+        const repoPath = `${tool_server_1.folderPath}/${repoName}`;
+        const installationToken = await fetchInstallationToken();
+        const gitOrgName = await getGithubOrganizationName();
+        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
+                    sudo git checkout "$TARGET_LOCAL";
+                elif sudo git show-ref --verify --quiet "refs/remotes/origin/$TARGET_LOCAL"; then
+                    sudo git checkout -b "$TARGET_LOCAL" "origin/$TARGET_LOCAL";
+                else
+                    echo "ERROR:TARGET_BRANCH_NOT_CHECKOUTABLE";
+                    exit 1;
+                fi &&
+                if sudo git show-ref --verify --quiet "refs/remotes/origin/$TARGET_LOCAL"; then
+                    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'}`);
+            }
+            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;
+            }
+            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,
+                    error: restoreError instanceof Error ? restoreError.message : String(restoreError)
+                });
+            }
+        }
+    }
+    async checkPullRequestExists(repoName, targetBranch) {
+        const repoPath = `${tool_server_1.folderPath}/${repoName}`;
+        const installationToken = await fetchInstallationToken();
+        const gitOrgName = await getGithubOrganizationName();
+        try {
+            logger.info('Checking if PR exists', { repoName, targetBranch });
+            // Get current branch and commits ahead
+            const combinedCommand = `
+                cd ${repoPath} &&
+                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} &&
+                COMMITS_AHEAD=$(sudo git rev-list --count origin/${targetBranch}..$HEAD_BRANCH 2>/dev/null || echo 0) &&
+                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
+            const { Octokit } = require('@octokit/rest');
+            const octokit = new Octokit({
+                auth: installationToken
+            });
+            const existingPRs = await octokit.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
+                });
+                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
+                };
+            }
+        }
+        finally {
+        }
+    }
+    /**
+     * Get commit list with commit IDs for a branch
+     */
+    async getCommitList(repoName, branchName, limit = 100) {
+        const repoPath = `${tool_server_1.folderPath}/${repoName}`;
+        try {
+            logger.info('Fetching commit list', { repoName, branchName, limit });
+            const safeLimit = Number.isFinite(limit) ? Math.min(Math.max(limit, 1), 500) : 100;
+            let targetBranch = (branchName || '').trim();
+            if (!targetBranch) {
+                const branchResult = await executeShell(`cd ${repoPath} && sudo git rev-parse --abbrev-ref HEAD`);
+                if (!branchResult.success) {
+                    throw new Error(`Failed to resolve current branch: ${branchResult.error || branchResult.output || 'Unknown error'}`);
+                }
+                targetBranch = branchResult.output.trim();
+            }
+            const resolvedBranch = await this.resolveBranchReference(repoPath, repoName, targetBranch);
+            const safeResolvedRef = this.escapeSingleQuotedShell(resolvedBranch.resolvedRef);
+            const logResult = await executeShell(`cd ${repoPath} && sudo git log '${safeResolvedRef}' -${safeLimit} --pretty=format:"%H%x1f%h%x1f%an%x1f%ae%x1f%ad%x1f%s" --date=iso`);
+            if (!logResult.success) {
+                throw new Error(`Failed to fetch commit list: ${logResult.error || logResult.output || 'Unknown error'}`);
+            }
+            const commitLines = (logResult.output || '').trim()
+                ? logResult.output.trim().split('\n').filter((line) => line.trim())
+                : [];
+            const commits = commitLines
+                .map((line) => {
+                const [fullHash, hash, author, email, date, ...messageParts] = line.split('\x1f');
+                return {
+                    hash: (hash || '').trim(),
+                    fullHash: (fullHash || '').trim(),
+                    author: (author || '').trim(),
+                    email: (email || '').trim(),
+                    date: (date || '').trim(),
+                    message: messageParts.join('\x1f').trim()
+                };
+            })
+                .filter((commit) => commit.fullHash);
+            logger.success('Commit list fetched successfully', {
+                repoName,
+                branchName: resolvedBranch.displayBranch,
+                commits: commits.length
+            });
+            return {
+                repoName,
+                branchName: resolvedBranch.displayBranch,
+                totalCommits: commits.length,
+                commits
+            };
+        }
+        finally {
+        }
+    }
+    /**
+     * Get latest commit diff for a given branch
+     */
+    async getLatestCommitDiff(repoName, branchName) {
+        const repoPath = `${tool_server_1.folderPath}/${repoName}`;
+        try {
+            logger.info('Fetching latest commit diff', { repoName, branchName });
+            let targetBranch = (branchName || '').trim();
+            if (!targetBranch) {
+                const branchResult = await executeShell(`cd ${repoPath} && sudo git rev-parse --abbrev-ref HEAD`);
+                if (!branchResult.success) {
+                    throw new Error(`Failed to resolve current branch: ${branchResult.error || branchResult.output || 'Unknown error'}`);
+                }
+                targetBranch = branchResult.output.trim();
+            }
+            const resolvedBranch = await this.resolveBranchReference(repoPath, repoName, targetBranch);
+            const safeResolvedRef = this.escapeSingleQuotedShell(resolvedBranch.resolvedRef);
+            const commitInfoResult = await executeShell(`cd ${repoPath} && sudo git show --no-patch --pretty=format:"%H%x1f%h%x1f%an%x1f%ae%x1f%ad%x1f%s" --date=iso '${safeResolvedRef}'`);
+            if (!commitInfoResult.success) {
+                throw new Error(`Failed to fetch latest commit information: ${commitInfoResult.error || commitInfoResult.output || 'Unknown error'}`);
+            }
+            const commitInfo = (commitInfoResult.output || '').trim();
+            if (!commitInfo) {
+                throw new Error(`No commits found on branch '${resolvedBranch.displayBranch}'`);
+            }
+            const [fullHash, hash, author, email, date, ...messageParts] = commitInfo.split('\x1f');
+            const commitMessage = messageParts.join('\x1f').trim();
+            const safeCommitHash = this.escapeSingleQuotedShell((fullHash || '').trim());
+            const diffResult = await executeShell(`cd ${repoPath} && sudo git show --pretty=format:"" '${safeCommitHash}'`);
+            if (!diffResult.success) {
+                throw new Error(`Failed to fetch diff for commit '${hash}': ${diffResult.error || diffResult.output || 'Unknown error'}`);
+            }
+            const statsResult = await executeShell(`cd ${repoPath} && sudo git show --numstat --pretty="" '${safeCommitHash}'`);
+            if (!statsResult.success) {
+                throw new Error(`Failed to fetch commit stats for '${hash}': ${statsResult.error || statsResult.output || 'Unknown error'}`);
+            }
+            const statLines = (statsResult.output || '').trim()
+                ? statsResult.output.trim().split('\n').filter((line) => line.trim())
+                : [];
+            let totalAdditions = 0;
+            let totalDeletions = 0;
+            for (const line of statLines) {
+                const [additionsRaw, deletionsRaw] = line.split('\t');
+                const additions = additionsRaw === '-' ? 0 : parseInt(additionsRaw, 10) || 0;
+                const deletions = deletionsRaw === '-' ? 0 : parseInt(deletionsRaw, 10) || 0;
+                totalAdditions += additions;
+                totalDeletions += deletions;
+            }
+            logger.success('Latest commit diff fetched successfully', {
+                repoName,
+                branchName: resolvedBranch.displayBranch,
+                commitHash: hash,
+                filesChanged: statLines.length
+            });
+            return {
+                repoName,
+                branchName: resolvedBranch.displayBranch,
+                commit: {
+                    hash: (hash || '').trim(),
+                    fullHash: (fullHash || '').trim(),
+                    author: (author || '').trim(),
+                    email: (email || '').trim(),
+                    date: (date || '').trim(),
+                    message: commitMessage
+                },
+                diff: diffResult.output || '',
+                summary: {
+                    filesChanged: statLines.length,
+                    totalAdditions,
+                    totalDeletions,
+                    totalChanges: totalAdditions + totalDeletions
+                }
+            };
+        }
+        finally {
+        }
+    }
+    /**
+     * Get diff for a specific commit hash
+     */
+    async getCommitDiffByHash(repoName, commitHash) {
+        const repoPath = `${tool_server_1.folderPath}/${repoName}`;
+        try {
+            const requestedCommit = (commitHash || '').trim();
+            if (!requestedCommit) {
+                throw new Error('commitHash is required');
+            }
+            logger.info('Fetching commit diff by hash', { repoName, commitHash: requestedCommit });
+            const sanitizedCommitHash = requestedCommit.replace(/'/g, `'\\''`);
+            const commitCheck = await executeShell(`cd ${repoPath} && sudo git rev-parse --verify '${sanitizedCommitHash}^{commit}' >/dev/null 2>&1 && echo "COMMIT_OK"`);
+            if (!commitCheck.success || !(commitCheck.output || '').includes('COMMIT_OK')) {
+                throw new Error(`Commit '${requestedCommit}' not found in repository '${repoName}'`);
+            }
+            const commitInfoResult = await executeShell(`cd ${repoPath} && sudo git show --no-patch --pretty=format:"%H%x1f%h%x1f%an%x1f%ae%x1f%ad%x1f%s" --date=iso '${sanitizedCommitHash}'`);
+            if (!commitInfoResult.success) {
+                throw new Error(`Failed to fetch commit information: ${commitInfoResult.error || commitInfoResult.output || 'Unknown error'}`);
+            }
+            const commitInfo = (commitInfoResult.output || '').trim();
+            if (!commitInfo) {
+                throw new Error(`No commit metadata found for '${requestedCommit}'`);
+            }
+            const [fullHash, hash, author, email, date, ...messageParts] = commitInfo.split('\x1f');
+            const commitMessage = messageParts.join('\x1f').trim();
+            const diffResult = await executeShell(`cd ${repoPath} && sudo git show --pretty=format:"" '${sanitizedCommitHash}'`);
+            if (!diffResult.success) {
+                throw new Error(`Failed to fetch diff for commit '${requestedCommit}': ${diffResult.error || diffResult.output || 'Unknown error'}`);
+            }
+            const statsResult = await executeShell(`cd ${repoPath} && sudo git show --numstat --pretty="" '${sanitizedCommitHash}'`);
+            if (!statsResult.success) {
+                throw new Error(`Failed to fetch commit stats for '${requestedCommit}': ${statsResult.error || statsResult.output || 'Unknown error'}`);
+            }
+            const statLines = (statsResult.output || '').trim()
+                ? statsResult.output.trim().split('\n').filter((line) => line.trim())
+                : [];
+            let totalAdditions = 0;
+            let totalDeletions = 0;
+            for (const line of statLines) {
+                const [additionsRaw, deletionsRaw] = line.split('\t');
+                const additions = additionsRaw === '-' ? 0 : parseInt(additionsRaw, 10) || 0;
+                const deletions = deletionsRaw === '-' ? 0 : parseInt(deletionsRaw, 10) || 0;
+                totalAdditions += additions;
+                totalDeletions += deletions;
+            }
+            logger.success('Commit diff fetched successfully', {
+                repoName,
+                commitHash: hash,
+                filesChanged: statLines.length
+            });
+            return {
+                repoName,
+                commit: {
+                    hash: (hash || '').trim(),
+                    fullHash: (fullHash || '').trim(),
+                    author: (author || '').trim(),
+                    email: (email || '').trim(),
+                    date: (date || '').trim(),
+                    message: commitMessage
+                },
+                diff: diffResult.output || '',
+                summary: {
+                    filesChanged: statLines.length,
+                    totalAdditions,
+                    totalDeletions,
+                    totalChanges: totalAdditions + totalDeletions
+                }
+            };
+        }
+        finally {
+        }
+    }
+    /**
+     * Get commit details
+     */
+    async getCommitDetails(repoName, commitHash) {
+        const repoPath = `${tool_server_1.folderPath}/${repoName}`;
+        try {
+            logger.info('Fetching commit details', { repoName, commitHash });
+            // Get commit information and file changes in a single SSH call
+            const combinedCommand = `
+                cd ${repoPath} &&
+                COMMIT_INFO=$(sudo git show --no-patch --pretty=format:"%H|%h|%an|%ae|%ad|%s" --date=iso ${commitHash}) &&
+                FILE_STATS=$(sudo git show --stat --pretty="" --numstat ${commitHash}) &&
+                echo "COMMIT_INFO:$COMMIT_INFO" &&
+                echo "FILE_STATS_START" &&
+                echo "$FILE_STATS" &&
+                echo "FILE_STATS_END"
+            `.replace(/\n\s+/g, ' ');
+            const result = await executeShell(combinedCommand);
+            if (!result.success) {
+                throw new Error('Failed to fetch commit details');
+            }
+            // Parse commit info
+            const output = result.output;
+            const commitInfoMatch = output.match(/COMMIT_INFO:([^\n]+)/);
+            if (!commitInfoMatch) {
+                throw new Error('Failed to parse commit information');
+            }
+            const [fullHash, shortHash, author, email, date, message] = commitInfoMatch[1].split('|');
+            // Parse file statistics
+            const fileStatsMatch = output.match(/FILE_STATS_START\n([\s\S]*?)FILE_STATS_END/);
+            const fileStatsRaw = fileStatsMatch ? fileStatsMatch[1].trim() : '';
+            const modifiedFiles = [];
+            let totalAdditions = 0;
+            let totalDeletions = 0;
+            if (fileStatsRaw) {
+                const lines = fileStatsRaw.split('\n').filter((line) => line.trim());
+                for (const line of lines) {
+                    // Format: additions\tdeletions\tfilename
+                    const parts = line.split('\t');
+                    if (parts.length >= 3) {
+                        const additions = parts[0] === '-' ? 0 : parseInt(parts[0]) || 0;
+                        const deletions = parts[1] === '-' ? 0 : parseInt(parts[1]) || 0;
+                        const filename = parts[2];
+                        // Determine file status
+                        let status = 'modified';
+                        if (additions > 0 && deletions === 0) {
+                            status = 'added';
+                        }
+                        else if (additions === 0 && deletions > 0) {
+                            status = 'deleted';
+                        }
+                        else if (parts[0] === '-' && parts[1] === '-') {
+                            status = 'binary';
+                        }
+                        modifiedFiles.push({
+                            filename,
+                            additions,
+                            deletions,
+                            changes: additions + deletions,
+                            status
+                        });
+                        totalAdditions += additions;
+                        totalDeletions += deletions;
+                    }
+                }
+            }
+            logger.success('Commit details fetched successfully', {
+                repoName,
+                commitHash: shortHash,
+                filesModified: modifiedFiles.length
+            });
+            return {
+                repoName,
+                commit: {
+                    hash: shortHash,
+                    fullHash,
+                    author,
+                    email,
+                    date,
+                    message
+                },
+                files: modifiedFiles,
+                summary: {
+                    totalFiles: modifiedFiles.length,
+                    totalAdditions,
+                    totalDeletions,
+                    totalChanges: totalAdditions + totalDeletions,
+                    filesByStatus: {
+                        added: modifiedFiles.filter(f => f.status === 'added').length,
+                        modified: modifiedFiles.filter(f => f.status === 'modified').length,
+                        deleted: modifiedFiles.filter(f => f.status === 'deleted').length,
+                        binary: modifiedFiles.filter(f => f.status === 'binary').length
+                    }
+                }
+            };
+        }
+        finally {
+        }
+    }
+    // Helper function to parse conflict markers in files
+    async parseConflictMarkers(filePath, repoPath) {
+        const fs = await Promise.resolve().then(() => __importStar(require('fs')));
+        const path = await Promise.resolve().then(() => __importStar(require('path')));
+        const fullPath = path.join(repoPath, filePath);
+        const content = await fs.promises.readFile(fullPath, 'utf-8');
+        const lines = content.split('\n');
+        const conflicts = [];
+        let i = 0;
+        while (i < lines.length) {
+            if (lines[i].startsWith('<<<<<<<')) {
+                const startLine = i;
+                const currentBranch = lines[i].replace('<<<<<<< ', '').trim();
+                // Find the separator
+                let separatorLine = -1;
+                for (let j = i + 1; j < lines.length; j++) {
+                    if (lines[j].startsWith('=======')) {
+                        separatorLine = j;
+                        break;
+                    }
+                }
+                // Find the end marker
+                let endLine = -1;
+                let incomingBranch = '';
+                for (let j = separatorLine + 1; j < lines.length; j++) {
+                    if (lines[j].startsWith('>>>>>>>')) {
+                        endLine = j;
+                        incomingBranch = lines[j].replace('>>>>>>> ', '').trim();
+                        break;
+                    }
+                }
+                if (separatorLine !== -1 && endLine !== -1) {
+                    // Check if there's a base content (3-way merge marker |||||||)
+                    let baseContent;
+                    let baseMarkerLine = -1;
+                    for (let j = i + 1; j < separatorLine; j++) {
+                        if (lines[j].startsWith('|||||||')) {
+                            baseMarkerLine = j;
+                            break;
+                        }
+                    }
+                    if (baseMarkerLine !== -1) {
+                        // 3-way merge
+                        const actualCurrentContent = lines.slice(i + 1, baseMarkerLine).join('\n');
+                        baseContent = lines.slice(baseMarkerLine + 1, separatorLine).join('\n');
+                        const incomingContent = lines.slice(separatorLine + 1, endLine).join('\n');
+                        conflicts.push({
+                            startLine: startLine + 1, // 1-based line numbers
+                            endLine: endLine + 1,
+                            currentContent: actualCurrentContent,
+                            incomingContent: incomingContent,
+                            baseContent: baseContent,
+                            currentBranch: currentBranch,
+                            incomingBranch: incomingBranch
+                        });
+                    }
+                    else {
+                        // 2-way merge
+                        const currentContent = lines.slice(i + 1, separatorLine).join('\n');
+                        const incomingContent = lines.slice(separatorLine + 1, endLine).join('\n');
+                        conflicts.push({
+                            startLine: startLine + 1,
+                            endLine: endLine + 1,
+                            currentContent: currentContent,
+                            incomingContent: incomingContent,
+                            currentBranch: currentBranch,
+                            incomingBranch: incomingBranch
+                        });
+                    }
+                    i = endLine + 1;
+                }
+                else {
+                    i++;
+                }
+            }
+            else {
+                i++;
+            }
+        }
+        return conflicts;
+    }
+    async getMergeConflictsImplementation(repoName, folderPath) {
+        console.log('[Merge Conflicts] ===============================');
+        console.log('[Merge Conflicts] Checking for conflicts in repo:', repoName);
+        try {
+            const fs = await Promise.resolve().then(() => __importStar(require('fs')));
+            const path = await Promise.resolve().then(() => __importStar(require('path')));
+            // Resolve full repo path from base folderPath and repoName
+            const repoPath = path.join(folderPath, repoName);
+            console.log(`[Merge Conflicts] Resolved repo path: ${repoPath}`);
+            // Check if the repo path exists
+            if (!fs.existsSync(repoPath)) {
+                return {
+                    success: false,
+                    error: `Repository path does not exist: ${repoPath}`,
+                    folderPath: folderPath,
+                    repoName: repoName
+                };
+            }
+            // Check if it's a git repository
+            const gitPath = path.join(repoPath, '.git');
+            if (!fs.existsSync(gitPath)) {
+                return {
+                    success: false,
+                    error: `Not a git repository: ${repoPath}`,
+                    folderPath: folderPath,
+                    repoName: repoName
+                };
+            }
+            const git = (0, simple_git_1.simpleGit)(repoPath);
+            const status = await git.status();
+            const currentBranch = status.current || 'unknown';
+            console.log(`[Merge Conflicts] Current branch: ${currentBranch}`);
+            console.log(`[Merge Conflicts] Conflicted files: ${status.conflicted.length}`);
+            console.log(`[Merge Conflicts] Is merging: ${status.conflicted.length > 0 ? 'Yes' : 'No'}`);
+            if (status.conflicted.length === 0) {
+                console.log(`[Merge Conflicts] No conflicts found in repository`);
+                return {
+                    success: true,
+                    hasConflicts: false,
+                    conflicts: [],
+                    message: 'No merge conflicts detected in the repository.',
+                    currentBranch: currentBranch,
+                    folderPath: folderPath,
+                    repoName: repoName
+                };
+            }
+            const conflictFiles = [];
+            let totalConflictsCount = 0;
+            console.log(`[Merge Conflicts] Processing ${status.conflicted.length} conflicted file(s)...`);
+            for (const conflictedFile of status.conflicted) {
+                try {
+                    const fullPath = path.join(repoPath, conflictedFile);
+                    // Check if file exists
+                    if (!fs.existsSync(fullPath)) {
+                        console.warn(`[Merge Conflicts] File not found: ${conflictedFile}`);
+                        conflictFiles.push({
+                            file: conflictedFile,
+                            conflicts: [],
+                            fullContent: ''
+                        });
+                        continue;
+                    }
+                    const fullContent = await fs.promises.readFile(fullPath, 'utf-8');
+                    // Parse conflict markers
+                    const conflicts = await this.parseConflictMarkers(conflictedFile, repoPath);
+                    totalConflictsCount += conflicts.length;
+                    conflictFiles.push({
+                        file: conflictedFile,
+                        conflicts: conflicts,
+                        fullContent: fullContent
+                    });
+                    console.log(`[Merge Conflicts] File: ${conflictedFile} - ${conflicts.length} conflict block(s) found`);
+                    conflicts.forEach((conflict, index) => {
+                        console.log(`[Merge Conflicts]   Conflict #${index + 1}: Lines ${conflict.startLine}-${conflict.endLine}`);
+                        console.log(`[Merge Conflicts]     Current (${conflict.currentBranch}): ${conflict.currentContent.substring(0, 50)}...`);
+                        console.log(`[Merge Conflicts]     Incoming (${conflict.incomingBranch}): ${conflict.incomingContent.substring(0, 50)}...`);
+                    });
+                }
+                catch (parseError) {
+                    console.error(`[Merge Conflicts] Error parsing ${conflictedFile}:`, parseError);
+                    conflictFiles.push({
+                        file: conflictedFile,
+                        conflicts: [],
+                        fullContent: ''
+                    });
+                }
+            }
+            console.log(`[Merge Conflicts] Summary: ${conflictFiles.length} file(s) with ${totalConflictsCount} total conflict block(s)`);
+            // Send response with all conflict information
+            return {
+                success: true,
+                hasConflicts: true,
+                conflicts: conflictFiles,
+                message: `Found ${totalConflictsCount} conflict block(s) in ${conflictFiles.length} file(s).`,
+                currentBranch: currentBranch,
+                totalFiles: conflictFiles.length,
+                totalConflicts: totalConflictsCount,
+                folderPath: folderPath,
+                repoName: repoName
+            };
+        }
+        catch (error) {
+            console.error('[Merge Conflicts] Error checking for conflicts:', error);
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'Unknown error occurred while checking for merge conflicts',
+                folderPath: folderPath,
+                repoName: repoName
+            };
+        }
+    }
+    /**
+     * Helper method to get merge conflicts
+     */
+    async getMergeConflicts(socket, repoName) {
+        return new Promise((resolve) => {
+            this.getMergeConflictsImplementation(repoName, tool_server_1.folderPath).then((mergeData) => {
+                resolve(mergeData);
+            }).catch((error) => {
+                console.error('Error in getMergeConflictsImplementation:', error);
+                resolve({
+                    success: false,
+                    error: error instanceof Error ? error.message : 'Unknown error occurred while getting merge conflicts',
+                    folderPath: tool_server_1.folderPath,
+                    repoName: repoName
+                });
+            });
+        });
+    }
+}
+exports.GithubOperationsService = GithubOperationsService;
+//# sourceMappingURL=githubOperationsHanlder.js.map