@andrebuzeli/git-mcp 10.0.9 → 11.0.0

package/dist/tools/gitBackup.d.ts

@@ -1,116 +0,0 @@
-import { Tool, MCPContext } from '../types.js';
-export declare class GitBackupTool implements Tool {
-    name: string;
-    description: string;
-    inputSchema: {
-        type: "object";
-        properties: {
-            projectPath: {
-                type: string;
-                description: string;
-            };
-            action: {
-                type: string;
-                enum: string[];
-                description: string;
-            };
-            backupPath: {
-                type: string;
-                description: string;
-            };
-            compress: {
-                type: string;
-                description: string;
-            };
-            confirm: {
-                type: string;
-                description: string;
-            };
-            name: {
-                type: string;
-                description: string;
-            };
-        };
-        required: string[];
-        additionalProperties: boolean;
-    };
-    handle(params: Record<string, any>, ctx: MCPContext): Promise<{
-        success: boolean;
-        backupPath: string;
-        backupData: {
-            projectPath: any;
-            timestamp: string;
-            branch: string;
-            lastCommit: string | null;
-            files: number;
-        };
-        message: string;
-        backups?: undefined;
-        count?: undefined;
-        backupDir?: undefined;
-        valid?: undefined;
-        backup?: undefined;
-        error?: undefined;
-        note?: undefined;
-    } | {
-        success: boolean;
-        backups: any[];
-        count: number;
-        backupDir: any;
-        backupPath?: undefined;
-        backupData?: undefined;
-        message?: undefined;
-        valid?: undefined;
-        backup?: undefined;
-        error?: undefined;
-        note?: undefined;
-    } | {
-        success: boolean;
-        backups: never[];
-        count: number;
-        message: string;
-        backupPath?: undefined;
-        backupData?: undefined;
-        backupDir?: undefined;
-        valid?: undefined;
-        backup?: undefined;
-        error?: undefined;
-        note?: undefined;
-    } | {
-        success: boolean;
-        valid: any;
-        backup: any;
-        message: string;
-        backupPath?: undefined;
-        backupData?: undefined;
-        backups?: undefined;
-        count?: undefined;
-        backupDir?: undefined;
-        error?: undefined;
-        note?: undefined;
-    } | {
-        success: boolean;
-        valid: boolean;
-        error: any;
-        backupPath?: undefined;
-        backupData?: undefined;
-        message?: undefined;
-        backups?: undefined;
-        count?: undefined;
-        backupDir?: undefined;
-        backup?: undefined;
-        note?: undefined;
-    } | {
-        success: boolean;
-        message: string;
-        backup: any;
-        note: string;
-        backupPath?: undefined;
-        backupData?: undefined;
-        backups?: undefined;
-        count?: undefined;
-        backupDir?: undefined;
-        valid?: undefined;
-        error?: undefined;
-    }>;
-}

package/dist/tools/gitBackup.js

@@ -1,156 +0,0 @@
-import fs from 'fs/promises';
-import path from 'path';
-import { MCPError } from '../utils/errors.js';
-export class GitBackupTool {
-    constructor() {
-        this.name = 'git-backup';
-        this.description = 'Repository backup and restore 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: ["create", "restore", "list", "delete"],
-                    description: "Backup operation to perform: create (create backup), restore (restore from backup), list (list backups), delete (delete backup)"
-                },
-                backupPath: {
-                    type: "string",
-                    description: "Path to backup file (required for create/restore/delete)"
-                },
-                compress: {
-                    type: "boolean",
-                    description: "Compress backup (optional for create, default: true)"
-                },
-                confirm: {
-                    type: "boolean",
-                    description: "Confirm destructive operations (optional for restore/delete)"
-                },
-                name: {
-                    type: "string",
-                    description: "Backup name (optional for create)"
-                }
-            },
-            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');
-        }
-        switch (action) {
-            case 'create':
-            case 'backup': {
-                const backupDir = params.backupDir || path.join(projectPath, '.git-backups');
-                const backupName = params.backupName || `backup-${Date.now()}.json`;
-                try {
-                    // Criar diretório de backups
-                    await fs.mkdir(backupDir, { recursive: true });
-                    const backupPath = path.join(backupDir, backupName);
-                    const git = ctx.gitAdapter;
-                    const status = await git.status(projectPath);
-                    const log = await git.log(projectPath, { maxCount: 1 });
-                    const backupData = {
-                        projectPath,
-                        timestamp: new Date().toISOString(),
-                        branch: status.current,
-                        lastCommit: log.length > 0 ? log[0].hash : null,
-                        files: status.files.length,
-                    };
-                    await fs.writeFile(backupPath, JSON.stringify(backupData, null, 2));
-                    return {
-                        success: true,
-                        backupPath,
-                        backupData,
-                        message: 'Backup created successfully',
-                    };
-                }
-                catch (error) {
-                    throw new MCPError('FILE_ERROR', `Failed to create backup: ${error.message}`);
-                }
-            }
-            case 'list': {
-                const backupDir = params.backupDir || path.join(projectPath, '.git-backups');
-                try {
-                    const files = await fs.readdir(backupDir);
-                    const backups = [];
-                    for (const file of files) {
-                        if (file.endsWith('.json')) {
-                            try {
-                                const content = await fs.readFile(path.join(backupDir, file), 'utf-8');
-                                const backup = JSON.parse(content);
-                                backups.push({ file, ...backup });
-                            }
-                            catch (e) {
-                                // Ignorar arquivos inválidos
-                            }
-                        }
-                    }
-                    return {
-                        success: true,
-                        backups,
-                        count: backups.length,
-                        backupDir,
-                    };
-                }
-                catch (error) {
-                    return {
-                        success: true,
-                        backups: [],
-                        count: 0,
-                        message: 'No backups directory found',
-                    };
-                }
-            }
-            case 'verify': {
-                const backupPath = params.backupPath;
-                if (!backupPath)
-                    throw new MCPError('VALIDATION_ERROR', 'backupPath is required');
-                try {
-                    const content = await fs.readFile(backupPath, 'utf-8');
-                    const backup = JSON.parse(content);
-                    const isValid = backup.timestamp && backup.projectPath;
-                    return {
-                        success: true,
-                        valid: isValid,
-                        backup,
-                        message: isValid ? 'Backup is valid' : 'Backup is invalid',
-                    };
-                }
-                catch (error) {
-                    return {
-                        success: false,
-                        valid: false,
-                        error: error.message,
-                    };
-                }
-            }
-            case 'restore': {
-                const backupPath = params.backupPath;
-                if (!backupPath)
-                    throw new MCPError('VALIDATION_ERROR', 'backupPath is required');
-                try {
-                    const content = await fs.readFile(backupPath, 'utf-8');
-                    const backup = JSON.parse(content);
-                    return {
-                        success: true,
-                        message: 'Backup info retrieved - manual restore required',
-                        backup,
-                        note: 'Use git commands to restore to the specified commit',
-                    };
-                }
-                catch (error) {
-                    throw new MCPError('FILE_ERROR', `Failed to read backup: ${error.message}`);
-                }
-            }
-            default:
-                throw new MCPError('VALIDATION_ERROR', `Unsupported action: ${action}`);
-        }
-    }
-}

package/dist/tools/gitBranches.d.ts

@@ -1,54 +0,0 @@
-import { Tool, MCPContext } from '../types.js';
-export declare class GitBranchesTool implements Tool {
-    name: string;
-    description: string;
-    inputSchema: {
-        type: "object";
-        properties: {
-            projectPath: {
-                type: string;
-                description: string;
-            };
-            action: {
-                type: string;
-                enum: string[];
-                description: string;
-            };
-            branchName: {
-                type: string;
-                description: string;
-            };
-            checkout: {
-                type: string;
-                description: string;
-            };
-            sourceBranch: {
-                type: string;
-                description: string;
-            };
-            confirm: {
-                type: string;
-                description: string;
-            };
-            force: {
-                type: string;
-                description: string;
-            };
-            targetBranch: {
-                type: string;
-                description: string;
-            };
-            baseBranch: {
-                type: string;
-                description: string;
-            };
-            compareBranch: {
-                type: string;
-                description: string;
-            };
-        };
-        required: string[];
-        additionalProperties: boolean;
-    };
-    handle(params: Record<string, any>, ctx: MCPContext): Promise<any>;
-}

package/dist/tools/gitBranches.js

@@ -1,282 +0,0 @@
-import { MCPError } from '../utils/errors.js';
-import { requireConfirmationIfDestructive } from '../utils/safetyController.js';
-import { getRepoInfo } from '../utils/repoHelpers.js';
-import axios from 'axios';
-export class GitBranchesTool {
-    constructor() {
-        this.name = 'git-branches';
-        this.description = 'Branch management operations - automatic dual-provider execution for remote queries';
-        this.inputSchema = {
-            type: "object",
-            properties: {
-                projectPath: {
-                    type: "string",
-                    description: "Absolute path to the project/repository (REQUIRED)"
-                },
-                action: {
-                    type: "string",
-                    enum: ["create", "list", "get", "delete", "merge", "compare"],
-                    description: "Action to perform: create (create branch), list (list branches), get (get branch info), delete (delete branch), merge (merge branches), compare (compare branches)"
-                },
-                branchName: {
-                    type: "string",
-                    description: "Branch name (required for create/get/delete/merge)"
-                },
-                checkout: {
-                    type: "boolean",
-                    description: "Checkout after creating branch (optional for create, default: true)"
-                },
-                sourceBranch: {
-                    type: "string",
-                    description: "Source branch to create from (optional for create)"
-                },
-                confirm: {
-                    type: "boolean",
-                    description: "Confirm destructive operations (optional for delete)"
-                },
-                force: {
-                    type: "boolean",
-                    description: "Force delete branch (optional for delete)"
-                },
-                targetBranch: {
-                    type: "string",
-                    description: "Target branch for merge (optional for merge)"
-                },
-                baseBranch: {
-                    type: "string",
-                    description: "Base branch for comparison (required for compare)"
-                },
-                compareBranch: {
-                    type: "string",
-                    description: "Branch to compare against base (required for compare)"
-                }
-            },
-            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 'create': {
-                const branchName = params.branchName;
-                if (!branchName)
-                    throw new MCPError('VALIDATION_ERROR', 'branchName is required');
-                const sourceBranch = params.sourceBranch;
-                if (sourceBranch) {
-                    await ctx.gitAdapter.checkout(projectPath, sourceBranch);
-                }
-                await ctx.gitAdapter.createBranch(projectPath, branchName);
-                if (params.checkout !== false) {
-                    await ctx.gitAdapter.checkout(projectPath, branchName);
-                }
-                return { success: true, branch: branchName, local: true };
-            }
-            case 'list': {
-                const branches = await ctx.gitAdapter.listBranches(projectPath);
-                const current = await ctx.gitAdapter.getCurrentBranch(projectPath);
-                const results = {
-                    success: true,
-                    local: {
-                        branches,
-                        current,
-                    },
-                    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 branches = await ctx.providerManager.github.rest.repos.listBranches({
-                            owner: githubOwner,
-                            repo: repo,
-                        });
-                        results.providers.github = {
-                            success: true,
-                            branches: branches.data.map((b) => ({
-                                name: b.name,
-                                protected: b.protected,
-                                sha: b.commit.sha,
-                            })),
-                        };
-                    }
-                    catch (err) {
-                        results.providers.github = { success: false, error: err.message };
-                    }
-                }
-                // Gitea
-                if (ctx.providerManager.giteaBaseUrl && giteaOwner) {
-                    try {
-                        const branches = await axios.get(`${ctx.providerManager.giteaBaseUrl}/api/v1/repos/${giteaOwner}/${repo}/branches`, { headers: { Authorization: `token ${ctx.providerManager.giteaToken}` } });
-                        results.providers.gitea = {
-                            success: true,
-                            branches: branches.data.map((b) => ({
-                                name: b.name,
-                                protected: b.protected,
-                                sha: b.commit.id,
-                            })),
-                        };
-                    }
-                    catch (err) {
-                        results.providers.gitea = { success: false, error: err.message };
-                    }
-                }
-                return results;
-            }
-            case 'get': {
-                const branchName = params.branchName;
-                if (!branchName)
-                    throw new MCPError('VALIDATION_ERROR', 'branchName is required');
-                const branches = await ctx.gitAdapter.listBranches(projectPath);
-                const current = await ctx.gitAdapter.getCurrentBranch(projectPath);
-                const found = branches.includes(branchName);
-                const results = {
-                    success: true,
-                    local: found ? { branch: branchName, current: current === branchName } : { 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 branchData = await ctx.providerManager.github.rest.repos.getBranch({
-                            owner: githubOwner,
-                            repo: repo,
-                            branch: branchName,
-                        });
-                        results.providers.github = {
-                            success: true,
-                            branch: {
-                                name: branchData.data.name,
-                                protected: branchData.data.protected,
-                                sha: branchData.data.commit.sha,
-                                commit: branchData.data.commit,
-                            },
-                        };
-                    }
-                    catch (err) {
-                        results.providers.github = { success: false, error: err.message };
-                    }
-                }
-                // Gitea
-                if (ctx.providerManager.giteaBaseUrl && giteaOwner) {
-                    try {
-                        const branchData = await axios.get(`${ctx.providerManager.giteaBaseUrl}/api/v1/repos/${giteaOwner}/${repo}/branches/${branchName}`, { headers: { Authorization: `token ${ctx.providerManager.giteaToken}` } });
-                        results.providers.gitea = {
-                            success: true,
-                            branch: {
-                                name: branchData.data.name,
-                                protected: branchData.data.protected,
-                                sha: branchData.data.commit.id,
-                                commit: branchData.data.commit,
-                            },
-                        };
-                    }
-                    catch (err) {
-                        results.providers.gitea = { success: false, error: err.message };
-                    }
-                }
-                return results;
-            }
-            case 'delete': {
-                requireConfirmationIfDestructive('delete', params);
-                const branchName = params.branchName;
-                if (!branchName)
-                    throw new MCPError('VALIDATION_ERROR', 'branchName is required');
-                await ctx.gitAdapter.deleteBranch(projectPath, branchName, params.force);
-                return { success: true, deleted: branchName, local: true };
-            }
-            case 'merge': {
-                const branchName = params.branchName;
-                const targetBranch = params.targetBranch;
-                if (!branchName)
-                    throw new MCPError('VALIDATION_ERROR', 'branchName is required');
-                if (targetBranch) {
-                    await ctx.gitAdapter.checkout(projectPath, targetBranch);
-                }
-                const result = await ctx.gitAdapter.merge(projectPath, branchName);
-                return { success: true, result, local: true };
-            }
-            case 'compare': {
-                const baseBranch = params.baseBranch;
-                const compareBranch = params.compareBranch;
-                if (!baseBranch || !compareBranch) {
-                    throw new MCPError('VALIDATION_ERROR', 'baseBranch and compareBranch are required');
-                }
-                // Basic comparison using log
-                // Note: This is a simplified comparison compared to git log base..compare
-                const baseLog = await ctx.gitAdapter.log(projectPath, { ref: baseBranch, maxCount: 20 });
-                const compareLog = await ctx.gitAdapter.log(projectPath, { ref: compareBranch, maxCount: 20 });
-                // Find commits in compare that are not in base
-                const baseHashes = new Set(baseLog.map(c => c.hash));
-                const uniqueCommits = compareLog.filter(c => !baseHashes.has(c.hash));
-                const results = {
-                    success: true,
-                    local: {
-                        baseBranch,
-                        compareBranch,
-                        commits: uniqueCommits,
-                        diff: "Diff not supported in adapter yet", // Placeholder
-                    },
-                    providers: {}
-                };
-                // Also compare on 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 comparison = await ctx.providerManager.github.rest.repos.compareCommits({
-                            owner: githubOwner,
-                            repo: repo,
-                            base: baseBranch,
-                            head: compareBranch,
-                        });
-                        results.providers.github = {
-                            success: true,
-                            comparison: {
-                                status: comparison.data.status,
-                                ahead_by: comparison.data.ahead_by,
-                                behind_by: comparison.data.behind_by,
-                                total_commits: comparison.data.total_commits,
-                                commits: comparison.data.commits.map((c) => ({
-                                    sha: c.sha,
-                                    message: c.commit.message,
-                                    author: c.commit.author.name,
-                                    date: c.commit.author.date,
-                                })),
-                            },
-                        };
-                    }
-                    catch (err) {
-                        results.providers.github = { success: false, error: err.message };
-                    }
-                }
-                // Gitea - comparison API might not be available
-                if (ctx.providerManager.giteaBaseUrl && giteaOwner) {
-                    results.providers.gitea = { success: false, error: 'Comparison API not available in Gitea' };
-                }
-                return results;
-            }
-            default:
-                throw new MCPError('VALIDATION_ERROR', `Unsupported action: ${action}`);
-        }
-    }
-}

package/dist/tools/gitChangelog.d.ts

@@ -1,37 +0,0 @@
-import { Tool, MCPContext } from '../types.js';
-export declare class GitChangelogTool implements Tool {
-    name: string;
-    description: string;
-    inputSchema: {
-        type: "object";
-        properties: {
-            projectPath: {
-                type: string;
-                description: string;
-            };
-            from: {
-                type: string;
-                description: string;
-            };
-            to: {
-                type: string;
-                description: string;
-            };
-            format: {
-                type: string;
-                description: string;
-                enum: string[];
-            };
-        };
-        required: string[];
-        additionalProperties: boolean;
-    };
-    handle(params: Record<string, any>, ctx: MCPContext): Promise<{
-        success: boolean;
-        changelog: string;
-        format: any;
-        commits: number;
-        from: any;
-        to: any;
-    }>;
-}