@andrebuzeli/git-mcp 10.0.9 → 11.0.0

package/dist/tools/gitWorkflow.js

@@ -1,472 +0,0 @@
-import { MCPError } from '../utils/errors.js';
-import { normalizeToolParams } from '../utils/repoHelpers.js';
-import axios from 'axios';
-/**
- * Git Workflow Tool - Operações Git principais com segurança aprimorada
- * VERSÃO SEGURA: Remove exposição de tokens, validação robusta, sem --force por padrão
- */
-export class GitWorkflowTool {
-    constructor() {
-        this.name = 'git-workflow';
-        this.description = 'Core Git operations including init, status, commit, sync, backup, and remote operations - automatic dual-provider for remote ops';
-        this.inputSchema = {
-            type: "object",
-            properties: {
-                projectPath: {
-                    type: "string",
-                    description: "Absolute path to the project/repository (REQUIRED)"
-                },
-                action: {
-                    type: "string",
-                    enum: ["init", "status", "commit", "sync", "backup", "create", "list", "get", "update", "delete", "fork", "search", "push"],
-                    description: "Action to perform: init (initialize repo), status (get repo status), commit (commit changes), sync (fetch/pull/push), backup (create backup), create (create repo on providers), list (list user repos), get (get repo details), update (update repo settings), delete (delete repo), fork (fork repo), search (search repos), push (push to remote)"
-                },
-                message: {
-                    type: "string",
-                    description: "Commit message (required for commit action)"
-                },
-                files: {
-                    type: "array",
-                    items: { type: "string" },
-                    description: "Files to add (optional for commit, default: ['.'])"
-                },
-                remote: {
-                    type: "string",
-                    description: "Remote name (optional for sync/push, default: 'origin')"
-                },
-                branch: {
-                    type: "string",
-                    description: "Branch name (optional for sync/push)"
-                },
-                backupPath: {
-                    type: "string",
-                    description: "Path for backup file (optional for backup)"
-                },
-                name: {
-                    type: "string",
-                    description: "Repository name (required for create)"
-                },
-                owner: {
-                    type: "string",
-                    description: "Repository owner (optional for create/get/update/delete/fork, uses env vars if not provided)"
-                },
-                repo: {
-                    type: "string",
-                    description: "Repository name (required for get/update/delete/fork)"
-                },
-                description: {
-                    type: "string",
-                    description: "Repository description (optional for create/update)"
-                },
-                private: {
-                    type: "boolean",
-                    description: "Make repository private (optional for create/update, default: true)"
-                },
-                has_issues: {
-                    type: "boolean",
-                    description: "Enable issues (optional for update)"
-                },
-                has_projects: {
-                    type: "boolean",
-                    description: "Enable projects (optional for update)"
-                },
-                has_wiki: {
-                    type: "boolean",
-                    description: "Enable wiki (optional for update)"
-                },
-                organization: {
-                    type: "string",
-                    description: "Organization for fork (optional for fork)"
-                },
-                query: {
-                    type: "string",
-                    description: "Search query (required for search)"
-                },
-                sort: {
-                    type: "string",
-                    description: "Sort field (optional for search)"
-                },
-                order: {
-                    type: "string",
-                    description: "Sort order (optional for search)"
-                },
-                limit: {
-                    type: "number",
-                    description: "Result limit (optional for search, default: 30)"
-                },
-                force: {
-                    type: "boolean",
-                    description: "Force push - REQUIRES confirmDestructive: true (optional for push, default: false)"
-                },
-                setUpstream: {
-                    type: "boolean",
-                    description: "Set upstream (optional for push, default: true)"
-                },
-                bare: {
-                    type: "boolean",
-                    description: "Initialize as bare repo (optional for init, default: false)"
-                },
-                confirmDestructive: {
-                    type: "boolean",
-                    description: "Required confirmation for destructive operations like force push (default: false)"
-                }
-            },
-            required: ["projectPath", "action"],
-            additionalProperties: true
-        };
-    }
-    async handle(params, ctx) {
-        // Normalize parameters to handle different IDE/agent formats
-        params = normalizeToolParams(params);
-        const action = params.action;
-        if (!action)
-            throw new MCPError('VALIDATION_ERROR', 'action is required. You can use either "action" or "command" parameter.');
-        const projectPath = params.projectPath;
-        // Validação de path para segurança
-        if (projectPath) {
-            const path = await import('path');
-            const resolvedPath = path.resolve(projectPath);
-            // Verificar se é um diretório válido e não está tentando escapar
-            if (!resolvedPath || resolvedPath.includes('..')) {
-                throw new MCPError('VALIDATION_ERROR', 'Invalid project path provided');
-            }
-        }
-        if (!ctx.gitAdapter) {
-            throw new MCPError('INTERNAL_ERROR', 'Git adapter not available');
-        }
-        switch (action) {
-            case 'init': {
-                if (!projectPath)
-                    throw new MCPError('VALIDATION_ERROR', 'projectPath is required for init');
-                await ctx.gitAdapter.init(projectPath);
-                return { success: true, path: projectPath };
-            }
-            case 'status': {
-                if (!projectPath)
-                    throw new MCPError('VALIDATION_ERROR', 'projectPath is required for status');
-                const status = await ctx.gitAdapter.status(projectPath);
-                return { success: true, status };
-            }
-            case 'commit': {
-                if (!projectPath)
-                    throw new MCPError('VALIDATION_ERROR', 'projectPath is required for commit');
-                const message = params.message;
-                if (!message)
-                    throw new MCPError('VALIDATION_ERROR', 'Commit message is required');
-                let files = params.files || ['.'];
-                // Handle case where files might be passed as a string (e.g., from some agents)
-                if (typeof files === 'string') {
-                    files = files === '.' ? ['.'] : files.split(',').map(f => f.trim());
-                }
-                // Ensure files is an array
-                if (!Array.isArray(files)) {
-                    files = [files];
-                }
-                try {
-                    await ctx.gitAdapter.add(projectPath, files);
-                }
-                catch (addErr) {
-                    console.warn(`Failed to add files: ${addErr.message}`);
-                    throw addErr;
-                }
-                const result = await ctx.gitAdapter.commit(projectPath, message);
-                return { success: true, commit: result };
-            }
-            case 'sync': {
-                if (!projectPath)
-                    throw new MCPError('VALIDATION_ERROR', 'projectPath is required for sync');
-                const remote = params.remote || 'origin';
-                let branch = params.branch;
-                if (!branch) {
-                    branch = await ctx.gitAdapter.getCurrentBranch(projectPath);
-                }
-                await ctx.gitAdapter.fetch(projectPath, remote);
-                await ctx.gitAdapter.pull(projectPath, remote, branch);
-                await ctx.gitAdapter.push(projectPath, remote, branch);
-                return { success: true, message: 'Repository synced' };
-            }
-            case 'backup': {
-                const backupPath = params.backupPath || `${projectPath}-backup-${Date.now()}.tar.gz`;
-                return { success: true, backupPath, message: 'Backup marked (simplified)' };
-            }
-            case 'create': {
-                const name = params.name;
-                if (!name)
-                    throw new MCPError('VALIDATION_ERROR', 'name is required');
-                const githubOwner = params.owner || process.env.GITHUB_USERNAME;
-                const giteaOwner = params.owner || process.env.GITEA_USERNAME;
-                const results = { success: true, providers: {} };
-                // GitHub
-                if (ctx.providerManager.github && githubOwner) {
-                    try {
-                        const result = await ctx.providerManager.github.rest.repos.createForAuthenticatedUser({
-                            name,
-                            description: params.description,
-                            private: params.private || false,
-                        });
-                        results.providers.github = { success: true, repo: result.data };
-                    }
-                    catch (err) {
-                        results.providers.github = { success: false, error: err.message };
-                    }
-                }
-                // Gitea
-                if (ctx.providerManager.giteaBaseUrl && giteaOwner) {
-                    try {
-                        const result = await axios.post(`${ctx.providerManager.giteaBaseUrl}/api/v1/user/repos`, {
-                            name,
-                            description: params.description,
-                            private: params.private || false,
-                        }, { headers: { Authorization: `token ${ctx.providerManager.giteaToken}` } });
-                        results.providers.gitea = { success: true, repo: result.data };
-                    }
-                    catch (err) {
-                        results.providers.gitea = { success: false, error: err.message };
-                    }
-                }
-                return results;
-            }
-            case 'list': {
-                const results = { success: true, providers: {} };
-                // GitHub
-                if (ctx.providerManager.github) {
-                    try {
-                        const result = await ctx.providerManager.github.rest.repos.listForAuthenticatedUser();
-                        results.providers.github = { success: true, repos: result.data };
-                    }
-                    catch (err) {
-                        results.providers.github = { success: false, error: err.message };
-                    }
-                }
-                // Gitea
-                if (ctx.providerManager.giteaBaseUrl) {
-                    try {
-                        const result = await axios.get(`${ctx.providerManager.giteaBaseUrl}/api/v1/user/repos`, { headers: { Authorization: `token ${ctx.providerManager.giteaToken}` } });
-                        results.providers.gitea = { success: true, repos: result.data };
-                    }
-                    catch (err) {
-                        results.providers.gitea = { success: false, error: err.message };
-                    }
-                }
-                return results;
-            }
-            case 'get': {
-                const githubOwner = params.owner || process.env.GITHUB_USERNAME;
-                const giteaOwner = params.owner || process.env.GITEA_USERNAME;
-                const repo = params.repo;
-                if (!githubOwner || !repo) {
-                    throw new MCPError('VALIDATION_ERROR', 'owner and repo are required');
-                }
-                const results = { success: true, providers: {} };
-                // GitHub
-                if (ctx.providerManager.github) {
-                    try {
-                        const result = await ctx.providerManager.github.rest.repos.get({ owner: githubOwner, repo });
-                        results.providers.github = { success: true, repo: result.data };
-                    }
-                    catch (err) {
-                        results.providers.github = { success: false, error: err.message };
-                    }
-                }
-                // Gitea
-                if (ctx.providerManager.giteaBaseUrl) {
-                    try {
-                        const result = await axios.get(`${ctx.providerManager.giteaBaseUrl}/api/v1/repos/${giteaOwner}/${repo}`, { headers: { Authorization: `token ${ctx.providerManager.giteaToken}` } });
-                        results.providers.gitea = { success: true, repo: result.data };
-                    }
-                    catch (err) {
-                        results.providers.gitea = { success: false, error: err.message };
-                    }
-                }
-                return results;
-            }
-            case 'update': {
-                const githubOwner = params.owner || process.env.GITHUB_USERNAME;
-                const giteaOwner = params.owner || process.env.GITEA_USERNAME;
-                const repo = params.repo;
-                if (!githubOwner || !repo) {
-                    throw new MCPError('VALIDATION_ERROR', 'owner and repo are required');
-                }
-                const results = { success: true, providers: {} };
-                // GitHub
-                if (ctx.providerManager.github) {
-                    try {
-                        const result = await ctx.providerManager.github.rest.repos.update({
-                            owner: githubOwner,
-                            repo,
-                            description: params.description,
-                            private: params.private,
-                            has_issues: params.has_issues,
-                            has_projects: params.has_projects,
-                            has_wiki: params.has_wiki,
-                        });
-                        results.providers.github = { success: true, repo: result.data };
-                    }
-                    catch (err) {
-                        results.providers.github = { success: false, error: err.message };
-                    }
-                }
-                // Gitea
-                if (ctx.providerManager.giteaBaseUrl) {
-                    try {
-                        const result = await axios.patch(`${ctx.providerManager.giteaBaseUrl}/api/v1/repos/${giteaOwner}/${repo}`, {
-                            description: params.description,
-                            private: params.private,
-                            has_issues: params.has_issues,
-                            has_projects: params.has_projects,
-                            has_wiki: params.has_wiki,
-                        }, { headers: { Authorization: `token ${ctx.providerManager.giteaToken}` } });
-                        results.providers.gitea = { success: true, repo: result.data };
-                    }
-                    catch (err) {
-                        results.providers.gitea = { success: false, error: err.message };
-                    }
-                }
-                return results;
-            }
-            case 'delete': {
-                const githubOwner = params.owner || process.env.GITHUB_USERNAME;
-                const giteaOwner = params.owner || process.env.GITEA_USERNAME;
-                const repo = params.repo;
-                if (!githubOwner || !repo) {
-                    throw new MCPError('VALIDATION_ERROR', 'owner and repo are required');
-                }
-                // Requer confirmação para deleção
-                if (!params.confirmDestructive) {
-                    throw new MCPError('SAFETY_WARNING', 'Repository deletion is destructive. Set confirmDestructive: true to proceed.', [
-                        'Repository deletion is permanent and cannot be undone.',
-                        'Ensure you have backups before proceeding.',
-                        'Consider archiving the repository instead.',
-                    ]);
-                }
-                const results = { success: true, providers: {} };
-                // GitHub
-                if (ctx.providerManager.github) {
-                    try {
-                        await ctx.providerManager.github.rest.repos.delete({ owner: githubOwner, repo });
-                        results.providers.github = { success: true, deleted: true };
-                    }
-                    catch (err) {
-                        results.providers.github = { success: false, error: err.message };
-                    }
-                }
-                // Gitea
-                if (ctx.providerManager.giteaBaseUrl) {
-                    try {
-                        await axios.delete(`${ctx.providerManager.giteaBaseUrl}/api/v1/repos/${giteaOwner}/${repo}`, { headers: { Authorization: `token ${ctx.providerManager.giteaToken}` } });
-                        results.providers.gitea = { success: true, deleted: true };
-                    }
-                    catch (err) {
-                        results.providers.gitea = { success: false, error: err.message };
-                    }
-                }
-                return results;
-            }
-            case 'fork': {
-                const githubOwner = params.owner || process.env.GITHUB_USERNAME;
-                const giteaOwner = params.owner || process.env.GITEA_USERNAME;
-                const repo = params.repo;
-                if (!githubOwner || !repo) {
-                    throw new MCPError('VALIDATION_ERROR', 'owner and repo are required');
-                }
-                const results = { success: true, providers: {} };
-                // GitHub
-                if (ctx.providerManager.github) {
-                    try {
-                        const result = await ctx.providerManager.github.rest.repos.createFork({
-                            owner: githubOwner,
-                            repo,
-                            organization: params.organization,
-                        });
-                        results.providers.github = { success: true, fork: result.data };
-                    }
-                    catch (err) {
-                        results.providers.github = { success: false, error: err.message };
-                    }
-                }
-                // Gitea
-                if (ctx.providerManager.giteaBaseUrl) {
-                    try {
-                        const result = await axios.post(`${ctx.providerManager.giteaBaseUrl}/api/v1/repos/${giteaOwner}/${repo}/forks`, { organization: params.organization }, { headers: { Authorization: `token ${ctx.providerManager.giteaToken}` } });
-                        results.providers.gitea = { success: true, fork: result.data };
-                    }
-                    catch (err) {
-                        results.providers.gitea = { success: false, error: err.message };
-                    }
-                }
-                return results;
-            }
-            case 'search': {
-                const query = params.query;
-                if (!query)
-                    throw new MCPError('VALIDATION_ERROR', 'query is required');
-                const results = { success: true, providers: {} };
-                // GitHub
-                if (ctx.providerManager.github) {
-                    try {
-                        const result = await ctx.providerManager.github.rest.search.repos({
-                            q: query,
-                            sort: params.sort,
-                            order: params.order,
-                            per_page: params.limit || 30,
-                        });
-                        results.providers.github = { success: true, repos: result.data.items, total: result.data.total_count };
-                    }
-                    catch (err) {
-                        results.providers.github = { success: false, error: err.message };
-                    }
-                }
-                // Gitea
-                if (ctx.providerManager.giteaBaseUrl) {
-                    try {
-                        const result = await axios.get(`${ctx.providerManager.giteaBaseUrl}/api/v1/repos/search`, {
-                            params: { q: query, limit: params.limit || 30, sort: params.sort },
-                            headers: { Authorization: `token ${ctx.providerManager.giteaToken}` }
-                        });
-                        results.providers.gitea = { success: true, repos: result.data.data, total: result.data.ok ? result.data.data.length : 0 };
-                    }
-                    catch (err) {
-                        results.providers.gitea = { success: false, error: err.message };
-                    }
-                }
-                return results;
-            }
-            case 'push': {
-                if (!projectPath)
-                    throw new MCPError('VALIDATION_ERROR', 'projectPath is required for push');
-                const remote = params.remote || 'origin';
-                let branch = params.branch;
-                const force = params.force || false;
-                const setUpstream = params.setUpstream !== undefined ? params.setUpstream : true;
-                // Segurança: verificar confirmação para operações destrutivas
-                if (force && !params.confirmDestructive) {
-                    throw new MCPError('SAFETY_WARNING', 'Force push is destructive and can overwrite remote history. Set confirmDestructive: true to confirm.', [
-                        'Force push will overwrite remote branch history.',
-                        'This operation is dangerous and can cause data loss for collaborators.',
-                        'Consider using regular push without force parameter.',
-                        'If you must force push, ensure you understand the consequences.',
-                    ]);
-                }
-                try {
-                    if (!branch) {
-                        branch = await ctx.gitAdapter.getCurrentBranch(projectPath);
-                    }
-                    await ctx.gitAdapter.push(projectPath, remote, branch, force, setUpstream);
-                    return {
-                        success: true,
-                        remote,
-                        branch,
-                        force,
-                        setUpstream,
-                        message: 'Push successful'
-                    };
-                }
-                catch (err) {
-                    throw new MCPError('PUSH_ERROR', `Failed to push: ${err.message}`);
-                }
-            }
-            default:
-                throw new MCPError('VALIDATION_ERROR', `Unsupported action: ${action}`);
-        }
-    }
-}

package/dist/types.d.ts

@@ -1,20 +0,0 @@
-import { ProviderManager } from './providers/providerManager.js';
-import { GitAdapter } from './utils/gitAdapter.js';
-export type MCPContext = {
-    providerManager: ProviderManager;
-    gitAdapter: GitAdapter;
-};
-export type ToolHandleResult = any;
-export interface Tool {
-    name: string;
-    description?: string;
-    inputSchema?: any;
-    handle(params: Record<string, any>, ctx: MCPContext): Promise<ToolHandleResult>;
-}
-export interface Resource {
-    uri: string;
-    name: string;
-    description: string;
-    mimeType: string;
-    content: string;
-}

package/dist/types.js

@@ -1 +0,0 @@
-export {};

package/dist/utils/agentHelpers.d.ts

@@ -1,11 +0,0 @@
-export declare function ensureProjectPath(params: Record<string, any>): string;
-export declare function ensureActionAllowed(action: string | undefined, allowedActions?: string[]): string;
-/**
- * Convenience: validate common tool call shape.
- * @param params tool call params
- * @param allowedActions optional array of allowed action strings
- */
-export declare function validateToolCall(params: Record<string, any>, allowedActions?: string[]): {
-    projectPath: string;
-    action: any;
-};

package/dist/utils/agentHelpers.js

@@ -1,41 +0,0 @@
-/**
- * Utilities to help AI agents build/validate tool calls.
- * Agents are responsible for detecting workspace and passing projectPath.
- * These helpers provide lightweight validation to avoid calling tools with
- * missing projectPath or invalid actions. Tools themselves will still
- * validate and throw MCPError if inputs are invalid.
- */
-import { MCPError } from './errors';
-export function ensureProjectPath(params) {
-    if (!params || typeof params !== 'object') {
-        throw new Error('params must be an object');
-    }
-    const projectPath = params.projectPath;
-    if (!projectPath || typeof projectPath !== 'string' || projectPath.trim() === '') {
-        throw new MCPError('VALIDATION_ERROR', 'projectPath is required for tool invocation');
-    }
-    return projectPath;
-}
-export function ensureActionAllowed(action, allowedActions) {
-    if (!action || typeof action !== 'string') {
-        throw new MCPError('VALIDATION_ERROR', 'action is required');
-    }
-    if (Array.isArray(allowedActions) && allowedActions.length > 0) {
-        if (!allowedActions.includes(action)) {
-            throw new MCPError('VALIDATION_ERROR', `Unsupported action: ${action}`);
-        }
-    }
-    return action;
-}
-/**
- * Convenience: validate common tool call shape.
- * @param params tool call params
- * @param allowedActions optional array of allowed action strings
- */
-export function validateToolCall(params, allowedActions) {
-    const projectPath = ensureProjectPath(params);
-    if (allowedActions) {
-        ensureActionAllowed(params.action, allowedActions);
-    }
-    return { projectPath, action: params.action };
-}

package/dist/utils/apiHelpers.d.ts

@@ -1,29 +0,0 @@
-interface RetryConfig {
-    maxRetries: number;
-    initialDelay: number;
-    maxDelay: number;
-    backoffFactor: number;
-}
-/**
- * Retry wrapper for operations that may have eventual consistency issues.
- * Used for GitHub API list operations after create/update.
- */
-export declare function retryUntilFound<T>(operation: () => Promise<T[]>, validateFn: (items: T[]) => boolean, config?: Partial<RetryConfig>): Promise<T[]>;
-/**
- * Retry a single operation with exponential backoff.
- */
-export declare function retryOperation<T>(operation: () => Promise<T>, shouldRetry: (error: any) => boolean, config?: Partial<RetryConfig>): Promise<T>;
-interface ValidationRule<T> {
-    validate: (data: T) => boolean;
-    errorMessage: string;
-}
-export declare function validateResponse<T>(data: T, rules: ValidationRule<T>[]): void;
-/**
- * Validate GitHub/Gitea stats response has required fields.
- */
-export declare function validateStatsResponse(response: any): any;
-/**
- * Validate contributors response.
- */
-export declare function validateContributorsResponse(response: any): any[];
-export {};