@andrebuzeli/git-mcp 10.0.9 → 11.0.0

package/dist/tools/gitStash.d.ts

@@ -1,61 +0,0 @@
-import { Tool, MCPContext } from '../types.js';
-export declare class GitStashTool implements Tool {
-    name: string;
-    description: string;
-    inputSchema: {
-        type: "object";
-        properties: {
-            projectPath: {
-                type: string;
-                description: string;
-            };
-            action: {
-                type: string;
-                enum: string[];
-                description: string;
-            };
-            includeUntracked: {
-                type: string;
-                description: string;
-            };
-            message: {
-                type: string;
-                description: string;
-            };
-            confirm: {
-                type: string;
-                description: string;
-            };
-            stashRef: {
-                type: string;
-                description: string;
-            };
-        };
-        required: string[];
-    };
-    handle(params: Record<string, any>, ctx: MCPContext): Promise<{
-        success: boolean;
-        message: string;
-        stash?: undefined;
-        stashes?: undefined;
-        dropped?: undefined;
-    } | {
-        success: boolean;
-        stash: any;
-        message: string;
-        stashes?: undefined;
-        dropped?: undefined;
-    } | {
-        success: boolean;
-        stashes: import("../utils/gitAdapter.js").StashEntry[];
-        message?: undefined;
-        stash?: undefined;
-        dropped?: undefined;
-    } | {
-        success: boolean;
-        dropped: any;
-        message?: undefined;
-        stash?: undefined;
-        stashes?: undefined;
-    }>;
-}

package/dist/tools/gitStash.js

@@ -1,80 +0,0 @@
-import { MCPError } from '../utils/errors.js';
-export class GitStashTool {
-    constructor() {
-        this.name = 'git-stash';
-        this.description = 'Stash management operations - local Git operations';
-        this.inputSchema = {
-            type: "object",
-            properties: {
-                projectPath: {
-                    type: "string",
-                    description: "The absolute path to the Git repository directory on the local filesystem. This should be the root directory containing the .git folder. For example: '/home/user/my-project' on Linux/Mac or 'C:\\Users\\user\\my-project' on Windows."
-                },
-                action: {
-                    type: "string",
-                    enum: ["save", "list", "apply", "pop", "drop", "clear"],
-                    description: "Stash operation to perform: save (stash changes), list (list stashes), apply (apply stash), pop (apply and remove stash), drop (remove stash), clear (remove all stashes)"
-                },
-                includeUntracked: {
-                    type: "boolean",
-                    description: "Include untracked files (optional for save)"
-                },
-                message: {
-                    type: "string",
-                    description: "Stash message (optional for save)"
-                },
-                confirm: {
-                    type: "boolean",
-                    description: "Confirm destructive operations (optional for drop/clear)"
-                },
-                stashRef: {
-                    type: "string",
-                    description: "Stash reference (optional for apply/pop/drop, default: stash@{0})"
-                }
-            },
-            required: ["projectPath", "action"]
-        };
-    }
-    async handle(params, ctx) {
-        const action = params.action;
-        const projectPath = params.projectPath;
-        if (!action || !projectPath) {
-            throw new MCPError('VALIDATION_ERROR', 'action and projectPath are required');
-        }
-        const git = ctx.gitAdapter;
-        switch (action) {
-            case 'save':
-            case 'stash': { // Support both for compatibility
-                const message = params.message;
-                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.popStash(projectPath, stashRef);
-                return { success: true, stash: stashRef, message: 'Stash applied and removed' };
-            }
-            case 'apply': {
-                const stashRef = params.stashRef || 'stash@{0}';
-                await git.applyStash(projectPath, stashRef);
-                return { success: true, stash: stashRef, message: 'Stash applied (kept in list)' };
-            }
-            case 'list': {
-                const stashes = await git.listStash(projectPath);
-                return { success: true, stashes };
-            }
-            case 'drop': {
-                const stashRef = params.stashRef || 'stash@{0}';
-                await git.dropStash(projectPath, stashRef);
-                return { success: true, dropped: stashRef };
-            }
-            case 'clear': {
-                await git.clearStash(projectPath);
-                return { success: true, message: 'All stashes cleared' };
-            }
-            default:
-                throw new MCPError('VALIDATION_ERROR', `Unsupported action: ${action}`);
-        }
-    }
-}

package/dist/tools/gitSync.d.ts

@@ -1,34 +0,0 @@
-import { Tool, MCPContext } from '../types.js';
-export declare class GitSyncTool implements Tool {
-    name: string;
-    description: string;
-    inputSchema: {
-        type: "object";
-        properties: {
-            projectPath: {
-                type: string;
-                description: string;
-            };
-            action: {
-                type: string;
-                enum: string[];
-                description: string;
-            };
-            branch: {
-                type: string;
-                description: string;
-            };
-            force: {
-                type: string;
-                description: string;
-            };
-            remote: {
-                type: string;
-                description: string;
-            };
-        };
-        required: string[];
-        additionalProperties: boolean;
-    };
-    handle(params: Record<string, any>, ctx: MCPContext): Promise<any>;
-}

package/dist/tools/gitSync.js

@@ -1,182 +0,0 @@
-import { MCPError } from '../utils/errors.js';
-export class GitSyncTool {
-    constructor() {
-        this.name = 'git-sync';
-        this.description = 'Repository synchronization operations - local Git operations';
-        this.inputSchema = {
-            type: "object",
-            properties: {
-                projectPath: {
-                    type: "string",
-                    description: "The absolute path to the Git repository directory on the local filesystem. This should be the root directory containing the .git folder. For example: '/home/user/my-project' on Linux/Mac or 'C:\\Users\\user\\my-project' on Windows."
-                },
-                action: {
-                    type: "string",
-                    enum: ["fetch", "pull", "push", "sync", "status", "one-shot"],
-                    description: "Sync operation to perform: fetch (fetch from remote), pull (pull changes), push (push changes), sync (fetch + push), status (get sync status), one-shot (complete sync cycle)"
-                },
-                branch: {
-                    type: "string",
-                    description: "Branch name (optional, default: current branch)"
-                },
-                force: {
-                    type: "boolean",
-                    description: "Force push (optional for push action)"
-                },
-                remote: {
-                    type: "string",
-                    description: "Remote name (optional, default: origin)"
-                }
-            },
-            required: ["projectPath", "action"],
-            additionalProperties: true
-        };
-    }
-    async handle(params, ctx) {
-        const action = params.action;
-        const projectPath = params.projectPath;
-        if (!action || !projectPath) {
-            throw new MCPError('VALIDATION_ERROR', 'action and projectPath are required');
-        }
-        if (!ctx.gitAdapter) {
-            throw new MCPError('INTERNAL_ERROR', 'Git adapter not available');
-        }
-        switch (action) {
-            case 'fetch': {
-                const remote = params.remote || 'origin';
-                try {
-                    await ctx.gitAdapter.fetch(projectPath, remote);
-                    return { success: true, projectPath, remote, action: 'fetch' };
-                }
-                catch (err) {
-                    throw new MCPError('FETCH_ERROR', `Failed to fetch from ${remote}: ${err.message}`);
-                }
-            }
-            case 'pull': {
-                const remote = params.remote || 'origin';
-                let branch = params.branch;
-                try {
-                    if (!branch) {
-                        branch = await ctx.gitAdapter.getCurrentBranch(projectPath);
-                    }
-                    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}`);
-                }
-            }
-            case 'push': {
-                const remote = params.remote || 'origin';
-                let branch = params.branch;
-                const force = params.force || false;
-                try {
-                    if (!branch) {
-                        branch = await ctx.gitAdapter.getCurrentBranch(projectPath);
-                    }
-                    await ctx.gitAdapter.push(projectPath, remote, branch, force);
-                    return {
-                        success: true,
-                        projectPath,
-                        remote,
-                        branch,
-                        action: 'push',
-                        message: 'Push successful'
-                    };
-                }
-                catch (err) {
-                    throw new MCPError('PUSH_ERROR', `Failed to push to ${remote}: ${err.message}`);
-                }
-            }
-            case 'sync': {
-                const remote = params.remote || 'origin';
-                let branch = params.branch;
-                try {
-                    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 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}`);
-                }
-            }
-            case 'status': {
-                try {
-                    const status = await ctx.gitAdapter.status(projectPath);
-                    const remotes = await ctx.gitAdapter.listRemotes(projectPath);
-                    return {
-                        success: true,
-                        projectPath,
-                        status: {
-                            branch: status.current,
-                            ahead: status.ahead,
-                            behind: status.behind,
-                            modified: status.modified,
-                            created: status.created,
-                            deleted: status.deleted,
-                            clean: status.isClean,
-                        },
-                        remotes,
-                    };
-                }
-                catch (err) {
-                    throw new MCPError('STATUS_ERROR', `Failed to get status: ${err.message}`);
-                }
-            }
-            case 'one-shot': {
-                // One-shot sync: fetch, pull, and push in a single operation
-                const remote = params.remote || 'origin';
-                let branch = params.branch;
-                const results = {
-                    success: true,
-                    projectPath,
-                    remote,
-                    branch: branch || 'current',
-                    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 ctx.gitAdapter.fetch(projectPath, remote);
-                    // Step 2: Pull
-                    results.steps.push({ action: 'pull', timestamp: new Date().toISOString() });
-                    await ctx.gitAdapter.pull(projectPath, remote, branch);
-                    // Step 3: Push
-                    results.steps.push({ action: 'push', timestamp: new Date().toISOString() });
-                    await ctx.gitAdapter.push(projectPath, remote, branch, false, true);
-                    results.pushResult = {
-                        pushed: true, // Isomorphic git doesn't return detailed push stats easily
-                        message: 'Push successful'
-                    };
-                    // Step 4: Final status
-                    const finalStatus = await ctx.gitAdapter.status(projectPath);
-                    results.finalStatus = {
-                        branch: finalStatus.current,
-                        ahead: finalStatus.ahead,
-                        behind: finalStatus.behind,
-                        clean: finalStatus.isClean,
-                    };
-                    return results;
-                }
-                catch (err) {
-                    throw new MCPError('ONE_SHOT_ERROR', `Failed during one-shot sync: ${err.message}`);
-                }
-            }
-            default:
-                throw new MCPError('VALIDATION_ERROR', `Unsupported action: ${action}`);
-        }
-    }
-}

package/dist/tools/gitTags.d.ts

@@ -1,45 +0,0 @@
-import { Tool, MCPContext } from '../types.js';
-export declare class GitTagsTool implements Tool {
-    name: string;
-    description: string;
-    inputSchema: {
-        type: "object";
-        properties: {
-            projectPath: {
-                type: string;
-                description: string;
-            };
-            action: {
-                type: string;
-                enum: string[];
-                description: string;
-            };
-            tagName: {
-                type: string;
-                description: string;
-            };
-            ref: {
-                type: string;
-                description: string;
-            };
-            message: {
-                type: string;
-                description: string;
-            };
-            annotated: {
-                type: string;
-                description: string;
-            };
-            force: {
-                type: string;
-                description: string;
-            };
-            remote: {
-                type: string;
-                description: string;
-            };
-        };
-        required: string[];
-    };
-    handle(params: Record<string, any>, ctx: MCPContext): Promise<any>;
-}

package/dist/tools/gitTags.js

@@ -1,251 +0,0 @@
-import { MCPError } from '../utils/errors.js';
-import axios from 'axios';
-import { getRepoInfo } from '../utils/repoHelpers.js';
-export class GitTagsTool {
-    constructor() {
-        this.name = 'git-tags';
-        this.description = 'Tag management operations - automatic dual-provider execution for remote queries';
-        this.inputSchema = {
-            type: "object",
-            properties: {
-                projectPath: {
-                    type: "string",
-                    description: "The absolute path to the Git repository directory on the local filesystem. This should be the root directory containing the .git folder. For example: '/home/user/my-project' on Linux/Mac or 'C:\\Users\\user\\my-project' on Windows."
-                },
-                action: {
-                    type: "string",
-                    enum: ["create", "list", "get", "delete", "push"],
-                    description: "Tag operation to perform: create (create tag), list (list tags), get (get tag details), delete (delete tag), push (push tag to remote)"
-                },
-                tagName: {
-                    type: "string",
-                    description: "Tag name (required for create/get/delete/push)"
-                },
-                ref: {
-                    type: "string",
-                    description: "Git reference to tag (optional for create, default: HEAD)"
-                },
-                message: {
-                    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"]
-        };
-    }
-    async handle(params, ctx) {
-        const action = params.action;
-        const projectPath = params.projectPath;
-        if (!action || !projectPath) {
-            throw new MCPError('VALIDATION_ERROR', 'action and projectPath are required');
-        }
-        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');
-                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 ctx.gitAdapter.listTags(projectPath);
-                const results = {
-                    success: true,
-                    local: { tags: localTags },
-                    providers: {}
-                };
-                // Also query remote APIs
-                const repoInfo = getRepoInfo(projectPath);
-                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: repo,
-                        });
-                        results.providers.github = {
-                            success: true,
-                            tags: tags.data.map((t) => ({
-                                name: t.name,
-                                sha: t.commit.sha,
-                                zipball_url: t.zipball_url,
-                                tarball_url: t.tarball_url,
-                            })),
-                        };
-                    }
-                    catch (err) {
-                        results.providers.github = { success: false, error: err.message };
-                    }
-                }
-                // Gitea
-                if (ctx.providerManager.giteaBaseUrl && giteaOwner) {
-                    try {
-                        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) => ({
-                                name: t.name,
-                                sha: t.commit?.id || t.id,
-                                zipball_url: t.zipball_url,
-                                tarball_url: t.tarball_url,
-                            })),
-                        };
-                    }
-                    catch (err) {
-                        results.providers.gitea = { success: false, error: err.message };
-                    }
-                }
-                return results;
-            }
-            case 'get': {
-                const tagName = params.tagName;
-                if (!tagName)
-                    throw new MCPError('VALIDATION_ERROR', 'tagName is required');
-                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: {}
-                };
-                // Also query remote APIs
-                const repoInfo = getRepoInfo(projectPath);
-                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: repo,
-                            ref: `tags/${tagName}`,
-                        });
-                        results.providers.github = {
-                            success: true,
-                            tag: {
-                                name: tagName,
-                                sha: tag.data.object.sha,
-                                type: tag.data.object.type,
-                                url: tag.data.url,
-                            },
-                        };
-                    }
-                    catch (err) {
-                        results.providers.github = { success: false, error: err.message };
-                    }
-                }
-                // Gitea
-                if (ctx.providerManager.giteaBaseUrl && giteaOwner) {
-                    try {
-                        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 = {
-                                success: true,
-                                tag: {
-                                    name: tag.name,
-                                    sha: tag.commit?.id || tag.id,
-                                    message: tag.message,
-                                },
-                            };
-                        }
-                        else {
-                            results.providers.gitea = { success: false, error: 'Tag not found' };
-                        }
-                    }
-                    catch (err) {
-                        results.providers.gitea = { success: false, error: err.message };
-                    }
-                }
-                return results;
-            }
-            case 'delete': {
-                const tagName = params.tagName;
-                if (!tagName)
-                    throw new MCPError('VALIDATION_ERROR', 'tagName is required');
-                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 ctx.gitAdapter.listTags(projectPath);
-                const filtered = localTags.filter(t => t.includes(pattern));
-                const results = {
-                    success: true,
-                    local: { tags: filtered },
-                    providers: {}
-                };
-                // Also search remote APIs
-                const repoInfo = getRepoInfo(projectPath);
-                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: repo,
-                        });
-                        const matchedTags = tags.data.filter((t) => t.name.includes(pattern));
-                        results.providers.github = {
-                            success: true,
-                            tags: matchedTags.map((t) => t.name),
-                        };
-                    }
-                    catch (err) {
-                        results.providers.github = { success: false, error: err.message };
-                    }
-                }
-                // Gitea
-                if (ctx.providerManager.giteaBaseUrl && giteaOwner) {
-                    try {
-                        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,
-                            tags: matchedTags.map((t) => t.name),
-                        };
-                    }
-                    catch (err) {
-                        results.providers.gitea = { success: false, error: err.message };
-                    }
-                }
-                return results;
-            }
-            default:
-                throw new MCPError('VALIDATION_ERROR', `Unsupported action: ${action}`);
-        }
-    }
-}