phantomx-tool-client 1.0.7 → 1.0.9

package/dist/githubOperationsHanlder.js

@@ -40,6 +40,8 @@ exports.getRepoList = getRepoList;
 exports.getRepoBranch = getRepoBranch;
 const Logger_1 = require("./Services/Logger");
 const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
 // ---------------------------------------------------------------------------
 // Local bash executor — drop-in replacement for ssh.executeCommand()
 // Returns { success, output, error, code } matching the SSH client response.
@@ -127,6 +129,34 @@ function getFileStats(fileStats) {
     }
     return { insertions: 0, deletions: 0 };
 }
+// Helper: recursively find all git repositories under a root path (max depth 10)
+async function findGitRepositories(rootPath) {
+    const fs = await Promise.resolve().then(() => __importStar(require('fs')));
+    const pathModule = await Promise.resolve().then(() => __importStar(require('path')));
+    const repositories = [];
+    async function searchDirectory(currentPath, depth = 0) {
+        if (depth > 10)
+            return;
+        try {
+            const items = await fs.promises.readdir(currentPath, { withFileTypes: true });
+            const gitPath = pathModule.join(currentPath, '.git');
+            if (fs.existsSync(gitPath)) {
+                repositories.push(currentPath);
+                return; // don't recurse inside a git repo looking for nested repos
+            }
+            for (const item of items) {
+                if (item.isDirectory() && !item.name.startsWith('.') && item.name !== 'node_modules') {
+                    await searchDirectory(pathModule.join(currentPath, item.name), depth + 1);
+                }
+            }
+        }
+        catch {
+            // skip directories we can't read
+        }
+    }
+    await searchDirectory(rootPath);
+    return repositories;
+}
 async function getRepositoryChangesMetadataOnly(repoPath) {
     const pathModule = await Promise.resolve().then(() => __importStar(require('path')));
     const fs = await Promise.resolve().then(() => __importStar(require('fs')));
@@ -285,6 +315,246 @@ async function getSingleFileDiff(repoPath, filePath, status) {
     }
 }
 class GithubOperationsService {
+    constructor(localWorkspacePath) {
+        this.localWorkspacePath = localWorkspacePath;
+    }
+    resolveWorkspacePath(targetPath) {
+        const workspace = path.resolve(this.localWorkspacePath || tool_server_1.folderPath);
+        const resolved = targetPath
+            ? path.resolve(path.isAbsolute(targetPath) ? targetPath : path.join(workspace, targetPath))
+            : workspace;
+        const relative = path.relative(workspace, resolved);
+        if (relative.startsWith('..') || path.isAbsolute(relative)) {
+            throw new Error(`Path is outside the workspace: ${targetPath}`);
+        }
+        return resolved;
+    }
+    resolveLocalRepository(repoPathOrName) {
+        const candidate = path.isAbsolute(repoPathOrName)
+            ? repoPathOrName
+            : path.join(this.localWorkspacePath || tool_server_1.folderPath, repoPathOrName);
+        const repoPath = this.resolveWorkspacePath(candidate);
+        if (!fs.existsSync(repoPath)) {
+            throw new Error(`Repository path does not exist: ${repoPath}`);
+        }
+        if (!fs.existsSync(path.join(repoPath, '.git'))) {
+            throw new Error(`Not a git repository: ${repoPath}`);
+        }
+        return repoPath;
+    }
+    async findLocalGitRepositories(rootPath) {
+        const repositories = [];
+        const search = async (currentPath, depth) => {
+            if (depth > 10)
+                return;
+            if (fs.existsSync(path.join(currentPath, '.git'))) {
+                repositories.push(currentPath);
+                return;
+            }
+            let entries;
+            try {
+                entries = await fs.promises.readdir(currentPath, { withFileTypes: true });
+            }
+            catch {
+                logger.warn(`Cannot read directory: ${currentPath}`);
+                return;
+            }
+            for (const entry of entries) {
+                if (!entry.isDirectory() || entry.name.startsWith('.') || entry.name === 'node_modules')
+                    continue;
+                await search(path.join(currentPath, entry.name), depth + 1);
+            }
+        };
+        await search(rootPath, 0);
+        return repositories;
+    }
+    getDiffStats(fileStats) {
+        return {
+            insertions: Number(fileStats === null || fileStats === void 0 ? void 0 : fileStats.insertions) || 0,
+            deletions: Number(fileStats === null || fileStats === void 0 ? void 0 : fileStats.deletions) || 0
+        };
+    }
+    async getLocalRepositoryChanges(repoPath) {
+        const git = (0, simple_git_1.simpleGit)(repoPath);
+        const status = await git.status();
+        const stagedSummary = await git.diffSummary(['--cached']);
+        const unstagedSummary = await git.diffSummary();
+        const changes = [];
+        const processed = new Set();
+        const addChange = (file, statusCode, insertions, deletions) => {
+            changes.push({ file, status: statusCode, insertions, deletions, changes: insertions + deletions });
+            processed.add(file);
+        };
+        for (const file of status.modified) {
+            const isStaged = status.staged.includes(file);
+            const unstaged = this.getDiffStats(unstagedSummary.files.find(item => item.file === file));
+            const staged = isStaged
+                ? this.getDiffStats(stagedSummary.files.find(item => item.file === file))
+                : { insertions: 0, deletions: 0 };
+            addChange(file, isStaged ? 'MM' : 'M', unstaged.insertions + staged.insertions, unstaged.deletions + staged.deletions);
+        }
+        for (const file of status.staged) {
+            if (processed.has(file) || status.deleted.includes(file))
+                continue;
+            const stats = this.getDiffStats(stagedSummary.files.find(item => item.file === file));
+            addChange(file, 'A', stats.insertions, stats.deletions);
+        }
+        for (const file of status.not_added) {
+            if (processed.has(file))
+                continue;
+            try {
+                const stat = await fs.promises.stat(path.join(repoPath, file));
+                addChange(file, '?', Math.max(1, Math.ceil(stat.size / 50)), 0);
+            }
+            catch {
+                addChange(file, '?', 1, 0);
+            }
+        }
+        for (const file of status.created || []) {
+            if (processed.has(file))
+                continue;
+            try {
+                const stat = await fs.promises.stat(path.join(repoPath, file));
+                addChange(file, '?', Math.max(1, Math.ceil(stat.size / 50)), 0);
+            }
+            catch {
+                addChange(file, '?', 1, 0);
+            }
+        }
+        for (const file of status.deleted) {
+            if (processed.has(file))
+                continue;
+            const summary = status.staged.includes(file) ? stagedSummary : unstagedSummary;
+            const stats = this.getDiffStats(summary.files.find(item => item.file === file));
+            addChange(file, 'D', 0, stats.deletions || 1);
+        }
+        for (const rename of status.renamed) {
+            if (processed.has(rename.to))
+                continue;
+            const staged = this.getDiffStats(stagedSummary.files.find(item => item.file === rename.to));
+            const unstaged = this.getDiffStats(unstagedSummary.files.find(item => item.file === rename.to));
+            addChange(rename.to, 'R', staged.insertions + unstaged.insertions, staged.deletions + unstaged.deletions);
+        }
+        const totalInsertions = changes.reduce((total, change) => total + change.insertions, 0);
+        const totalDeletions = changes.reduce((total, change) => total + change.deletions, 0);
+        return {
+            repoName: path.basename(repoPath),
+            repoPath,
+            changes,
+            summary: {
+                totalFiles: changes.length,
+                totalInsertions,
+                totalDeletions,
+                totalChanges: totalInsertions + totalDeletions
+            }
+        };
+    }
+    async getGitChanges(requestedPath) {
+        try {
+            const rootPath = this.resolveWorkspacePath(requestedPath);
+            if (!fs.existsSync(rootPath)) {
+                return { success: false, error: `Path does not exist: ${rootPath}` };
+            }
+            const repoPaths = await this.findLocalGitRepositories(rootPath);
+            if (repoPaths.length === 0) {
+                return { success: false, error: `No git repositories found in: ${rootPath}` };
+            }
+            const repositories = [];
+            for (const repoPath of repoPaths) {
+                try {
+                    repositories.push(await this.getLocalRepositoryChanges(repoPath));
+                }
+                catch (error) {
+                    logger.error(`Failed to inspect repository ${repoPath}`, error);
+                }
+            }
+            const totalFiles = repositories.reduce((total, repo) => total + repo.summary.totalFiles, 0);
+            const totalInsertions = repositories.reduce((total, repo) => total + repo.summary.totalInsertions, 0);
+            const totalDeletions = repositories.reduce((total, repo) => total + repo.summary.totalDeletions, 0);
+            return {
+                success: true,
+                repositories,
+                overallSummary: {
+                    totalRepositories: repositories.length,
+                    totalFiles,
+                    totalInsertions,
+                    totalDeletions,
+                    totalChanges: totalInsertions + totalDeletions
+                }
+            };
+        }
+        catch (error) {
+            return { success: false, error: error instanceof Error ? error.message : String(error) };
+        }
+    }
+    async getFileDiff(repoPathOrName, filePath, statusCode) {
+        const repoPath = this.resolveLocalRepository(repoPathOrName);
+        const fullFilePath = this.resolveWorkspacePath(path.join(repoPath, filePath));
+        const relativeFilePath = path.relative(repoPath, fullFilePath);
+        if (relativeFilePath.startsWith('..') || path.isAbsolute(relativeFilePath)) {
+            throw new Error(`File is outside the repository: ${filePath}`);
+        }
+        const git = (0, simple_git_1.simpleGit)(repoPath);
+        let diff = '';
+        if (statusCode === 'MM') {
+            const staged = await git.diff(['--cached', relativeFilePath]);
+            const unstaged = await git.diff([relativeFilePath]);
+            diff = `--- STAGED CHANGES ---\n${staged}\n\n--- UNSTAGED CHANGES ---\n${unstaged}`;
+        }
+        else if (statusCode === 'A') {
+            diff = await git.diff(['--cached', relativeFilePath]);
+        }
+        else if (statusCode === '?') {
+            if (fs.existsSync(fullFilePath)) {
+                const lines = (await fs.promises.readFile(fullFilePath, 'utf8')).split('\n');
+                diff = `+++ b/${relativeFilePath}\n@@ -0,0 +1,${lines.length} @@\n${lines.map(line => `+${line}`).join('\n')}\n`;
+            }
+        }
+        else if (statusCode === 'D') {
+            const currentStatus = await git.status();
+            const args = currentStatus.staged.includes(relativeFilePath)
+                ? ['--cached', 'HEAD', relativeFilePath]
+                : ['HEAD', relativeFilePath];
+            diff = await git.diff(args).catch(() => '');
+        }
+        else {
+            diff = await git.diff([relativeFilePath]);
+        }
+        return { success: true, diff, filePath: relativeFilePath, repoPath };
+    }
+    async discardFileChanges(repoPathOrName, filePath) {
+        const repoPath = this.resolveLocalRepository(repoPathOrName);
+        const fullFilePath = this.resolveWorkspacePath(path.join(repoPath, filePath));
+        const relativeFilePath = path.relative(repoPath, fullFilePath);
+        if (relativeFilePath.startsWith('..') || path.isAbsolute(relativeFilePath)) {
+            throw new Error(`File is outside the repository: ${filePath}`);
+        }
+        const git = (0, simple_git_1.simpleGit)(repoPath);
+        const status = await git.status();
+        const isUntracked = status.not_added.includes(relativeFilePath) || (status.created || []).includes(relativeFilePath);
+        if (isUntracked) {
+            if (!fs.existsSync(fullFilePath)) {
+                return { success: false, error: `File '${relativeFilePath}' does not exist.` };
+            }
+            const stat = await fs.promises.lstat(fullFilePath);
+            if (!stat.isFile()) {
+                return { success: false, error: `Only untracked files can be discarded: ${relativeFilePath}` };
+            }
+            await fs.promises.unlink(fullFilePath);
+            return { success: true, message: `Untracked file '${relativeFilePath}' has been removed.` };
+        }
+        const hasChanges = status.modified.includes(relativeFilePath)
+            || status.staged.includes(relativeFilePath)
+            || status.deleted.includes(relativeFilePath);
+        if (!hasChanges) {
+            return { success: false, error: `File '${relativeFilePath}' has no changes to discard.` };
+        }
+        if (status.staged.includes(relativeFilePath)) {
+            await git.reset(['HEAD', relativeFilePath]);
+        }
+        await git.checkout(['HEAD', '--', relativeFilePath]);
+        return { success: true, message: `Changes to '${relativeFilePath}' have been discarded.` };
+    }
     escapeSingleQuotedShell(value) {
         return value.replace(/'/g, `'\\''`);
     }
@@ -411,21 +681,21 @@ class GithubOperationsService {
         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"
+            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) {
@@ -468,23 +738,23 @@ class GithubOperationsService {
         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"
+            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) {
@@ -681,23 +951,23 @@ class GithubOperationsService {
             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"
+            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) {
@@ -782,20 +1052,20 @@ class GithubOperationsService {
         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
+            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 || '';
@@ -992,20 +1262,20 @@ class GithubOperationsService {
             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
+            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) {
@@ -1103,16 +1373,16 @@ class GithubOperationsService {
         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 --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) &&
-                sudo git remote set-url origin https://github.com/${gitOrgName}/${repoName}.git &&
-                echo "HEAD_BRANCH:$HEAD_BRANCH" &&
-                echo "COMMITS_AHEAD:$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 --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) &&
+                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
@@ -1387,14 +1657,14 @@ class GithubOperationsService {
         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"
+            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) {
@@ -1688,144 +1958,6 @@ class GithubOperationsService {
             });
         });
     }
-    // ── New git operations ─────────────────────────────────────────────────────
-    /**
-     * Get all uncommitted git changes (metadata only, no diffs) for a repository.
-     * Accepts repoName (looked up under folderPath) or a full absolute repoPath.
-     */
-    async getGitChanges(repoName) {
-        const pathModule = await Promise.resolve().then(() => __importStar(require('path')));
-        const fs = await Promise.resolve().then(() => __importStar(require('fs')));
-        logger.info(`[getGitChanges] repoName: ${repoName}`);
-        try {
-            // Resolve the repo path: treat as absolute if it starts with '/', otherwise join with folderPath
-            let repoPath = pathModule.isAbsolute(repoName)
-                ? repoName
-                : pathModule.join(tool_server_1.folderPath, repoName);
-            if (!fs.existsSync(repoPath)) {
-                return { success: false, error: `Repository path does not exist: ${repoPath}` };
-            }
-            const gitDir = pathModule.join(repoPath, '.git');
-            if (!fs.existsSync(gitDir)) {
-                return { success: false, error: `Not a git repository: ${repoPath}` };
-            }
-            logger.info(`[getGitChanges] Fetching metadata for repo: ${repoPath}`);
-            const repoData = await getRepositoryChangesMetadataOnly(repoPath);
-            return {
-                success: true,
-                repositories: [repoData],
-                overallSummary: {
-                    totalRepositories: 1,
-                    totalFiles: repoData.summary.totalFiles,
-                    totalInsertions: repoData.summary.totalInsertions,
-                    totalDeletions: repoData.summary.totalDeletions,
-                    totalChanges: repoData.summary.totalChanges
-                }
-            };
-        }
-        catch (error) {
-            logger.error('[getGitChanges] Error:', error);
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : 'Unknown error occurred while getting git changes'
-            };
-        }
-    }
-    /**
-     * Get the unified diff for a single file in a repository.
-     * status codes: 'M' modified, 'MM' modified+staged, 'A' added/staged,
-     *               '?' untracked, 'D' deleted, 'R' renamed
-     */
-    async getFileDiff(repoName, filePath, status) {
-        const pathModule = await Promise.resolve().then(() => __importStar(require('path')));
-        const fs = await Promise.resolve().then(() => __importStar(require('fs')));
-        logger.info(`[getFileDiff] repoName: ${repoName} | filePath: ${filePath} | status: ${status}`);
-        try {
-            let repoPath = pathModule.isAbsolute(repoName)
-                ? repoName
-                : pathModule.join(tool_server_1.folderPath, repoName);
-            if (!fs.existsSync(repoPath)) {
-                return { success: false, error: `Repository path does not exist: ${repoPath}`, filePath, repoPath };
-            }
-            const result = await getSingleFileDiff(repoPath, filePath, status);
-            logger.success(`[getFileDiff] Retrieved diff for ${filePath} (${(result.diff || '').length} chars)`);
-            return result;
-        }
-        catch (error) {
-            logger.error('[getFileDiff] Error:', error);
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : 'Unknown error occurred while getting file diff',
-                filePath,
-                repoPath: repoName
-            };
-        }
-    }
-    /**
-     * Discard changes for a single file in a repository.
-     * - Untracked / created files: physically deleted from disk.
-     * - Modified / staged / deleted files: unstaged if needed, then restored from HEAD.
-     */
-    async discardFileChanges(repoName, filePath) {
-        const pathModule = await Promise.resolve().then(() => __importStar(require('path')));
-        const fs = await Promise.resolve().then(() => __importStar(require('fs')));
-        logger.info(`[discardFileChanges] repoName: ${repoName} | filePath: ${filePath}`);
-        try {
-            const repoPath = pathModule.isAbsolute(repoName)
-                ? repoName
-                : pathModule.join(tool_server_1.folderPath, repoName);
-            if (!fs.existsSync(repoPath)) {
-                return { success: false, error: `Repository path does not exist: ${repoPath}` };
-            }
-            const gitDir = pathModule.join(repoPath, '.git');
-            if (!fs.existsSync(gitDir)) {
-                return { success: false, error: `Not a git repository: ${repoPath}` };
-            }
-            const git = (0, simple_git_1.simpleGit)(repoPath);
-            const status = await git.status();
-            const isModified = status.modified.includes(filePath);
-            const isStaged = status.staged.includes(filePath);
-            const isDeleted = status.deleted.includes(filePath);
-            const isCreated = status.not_added.includes(filePath) || ((status.created || []).includes(filePath));
-            const fullFilePath = pathModule.join(repoPath, filePath);
-            const fileExistsOnDisk = fs.existsSync(fullFilePath);
-            logger.info(`[discardFileChanges] flags — modified:${isModified} staged:${isStaged} deleted:${isDeleted} created:${isCreated} existsOnDisk:${fileExistsOnDisk}`);
-            if (isCreated) {
-                // Untracked file — remove from disk
-                if (fileExistsOnDisk) {
-                    await fs.promises.unlink(fullFilePath);
-                    logger.success(`[discardFileChanges] Untracked file removed: ${filePath}`);
-                    return { success: true, message: `Untracked file '${filePath}' has been removed.` };
-                }
-                else {
-                    return { success: false, error: `File '${filePath}' does not exist on disk.` };
-                }
-            }
-            if (isModified || isStaged || isDeleted) {
-                try {
-                    if (isStaged) {
-                        await git.reset(['HEAD', filePath]);
-                        logger.info(`[discardFileChanges] Unstaged: ${filePath}`);
-                    }
-                    await git.checkout(['HEAD', '--', filePath]);
-                    logger.success(`[discardFileChanges] Restored from HEAD: ${filePath}`);
-                    return { success: true, message: `Changes to '${filePath}' have been discarded.` };
-                }
-                catch (checkoutError) {
-                    logger.error('[discardFileChanges] git checkout error:', checkoutError);
-                    return { success: false, error: `Failed to discard changes: ${checkoutError.message}` };
-                }
-            }
-            return { success: false, error: `File '${filePath}' has no changes to discard.` };
-        }
-        catch (error) {
-            logger.error('[discardFileChanges] Error:', error);
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : 'Unknown error occurred while discarding changes'
-            };
-        }
-    }
 }
 exports.GithubOperationsService = GithubOperationsService;
 //# sourceMappingURL=githubOperationsHanlder.js.map