@andrebuzeli/git-mcp 10.0.7 → 10.0.9

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[];
     };

package/dist/tools/gitTags.js

@@ -1,4 +1,3 @@
-import simpleGit from 'simple-git';
 import { MCPError } from '../utils/errors.js';
 import axios from 'axios';
 import { getRepoInfo } from '../utils/repoHelpers.js';
@@ -30,9 +29,17 @@ export class GitTagsTool {
                     type: "string",
                     description: "Tag annotation message (optional for create)"
                 },
+                annotated: {
+                    type: "boolean",
+                    description: "Create annotated tag (optional for create, default: false)"
+                },
                 force: {
                     type: "boolean",
                     description: "Force create/delete/push tag (default: true)"
+                },
+                remote: {
+                    type: "string",
+                    description: "Remote name (optional for push, default: origin)"
                 }
             },
             required: ["projectPath", "action"]
@@ -44,37 +51,37 @@ export class GitTagsTool {
         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 'create': {
                 const tagName = params.tagName;
                 if (!tagName)
                     throw new MCPError('VALIDATION_ERROR', 'tagName is required');
-                if (params.annotated) {
-                    await git.addAnnotatedTag(tagName, params.message || tagName);
-                }
-                else {
-                    await git.addTag(tagName);
-                }
+                const ref = params.ref || 'HEAD';
+                const message = params.annotated ? (params.message || tagName) : undefined;
+                await ctx.gitAdapter.createTag(projectPath, tagName, ref, message);
                 return { success: true, tag: tagName, local: true };
             }
             case 'list': {
-                const localTags = await git.tags();
+                const localTags = await ctx.gitAdapter.listTags(projectPath);
                 const results = {
                     success: true,
-                    local: { tags: localTags.all },
+                    local: { tags: localTags },
                     providers: {}
                 };
                 // Also query remote APIs
                 const repoInfo = getRepoInfo(projectPath);
-                const githubOwner = process.env.GITHUB_USERNAME;
-                const giteaOwner = process.env.GITEA_USERNAME;
+                const repo = params.repo || repoInfo.repoName;
+                const githubOwner = params.owner || process.env.GITHUB_USERNAME;
+                const giteaOwner = params.owner || process.env.GITEA_USERNAME;
                 // GitHub
                 if (ctx.providerManager.github && githubOwner) {
                     try {
                         const tags = await ctx.providerManager.github.rest.repos.listTags({
                             owner: githubOwner,
-                            repo: repoInfo.repoName,
+                            repo: repo,
                         });
                         results.providers.github = {
                             success: true,
@@ -93,7 +100,7 @@ export class GitTagsTool {
                 // Gitea
                 if (ctx.providerManager.giteaBaseUrl && giteaOwner) {
                     try {
-                        const tags = await axios.get(`${ctx.providerManager.giteaBaseUrl}/api/v1/repos/${giteaOwner}/${repoInfo.repoName}/tags`, { headers: { Authorization: `token ${ctx.providerManager.giteaToken}` } });
+                        const tags = await axios.get(`${ctx.providerManager.giteaBaseUrl}/api/v1/repos/${giteaOwner}/${repo}/tags`, { headers: { Authorization: `token ${ctx.providerManager.giteaToken}` } });
                         results.providers.gitea = {
                             success: true,
                             tags: tags.data.map((t) => ({
@@ -114,30 +121,24 @@ export class GitTagsTool {
                 const tagName = params.tagName;
                 if (!tagName)
                     throw new MCPError('VALIDATION_ERROR', 'tagName is required');
-                const localTags = await git.tags();
-                const localTag = localTags.all.find(t => t === tagName);
+                const localTags = await ctx.gitAdapter.listTags(projectPath);
+                const localTag = localTags.find(t => t === tagName);
                 const results = {
                     success: true,
                     local: localTag ? { found: true, tag: tagName } : { found: false },
                     providers: {}
                 };
-                if (localTag) {
-                    try {
-                        const show = await git.show([tagName]);
-                        results.local.details = show;
-                    }
-                    catch { }
-                }
                 // Also query remote APIs
                 const repoInfo = getRepoInfo(projectPath);
-                const githubOwner = process.env.GITHUB_USERNAME;
-                const giteaOwner = process.env.GITEA_USERNAME;
+                const repo = params.repo || repoInfo.repoName;
+                const githubOwner = params.owner || process.env.GITHUB_USERNAME;
+                const giteaOwner = params.owner || process.env.GITEA_USERNAME;
                 // GitHub
                 if (ctx.providerManager.github && githubOwner) {
                     try {
                         const tag = await ctx.providerManager.github.rest.git.getRef({
                             owner: githubOwner,
-                            repo: repoInfo.repoName,
+                            repo: repo,
                             ref: `tags/${tagName}`,
                         });
                         results.providers.github = {
@@ -157,7 +158,7 @@ export class GitTagsTool {
                 // Gitea
                 if (ctx.providerManager.giteaBaseUrl && giteaOwner) {
                     try {
-                        const tags = await axios.get(`${ctx.providerManager.giteaBaseUrl}/api/v1/repos/${giteaOwner}/${repoInfo.repoName}/tags`, { headers: { Authorization: `token ${ctx.providerManager.giteaToken}` } });
+                        const tags = await axios.get(`${ctx.providerManager.giteaBaseUrl}/api/v1/repos/${giteaOwner}/${repo}/tags`, { headers: { Authorization: `token ${ctx.providerManager.giteaToken}` } });
                         const tag = tags.data.find((t) => t.name === tagName);
                         if (tag) {
                             results.providers.gitea = {
@@ -183,15 +184,23 @@ export class GitTagsTool {
                 const tagName = params.tagName;
                 if (!tagName)
                     throw new MCPError('VALIDATION_ERROR', 'tagName is required');
-                await git.tag(['-d', tagName]);
+                await ctx.gitAdapter.deleteTag(projectPath, tagName);
                 return { success: true, deleted: tagName, local: true };
             }
+            case 'push': {
+                const tagName = params.tagName;
+                if (!tagName)
+                    throw new MCPError('VALIDATION_ERROR', 'tagName is required');
+                const remote = params.remote || 'origin';
+                await ctx.gitAdapter.pushTag(projectPath, remote, tagName);
+                return { success: true, pushed: tagName, remote };
+            }
             case 'search': {
                 const pattern = params.pattern;
                 if (!pattern)
                     throw new MCPError('VALIDATION_ERROR', 'pattern is required');
-                const localTags = await git.tags();
-                const filtered = localTags.all.filter(t => t.includes(pattern));
+                const localTags = await ctx.gitAdapter.listTags(projectPath);
+                const filtered = localTags.filter(t => t.includes(pattern));
                 const results = {
                     success: true,
                     local: { tags: filtered },
@@ -199,14 +208,15 @@ export class GitTagsTool {
                 };
                 // Also search remote APIs
                 const repoInfo = getRepoInfo(projectPath);
-                const githubOwner = process.env.GITHUB_USERNAME;
-                const giteaOwner = process.env.GITEA_USERNAME;
+                const repo = params.repo || repoInfo.repoName;
+                const githubOwner = params.owner || process.env.GITHUB_USERNAME;
+                const giteaOwner = params.owner || process.env.GITEA_USERNAME;
                 // GitHub
                 if (ctx.providerManager.github && githubOwner) {
                     try {
                         const tags = await ctx.providerManager.github.rest.repos.listTags({
                             owner: githubOwner,
-                            repo: repoInfo.repoName,
+                            repo: repo,
                         });
                         const matchedTags = tags.data.filter((t) => t.name.includes(pattern));
                         results.providers.github = {
@@ -221,7 +231,7 @@ export class GitTagsTool {
                 // Gitea
                 if (ctx.providerManager.giteaBaseUrl && giteaOwner) {
                     try {
-                        const tags = await axios.get(`${ctx.providerManager.giteaBaseUrl}/api/v1/repos/${giteaOwner}/${repoInfo.repoName}/tags`, { headers: { Authorization: `token ${ctx.providerManager.giteaToken}` } });
+                        const tags = await axios.get(`${ctx.providerManager.giteaBaseUrl}/api/v1/repos/${giteaOwner}/${repo}/tags`, { headers: { Authorization: `token ${ctx.providerManager.giteaToken}` } });
                         const matchedTags = tags.data.filter((t) => t.name.includes(pattern));
                         results.providers.gitea = {
                             success: true,

package/dist/tools/gitUpdate.d.ts

@@ -22,6 +22,33 @@ export declare class GitUpdateTool implements Tool {
                 type: string;
                 description: string;
             };
+            message: {
+                type: string;
+                description: string;
+            };
+            commitMessage: {
+                type: string;
+                description: string;
+            };
+            branch: {
+                type: string;
+                description: string;
+            };
+            files: {
+                type: string;
+                items: {
+                    type: string;
+                };
+                description: string;
+            };
+            repoName: {
+                type: string;
+                description: string;
+            };
+            description: {
+                type: string;
+                description: string;
+            };
         };
         required: string[];
         additionalProperties: boolean;

package/dist/tools/gitUpdate.js

@@ -1,4 +1,3 @@
-import simpleGit from 'simple-git';
 import { MCPError } from '../utils/errors.js';
 import axios from 'axios';
 import * as fs from 'fs/promises';
@@ -27,6 +26,31 @@ export class GitUpdateTool {
                 owner: {
                     type: "string",
                     description: "Repository owner for providers (optional, uses env vars)"
+                },
+                message: {
+                    type: "string",
+                    description: "Commit message"
+                },
+                commitMessage: {
+                    type: "string",
+                    description: "Commit message (alias)"
+                },
+                branch: {
+                    type: "string",
+                    description: "Branch name"
+                },
+                files: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Files to add"
+                },
+                repoName: {
+                    type: "string",
+                    description: "Repository name"
+                },
+                description: {
+                    type: "string",
+                    description: "Repository description"
                 }
             },
             required: ["projectPath"],
@@ -38,10 +62,12 @@ export class GitUpdateTool {
         if (!projectPath) {
             throw new MCPError('VALIDATION_ERROR', 'projectPath is required');
         }
+        if (!ctx.gitAdapter) {
+            throw new MCPError('INTERNAL_ERROR', 'Git adapter not available');
+        }
         const commitMessage = params.message || params.commitMessage || `[git-update] Update at ${new Date().toISOString()}`;
         const branch = params.branch || 'master';
         const files = params.files || ['.'];
-        const git = simpleGit({ baseDir: projectPath });
         // Resultado com rastreabilidade completa
         const results = {
             success: true,
@@ -65,7 +91,7 @@ export class GitUpdateTool {
                 action: 'check_pre_update_status',
                 timestamp: new Date().toISOString(),
             });
-            const preStatus = await git.status();
+            const preStatus = await ctx.gitAdapter.status(projectPath);
             results.traceability.preUpdateStatus = {
                 branch: preStatus.current,
                 ahead: preStatus.ahead,
@@ -76,7 +102,7 @@ export class GitUpdateTool {
                 renamed: preStatus.renamed,
                 staged: preStatus.staged,
                 conflicted: preStatus.conflicted,
-                isClean: preStatus.isClean(),
+                isClean: preStatus.isClean,
             };
             // 2. Detectar arquivos alterados com diff
             results.traceability.updateSteps.push({
@@ -84,15 +110,11 @@ export class GitUpdateTool {
                 action: 'detect_changes',
                 timestamp: new Date().toISOString(),
             });
-            const diff = await git.diff(['--name-status']);
-            const diffLines = diff.split('\n').filter(l => l.trim());
-            results.traceability.changedFiles = diffLines.map(line => {
-                const [status, ...fileParts] = line.split('\t');
-                return {
-                    status: status.trim(),
-                    file: fileParts.join('\t').trim(),
-                };
-            });
+            // Isomorphic git diff is basic, so we rely on status for changed files list
+            results.traceability.changedFiles = preStatus.files.map(f => ({
+                status: f.working_dir,
+                file: f.path
+            }));
             // 3. Add files
             results.traceability.updateSteps.push({
                 step: 3,
@@ -100,7 +122,7 @@ export class GitUpdateTool {
                 timestamp: new Date().toISOString(),
                 files,
             });
-            await git.add(files);
+            await ctx.gitAdapter.add(projectPath, files);
             // 4. Commit
             results.traceability.updateSteps.push({
                 step: 4,
@@ -110,7 +132,13 @@ export class GitUpdateTool {
             });
             let commitResult;
             try {
-                commitResult = await git.commit(commitMessage);
+                const sha = await ctx.gitAdapter.commit(projectPath, commitMessage);
+                commitResult = {
+                    commit: sha,
+                    summary: { changes: 0, insertions: 0, deletions: 0 }, // Basic adapter doesn't return stats yet
+                    branch: await ctx.gitAdapter.getCurrentBranch(projectPath),
+                    author: { name: 'unknown', email: 'unknown' } // We could fetch this if needed
+                };
                 results.traceability.commit = {
                     hash: commitResult.commit,
                     summary: commitResult.summary,
@@ -119,7 +147,7 @@ export class GitUpdateTool {
                 };
             }
             catch (err) {
-                if (err.message.includes('nothing to commit')) {
+                if (err.message.includes('nothing to commit') || (preStatus.isClean && files[0] === '.')) {
                     results.traceability.commit = { message: 'No changes to commit' };
                 }
                 else {
@@ -127,7 +155,7 @@ export class GitUpdateTool {
                 }
             }
             // 5. Get remotes and ensure repos exist
-            const remotes = await git.getRemotes(true);
+            const remotes = await ctx.gitAdapter.listRemotes(projectPath);
             let githubRemote = remotes.find(r => r.name === 'github' || r.name === 'origin');
             let giteaRemote = remotes.find(r => r.name === 'gitea');
             // Auto-create repos if they don't exist
@@ -169,8 +197,9 @@ export class GitUpdateTool {
                         });
                     }
                     // Add remote
-                    await git.addRemote('github', `https://github.com/${githubOwner}/${repoName}.git`);
-                    githubRemote = { name: 'github', refs: { push: `https://github.com/${githubOwner}/${repoName}.git`, fetch: '' } };
+                    const url = `https://github.com/${githubOwner}/${repoName}.git`;
+                    await ctx.gitAdapter.addRemote(projectPath, 'github', url);
+                    githubRemote = { name: 'github', remote: 'github', url, fetch: url };
                 }
                 catch (err) {
                     results.traceability.errors.push({
@@ -211,8 +240,9 @@ export class GitUpdateTool {
                         });
                     }
                     // Add remote
-                    await git.addRemote('gitea', `${ctx.providerManager.giteaBaseUrl}/${giteaOwner}/${repoName}.git`);
-                    giteaRemote = { name: 'gitea', refs: { push: `${ctx.providerManager.giteaBaseUrl}/${giteaOwner}/${repoName}.git`, fetch: '' } };
+                    const url = `${ctx.providerManager.giteaBaseUrl}/${giteaOwner}/${repoName}.git`;
+                    await ctx.gitAdapter.addRemote(projectPath, 'gitea', url);
+                    giteaRemote = { name: 'gitea', remote: 'gitea', url, fetch: url };
                 }
                 catch (err) {
                     results.traceability.errors.push({
@@ -233,15 +263,14 @@ export class GitUpdateTool {
                     branch,
                 });
                 try {
-                    const pushResult = await git.push(githubRemote.name, branch);
+                    await ctx.gitAdapter.push(projectPath, githubRemote.name, branch);
                     results.providers.github = {
                         success: true,
                         remote: githubRemote.name,
-                        url: githubRemote.refs.push,
+                        url: githubRemote.url,
                         pushed: true,
                         pushResult: {
-                            remoteMessages: pushResult.remoteMessages?.all || [],
-                            update: pushResult.update,
+                            message: 'Push successful'
                         }
                     };
                     // Verificar commit no GitHub via API
@@ -285,15 +314,14 @@ export class GitUpdateTool {
                     branch,
                 });
                 try {
-                    const pushResult = await git.push(giteaRemote.name, branch);
+                    await ctx.gitAdapter.push(projectPath, giteaRemote.name, branch);
                     results.providers.gitea = {
                         success: true,
                         remote: giteaRemote.name,
-                        url: giteaRemote.refs.push,
+                        url: giteaRemote.url,
                         pushed: true,
                         pushResult: {
-                            remoteMessages: pushResult.remoteMessages?.all || [],
-                            update: pushResult.update,
+                            message: 'Push successful'
                         }
                     };
                     // Verificar commit no Gitea via API
@@ -328,12 +356,12 @@ export class GitUpdateTool {
                 action: 'check_post_update_status',
                 timestamp: new Date().toISOString(),
             });
-            const postStatus = await git.status();
+            const postStatus = await ctx.gitAdapter.status(projectPath);
             results.traceability.postUpdateStatus = {
                 branch: postStatus.current,
                 ahead: postStatus.ahead,
                 behind: postStatus.behind,
-                isClean: postStatus.isClean(),
+                isClean: postStatus.isClean,
                 tracking: postStatus.tracking,
             };
             // 9. Salvar histórico local
@@ -374,12 +402,11 @@ export class GitUpdateTool {
         const githubOwner = params.owner || process.env.GITHUB_USERNAME;
         const giteaOwner = params.owner || process.env.GITEA_USERNAME;
         // Pegar nome do repo dos remotes do Git ao invés do nome da pasta
-        const git = simpleGit(projectPath);
-        const remotes = await git.getRemotes(true);
+        const remotes = await ctx.gitAdapter.listRemotes(projectPath);
         let repoName = getRepoNameFromPath(projectPath); // fallback
         if (remotes.length > 0) {
             const githubRemote = remotes.find(r => r.name === 'github') || remotes.find(r => r.name === 'origin') || remotes[0];
-            const match = githubRemote.refs.push?.match(/\/([^\/]+?)(\.git)?$/);
+            const match = githubRemote.fetch?.match(/\/([^\/]+?)(\.git)?$/);
             if (match)
                 repoName = match[1];
         }