@andrebuzeli/git-mcp 10.0.6 → 10.0.8

package/dist/tools/gitPulls.js

@@ -75,9 +75,9 @@ export class GitPullsTool {
         if (!projectPath)
             throw new MCPError('VALIDATION_ERROR', 'projectPath is required');
         const repoInfo = getRepoInfo(projectPath);
-        const repo = repoInfo.repoName;
-        const githubOwner = repoInfo.githubOwner || process.env.GITHUB_USERNAME;
-        const giteaOwner = repoInfo.giteaOwner || process.env.GITEA_USERNAME;
+        const repo = params.repo || repoInfo.repoName;
+        const githubOwner = params.owner || repoInfo.githubOwner || process.env.GITHUB_USERNAME;
+        const giteaOwner = params.owner || repoInfo.giteaOwner || process.env.GITEA_USERNAME;
         switch (action) {
             case 'create': {
                 if (!params.title || !params.head || !params.base) {
@@ -152,7 +152,7 @@ export class GitPullsTool {
                 return results;
             }
             case 'get': {
-                const pull_number = params.pull_number;
+                const pull_number = params.pull_number || params.pullNumber;
                 if (!pull_number)
                     throw new MCPError('VALIDATION_ERROR', 'pull_number is required');
                 const results = { success: true, providers: {} };
@@ -183,7 +183,7 @@ export class GitPullsTool {
                 return results;
             }
             case 'update': {
-                const pull_number = params.pull_number;
+                const pull_number = params.pull_number || params.pullNumber;
                 if (!pull_number)
                     throw new MCPError('VALIDATION_ERROR', 'pull_number is required');
                 const results = { success: true, providers: {} };
@@ -217,7 +217,7 @@ export class GitPullsTool {
                 return results;
             }
             case 'merge': {
-                const pull_number = params.pull_number;
+                const pull_number = params.pull_number || params.pullNumber;
                 if (!pull_number)
                     throw new MCPError('VALIDATION_ERROR', 'pull_number is required');
                 const results = { success: true, providers: {} };
@@ -255,7 +255,7 @@ export class GitPullsTool {
                 return results;
             }
             case 'close': {
-                const pull_number = params.pull_number;
+                const pull_number = params.pull_number || params.pullNumber;
                 if (!pull_number)
                     throw new MCPError('VALIDATION_ERROR', 'pull_number is required');
                 const results = { success: true, providers: {} };
@@ -287,7 +287,7 @@ export class GitPullsTool {
                 return results;
             }
             case 'review': {
-                const pull_number = params.pull_number;
+                const pull_number = params.pull_number || params.pullNumber;
                 const event = params.event;
                 if (!pull_number || !event) {
                     throw new MCPError('VALIDATION_ERROR', 'pull_number and event are required');

package/dist/tools/gitRelease.js

@@ -1,4 +1,3 @@
-import simpleGit from 'simple-git';
 import { MCPError } from '../utils/errors.js';
 import { normalizeToolParams, getRepoInfo } from '../utils/repoHelpers.js';
 import axios from 'axios';
@@ -59,16 +58,16 @@ export class GitReleaseTool {
         if (!projectPath)
             throw new MCPError('VALIDATION_ERROR', 'projectPath is required');
         const repoInfo = getRepoInfo(projectPath);
-        const repo = repoInfo.repoName;
-        const githubOwner = repoInfo.githubOwner || process.env.GITHUB_USERNAME;
-        const giteaOwner = repoInfo.giteaOwner || process.env.GITEA_USERNAME;
+        const repo = params.repo || repoInfo.repoName;
+        const githubOwner = params.owner || repoInfo.githubOwner || process.env.GITHUB_USERNAME;
+        const giteaOwner = params.owner || repoInfo.giteaOwner || process.env.GITEA_USERNAME;
         switch (action) {
             case 'create': {
                 const tagName = params.tagName;
                 if (!tagName)
                     throw new MCPError('VALIDATION_ERROR', 'tagName is required');
-                const git = simpleGit({ baseDir: projectPath });
-                await git.addAnnotatedTag(tagName, params.description || tagName);
+                const git = ctx.gitAdapter;
+                await git.createTag(projectPath, tagName, 'HEAD', params.description || tagName);
                 const results = { success: true, localTag: tagName, providers: {} };
                 if (ctx.providerManager.github) {
                     try {

package/dist/tools/gitRemote.d.ts

@@ -30,45 +30,18 @@ export declare class GitRemoteTool implements Tool {
         remote: any;
         url: any;
         removed?: undefined;
-        renamed?: undefined;
-        to?: undefined;
         remotes?: undefined;
-        pruned?: undefined;
     } | {
         success: boolean;
         removed: any;
         remote?: undefined;
         url?: undefined;
-        renamed?: undefined;
-        to?: undefined;
         remotes?: undefined;
-        pruned?: undefined;
     } | {
         success: boolean;
-        renamed: any;
-        to: any;
+        remotes: import("../utils/gitAdapter.js").RemoteInfo[];
         remote?: undefined;
         url?: undefined;
         removed?: undefined;
-        remotes?: undefined;
-        pruned?: undefined;
-    } | {
-        success: boolean;
-        remotes: import("simple-git").RemoteWithoutRefs[];
-        remote?: undefined;
-        url?: undefined;
-        removed?: undefined;
-        renamed?: undefined;
-        to?: undefined;
-        pruned?: undefined;
-    } | {
-        success: boolean;
-        pruned: any;
-        remote?: undefined;
-        url?: undefined;
-        removed?: undefined;
-        renamed?: undefined;
-        to?: undefined;
-        remotes?: undefined;
     }>;
 }

package/dist/tools/gitRemote.js

@@ -1,4 +1,3 @@
-import simpleGit from 'simple-git';
 import { MCPError } from '../utils/errors.js';
 import { getRepoInfo, buildGitHubUrl, buildGiteaUrl } from '../utils/repoHelpers.js';
 export class GitRemoteTool {
@@ -35,10 +34,12 @@ export class GitRemoteTool {
         if (!action || !projectPath) {
             throw new MCPError('VALIDATION_ERROR', 'action and projectPath are required');
         }
-        const git = simpleGit({ baseDir: projectPath });
+        if (!ctx.gitAdapter) {
+            throw new MCPError('INTERNAL_ERROR', 'Git adapter not available');
+        }
         switch (action) {
             case 'add': {
-                const name = params.name || 'origin';
+                const name = params.remoteName || 'origin';
                 let url = params.url;
                 // Auto-construct URL if not provided
                 if (!url) {
@@ -57,31 +58,22 @@ export class GitRemoteTool {
                         throw new MCPError('VALIDATION_ERROR', 'url is required or set GITHUB_USERNAME/GITEA_USERNAME in environment');
                     }
                 }
-                await git.addRemote(name, url);
+                await ctx.gitAdapter.addRemote(projectPath, name, url);
                 return { success: true, remote: name, url };
             }
             case 'remove': {
-                const name = params.name;
+                const name = params.remoteName;
                 if (!name)
-                    throw new MCPError('VALIDATION_ERROR', 'name is required');
-                await git.removeRemote(name);
+                    throw new MCPError('VALIDATION_ERROR', 'remoteName is required');
+                await ctx.gitAdapter.removeRemote(projectPath, name);
                 return { success: true, removed: name };
             }
-            case 'rename': {
-                const name = params.name;
-                const newName = params.newName;
-                if (!name || !newName)
-                    throw new MCPError('VALIDATION_ERROR', 'name and newName are required');
-                await git.remote(['rename', name, newName]);
-                return { success: true, renamed: name, to: newName };
-            }
-            case 'show':
             case 'list': {
-                const remotes = await git.getRemotes(params.verbose);
+                const remotes = await ctx.gitAdapter.listRemotes(projectPath);
                 return { success: true, remotes };
             }
             case 'set-url': {
-                const name = params.name || 'origin';
+                const name = params.remoteName || 'origin';
                 let url = params.url;
                 // Auto-construct URL if not provided
                 if (!url) {
@@ -100,13 +92,17 @@ export class GitRemoteTool {
                         throw new MCPError('VALIDATION_ERROR', 'url is required or set GITHUB_USERNAME/GITEA_USERNAME in environment');
                     }
                 }
-                await git.remote(['set-url', name, url]);
+                // Use setConfig to update remote URL
+                await ctx.gitAdapter.setConfig(projectPath, `remote.${name}.url`, url);
                 return { success: true, remote: name, url };
             }
-            case 'prune': {
-                const name = params.name || 'origin';
-                await git.remote(['prune', name]);
-                return { success: true, pruned: name };
+            case 'get-url': {
+                const name = params.remoteName || 'origin';
+                const url = await ctx.gitAdapter.getConfig(projectPath, `remote.${name}.url`);
+                if (!url) {
+                    throw new MCPError('NOT_FOUND', `Remote '${name}' not found`);
+                }
+                return { success: true, remote: name, url };
             }
             default:
                 throw new MCPError('VALIDATION_ERROR', `Unsupported action: ${action}`);

package/dist/tools/gitReset.js

@@ -1,4 +1,3 @@
-import simpleGit from 'simple-git';
 import { MCPError } from '../utils/errors.js';
 import { requireConfirmationIfDestructive } from '../utils/safetyController.js';
 export class GitResetTool {
@@ -36,21 +35,21 @@ export class GitResetTool {
             throw new MCPError('VALIDATION_ERROR', 'action and projectPath are required');
         }
         requireConfirmationIfDestructive(action, params);
-        const git = simpleGit({ baseDir: projectPath });
+        const git = ctx.gitAdapter;
         switch (action) {
             case 'soft': {
                 const target = params.target || 'HEAD~1';
-                await git.reset(['--soft', target]);
+                await git.reset(projectPath, target, 'soft');
                 return { success: true, mode: 'soft', target };
             }
             case 'mixed': {
                 const target = params.target || 'HEAD~1';
-                await git.reset(['--mixed', target]);
+                await git.reset(projectPath, target, 'mixed');
                 return { success: true, mode: 'mixed', target };
             }
             case 'hard': {
                 const target = params.target || 'HEAD~1';
-                await git.reset(['--hard', target]);
+                await git.reset(projectPath, target, 'hard');
                 return {
                     success: true,
                     mode: 'hard',
@@ -63,14 +62,14 @@ export class GitResetTool {
                 if (!commit)
                     throw new MCPError('VALIDATION_ERROR', 'commit is required');
                 const mode = params.mode || 'mixed';
-                await git.reset([`--${mode}`, commit]);
+                await git.reset(projectPath, commit, mode);
                 return { success: true, mode, commit };
             }
             case 'reset-branch': {
                 const branch = params.branch;
                 if (!branch)
                     throw new MCPError('VALIDATION_ERROR', 'branch is required');
-                await git.reset(['--hard', `origin/${branch}`]);
+                await git.reset(projectPath, `origin/${branch}`, 'hard');
                 return { success: true, branch, warning: 'Branch reset to match origin' };
             }
             default:

package/dist/tools/gitStash.d.ts

@@ -38,28 +38,18 @@ export declare class GitStashTool implements Tool {
         message: string;
         stash?: undefined;
         stashes?: undefined;
-        details?: undefined;
         dropped?: undefined;
     } | {
         success: boolean;
         stash: any;
         message: string;
         stashes?: undefined;
-        details?: undefined;
         dropped?: undefined;
     } | {
         success: boolean;
-        stashes: readonly (import("simple-git").DefaultLogFields & import("simple-git").ListLogLine)[];
+        stashes: import("../utils/gitAdapter.js").StashEntry[];
         message?: undefined;
         stash?: undefined;
-        details?: undefined;
-        dropped?: undefined;
-    } | {
-        success: boolean;
-        stash: any;
-        details: string;
-        message?: undefined;
-        stashes?: undefined;
         dropped?: undefined;
     } | {
         success: boolean;
@@ -67,6 +57,5 @@ export declare class GitStashTool implements Tool {
         message?: undefined;
         stash?: undefined;
         stashes?: undefined;
-        details?: undefined;
     }>;
 }

package/dist/tools/gitStash.js

@@ -1,4 +1,3 @@
-import simpleGit from 'simple-git';
 import { MCPError } from '../utils/errors.js';
 export class GitStashTool {
     constructor() {
@@ -42,46 +41,36 @@ export class GitStashTool {
         if (!action || !projectPath) {
             throw new MCPError('VALIDATION_ERROR', 'action and projectPath are required');
         }
-        const git = simpleGit({ baseDir: projectPath });
+        const git = ctx.gitAdapter;
         switch (action) {
-            case 'stash': {
+            case 'save':
+            case 'stash': { // Support both for compatibility
                 const message = params.message;
-                const options = [];
-                if (params.includeUntracked)
-                    options.push('-u');
-                if (params.keepIndex)
-                    options.push('--keep-index');
-                if (message)
-                    options.push('-m', message);
-                await git.stash(['push', ...options]);
+                const includeUntracked = params.includeUntracked;
+                await git.saveStash(projectPath, message, includeUntracked);
                 return { success: true, message: 'Changes stashed' };
             }
             case 'pop': {
                 const stashRef = params.stashRef || 'stash@{0}';
-                await git.stash(['pop', stashRef]);
+                await git.popStash(projectPath, stashRef);
                 return { success: true, stash: stashRef, message: 'Stash applied and removed' };
             }
             case 'apply': {
                 const stashRef = params.stashRef || 'stash@{0}';
-                await git.stash(['apply', stashRef]);
+                await git.applyStash(projectPath, stashRef);
                 return { success: true, stash: stashRef, message: 'Stash applied (kept in list)' };
             }
             case 'list': {
-                const result = await git.stashList();
-                return { success: true, stashes: result.all };
-            }
-            case 'show': {
-                const stashRef = params.stashRef || 'stash@{0}';
-                const result = await git.show([stashRef]);
-                return { success: true, stash: stashRef, details: result };
+                const stashes = await git.listStash(projectPath);
+                return { success: true, stashes };
             }
             case 'drop': {
                 const stashRef = params.stashRef || 'stash@{0}';
-                await git.stash(['drop', stashRef]);
+                await git.dropStash(projectPath, stashRef);
                 return { success: true, dropped: stashRef };
             }
             case 'clear': {
-                await git.stash(['clear']);
+                await git.clearStash(projectPath);
                 return { success: true, message: 'All stashes cleared' };
             }
             default:

package/dist/tools/gitSync.js

@@ -1,4 +1,3 @@
-import simpleGit from 'simple-git';
 import { MCPError } from '../utils/errors.js';
 export class GitSyncTool {
     constructor() {
@@ -39,12 +38,14 @@ export class GitSyncTool {
         if (!action || !projectPath) {
             throw new MCPError('VALIDATION_ERROR', 'action and projectPath are required');
         }
-        const git = simpleGit({ baseDir: projectPath });
+        if (!ctx.gitAdapter) {
+            throw new MCPError('INTERNAL_ERROR', 'Git adapter not available');
+        }
         switch (action) {
             case 'fetch': {
                 const remote = params.remote || 'origin';
                 try {
-                    await git.fetch(remote);
+                    await ctx.gitAdapter.fetch(projectPath, remote);
                     return { success: true, projectPath, remote, action: 'fetch' };
                 }
                 catch (err) {
@@ -53,15 +54,13 @@ export class GitSyncTool {
             }
             case 'pull': {
                 const remote = params.remote || 'origin';
-                const branch = params.branch;
+                let branch = params.branch;
                 try {
-                    if (branch) {
-                        await git.pull(remote, branch);
-                    }
-                    else {
-                        await git.pull(remote);
+                    if (!branch) {
+                        branch = await ctx.gitAdapter.getCurrentBranch(projectPath);
                     }
-                    return { success: true, projectPath, remote, branch: branch || 'current', action: 'pull' };
+                    await ctx.gitAdapter.pull(projectPath, remote, branch);
+                    return { success: true, projectPath, remote, branch, action: 'pull' };
                 }
                 catch (err) {
                     throw new MCPError('PULL_ERROR', `Failed to pull from ${remote}: ${err.message}`);
@@ -69,16 +68,20 @@ export class GitSyncTool {
             }
             case 'push': {
                 const remote = params.remote || 'origin';
-                const branch = params.branch;
+                let branch = params.branch;
+                const force = params.force || false;
                 try {
-                    const pushResult = await git.push(remote, branch);
+                    if (!branch) {
+                        branch = await ctx.gitAdapter.getCurrentBranch(projectPath);
+                    }
+                    await ctx.gitAdapter.push(projectPath, remote, branch, force);
                     return {
                         success: true,
                         projectPath,
                         remote,
-                        branch: branch || 'current',
+                        branch,
                         action: 'push',
-                        result: pushResult
+                        message: 'Push successful'
                     };
                 }
                 catch (err) {
@@ -87,14 +90,20 @@ export class GitSyncTool {
             }
             case 'sync': {
                 const remote = params.remote || 'origin';
-                const branch = params.branch;
+                let branch = params.branch;
                 try {
-                    if (branch) {
-                        await git.checkout(branch);
+                    if (!branch) {
+                        branch = await ctx.gitAdapter.getCurrentBranch(projectPath);
+                    }
+                    // Checkout if needed (not strictly necessary if we are already on the branch, but good for safety)
+                    const currentBranch = await ctx.gitAdapter.getCurrentBranch(projectPath);
+                    if (branch !== currentBranch) {
+                        await ctx.gitAdapter.checkout(projectPath, branch);
                     }
-                    await git.fetch(remote);
-                    await git.pull(remote, branch);
-                    return { success: true, projectPath, remote, branch: branch || 'current', message: 'Repository synced' };
+                    await ctx.gitAdapter.fetch(projectPath, remote);
+                    await ctx.gitAdapter.pull(projectPath, remote, branch);
+                    await ctx.gitAdapter.push(projectPath, remote, branch);
+                    return { success: true, projectPath, remote, branch, message: 'Repository synced' };
                 }
                 catch (err) {
                     throw new MCPError('SYNC_ERROR', `Failed to sync with ${remote}: ${err.message}`);
@@ -102,8 +111,8 @@ export class GitSyncTool {
             }
             case 'status': {
                 try {
-                    const status = await git.status();
-                    const remotes = await git.getRemotes(true);
+                    const status = await ctx.gitAdapter.status(projectPath);
+                    const remotes = await ctx.gitAdapter.listRemotes(projectPath);
                     return {
                         success: true,
                         projectPath,
@@ -114,7 +123,7 @@ export class GitSyncTool {
                             modified: status.modified,
                             created: status.created,
                             deleted: status.deleted,
-                            clean: status.isClean(),
+                            clean: status.isClean,
                         },
                         remotes,
                     };
@@ -126,7 +135,7 @@ export class GitSyncTool {
             case 'one-shot': {
                 // One-shot sync: fetch, pull, and push in a single operation
                 const remote = params.remote || 'origin';
-                const branch = params.branch;
+                let branch = params.branch;
                 const results = {
                     success: true,
                     projectPath,
@@ -135,31 +144,30 @@ export class GitSyncTool {
                     steps: [],
                 };
                 try {
+                    if (!branch) {
+                        branch = await ctx.gitAdapter.getCurrentBranch(projectPath);
+                        results.branch = branch;
+                    }
                     // Step 1: Fetch
                     results.steps.push({ action: 'fetch', timestamp: new Date().toISOString() });
-                    await git.fetch(remote);
+                    await ctx.gitAdapter.fetch(projectPath, remote);
                     // Step 2: Pull
                     results.steps.push({ action: 'pull', timestamp: new Date().toISOString() });
-                    if (branch) {
-                        await git.pull(remote, branch);
-                    }
-                    else {
-                        await git.pull(remote);
-                    }
+                    await ctx.gitAdapter.pull(projectPath, remote, branch);
                     // Step 3: Push
                     results.steps.push({ action: 'push', timestamp: new Date().toISOString() });
-                    const pushResult = await git.push(remote, branch, ['--set-upstream']);
+                    await ctx.gitAdapter.push(projectPath, remote, branch, false, true);
                     results.pushResult = {
-                        pushed: pushResult.pushed || [],
-                        remoteMessages: pushResult.remoteMessages?.all || [],
+                        pushed: true, // Isomorphic git doesn't return detailed push stats easily
+                        message: 'Push successful'
                     };
                     // Step 4: Final status
-                    const finalStatus = await git.status();
+                    const finalStatus = await ctx.gitAdapter.status(projectPath);
                     results.finalStatus = {
                         branch: finalStatus.current,
                         ahead: finalStatus.ahead,
                         behind: finalStatus.behind,
-                        clean: finalStatus.isClean(),
+                        clean: finalStatus.isClean,
                     };
                     return results;
                 }

package/dist/tools/gitTags.d.ts

@@ -26,10 +26,18 @@ export declare class GitTagsTool implements Tool {
                 type: string;
                 description: string;
             };
+            annotated: {
+                type: string;
+                description: string;
+            };
             force: {
                 type: string;
                 description: string;
             };
+            remote: {
+                type: string;
+                description: string;
+            };
         };
         required: string[];
     };