@andrebuzeli/git-mcp 10.0.9 → 11.0.0

package/dist/utils/logger.d.ts

@@ -1,45 +0,0 @@
-/**
- * Sistema de logging aprimorado para Git-MCP
- * Fornece diferentes níveis de log com rotação e sanitização
- */
-export declare enum LogLevel {
-    ERROR = 0,
-    WARN = 1,
-    INFO = 2,
-    DEBUG = 3
-}
-export interface LogEntry {
-    timestamp: string;
-    level: LogLevel;
-    message: string;
-    data?: any;
-    tool?: string;
-    userAgent?: string;
-}
-export declare class Logger {
-    private static instance;
-    private logLevel;
-    private maxEntries;
-    private logs;
-    private constructor();
-    static getInstance(): Logger;
-    /**
-     * Sanitiza dados sensíveis antes de logar
-     */
-    private sanitizeData;
-    private formatMessage;
-    private addLog;
-    error(message: string, data?: any, tool?: string): void;
-    warn(message: string, data?: any, tool?: string): void;
-    info(message: string, data?: any, tool?: string): void;
-    debug(message: string, data?: any, tool?: string): void;
-    getRecentLogs(level?: LogLevel, limit?: number): LogEntry[];
-    clearLogs(): void;
-    setLogLevel(level: LogLevel): void;
-}
-/**
- * Helper functions para logging em diferentes contextos
- */
-export declare function logToolExecution(toolName: string, args: any, result?: any, error?: Error): void;
-export declare function logSecurityEvent(event: string, details: any): void;
-export declare function logPerformanceMetric(operation: string, duration: number, details?: any): void;

package/dist/utils/logger.js

@@ -1,140 +0,0 @@
-/**
- * Sistema de logging aprimorado para Git-MCP
- * Fornece diferentes níveis de log com rotação e sanitização
- */
-export var LogLevel;
-(function (LogLevel) {
-    LogLevel[LogLevel["ERROR"] = 0] = "ERROR";
-    LogLevel[LogLevel["WARN"] = 1] = "WARN";
-    LogLevel[LogLevel["INFO"] = 2] = "INFO";
-    LogLevel[LogLevel["DEBUG"] = 3] = "DEBUG";
-})(LogLevel || (LogLevel = {}));
-export class Logger {
-    constructor(logLevel = LogLevel.INFO, maxEntries = 1000) {
-        this.logLevel = logLevel;
-        this.maxEntries = maxEntries;
-        this.logs = [];
-    }
-    static getInstance() {
-        if (!Logger.instance) {
-            const debugMode = process.env.DEBUG === 'true';
-            Logger.instance = new Logger(debugMode ? LogLevel.DEBUG : LogLevel.INFO);
-        }
-        return Logger.instance;
-    }
-    /**
-     * Sanitiza dados sensíveis antes de logar
-     */
-    sanitizeData(data) {
-        if (!data || typeof data !== 'object') {
-            return data;
-        }
-        const sensitiveKeys = ['token', 'password', 'secret', 'key', 'auth', 'credential'];
-        const sanitized = { ...data };
-        for (const key of Object.keys(sanitized)) {
-            const lowerKey = key.toLowerCase();
-            if (sensitiveKeys.some(sk => lowerKey.includes(sk))) {
-                sanitized[key] = '[REDACTED]';
-            }
-            else if (typeof sanitized[key] === 'object') {
-                sanitized[key] = this.sanitizeData(sanitized[key]);
-            }
-        }
-        return sanitized;
-    }
-    formatMessage(level, message, data, tool) {
-        const timestamp = new Date().toISOString();
-        const levelName = LogLevel[level];
-        const toolInfo = tool ? `[${tool}] ` : '';
-        const dataStr = data ? ` ${JSON.stringify(this.sanitizeData(data))}` : '';
-        return `[${timestamp}] ${levelName} ${toolInfo}${message}${dataStr}`;
-    }
-    addLog(entry) {
-        this.logs.push(entry);
-        // Rotação automática
-        if (this.logs.length > this.maxEntries) {
-            this.logs = this.logs.slice(-this.maxEntries);
-        }
-        // Log para stderr em modo debug
-        if (this.logLevel >= LogLevel.DEBUG || entry.level <= LogLevel.WARN) {
-            console.error(this.formatMessage(entry.level, entry.message, entry.data, entry.tool));
-        }
-    }
-    error(message, data, tool) {
-        if (this.logLevel >= LogLevel.ERROR) {
-            this.addLog({
-                timestamp: new Date().toISOString(),
-                level: LogLevel.ERROR,
-                message,
-                data,
-                tool,
-            });
-        }
-    }
-    warn(message, data, tool) {
-        if (this.logLevel >= LogLevel.WARN) {
-            this.addLog({
-                timestamp: new Date().toISOString(),
-                level: LogLevel.WARN,
-                message,
-                data,
-                tool,
-            });
-        }
-    }
-    info(message, data, tool) {
-        if (this.logLevel >= LogLevel.INFO) {
-            this.addLog({
-                timestamp: new Date().toISOString(),
-                level: LogLevel.INFO,
-                message,
-                data,
-                tool,
-            });
-        }
-    }
-    debug(message, data, tool) {
-        if (this.logLevel >= LogLevel.DEBUG) {
-            this.addLog({
-                timestamp: new Date().toISOString(),
-                level: LogLevel.DEBUG,
-                message,
-                data,
-                tool,
-            });
-        }
-    }
-    getRecentLogs(level, limit = 100) {
-        let filtered = this.logs;
-        if (level !== undefined) {
-            filtered = filtered.filter(entry => entry.level <= level);
-        }
-        return filtered.slice(-limit);
-    }
-    clearLogs() {
-        this.logs = [];
-    }
-    setLogLevel(level) {
-        this.logLevel = level;
-    }
-}
-/**
- * Helper functions para logging em diferentes contextos
- */
-export function logToolExecution(toolName, args, result, error) {
-    const logger = Logger.getInstance();
-    if (error) {
-        logger.error(`Tool execution failed: ${toolName}`, { args, error: error.message }, toolName);
-    }
-    else {
-        logger.info(`Tool executed successfully: ${toolName}`, { args, result: result ? 'success' : 'no result' }, toolName);
-    }
-}
-export function logSecurityEvent(event, details) {
-    const logger = Logger.getInstance();
-    logger.warn(`Security event: ${event}`, details, 'SECURITY');
-}
-export function logPerformanceMetric(operation, duration, details) {
-    const logger = Logger.getInstance();
-    logger.debug(`Performance: ${operation} took ${duration}ms`, details, 'PERFORMANCE');
-}

package/dist/utils/rateLimiter.d.ts

@@ -1,113 +0,0 @@
-/**
- * Sistema de rate limiting para proteção contra abuso
- * Implementa algoritmo token bucket com diferentes limites por tipo de operação
- */
-export interface RateLimitConfig {
-    maxRequests: number;
-    windowMs: number;
-    burst?: number;
-    keyGenerator?: (toolName: string, args: any) => string;
-}
-export interface RateLimitEntry {
-    tokens: number;
-    lastRefill: number;
-    requestCount: number;
-    windowStart: number;
-}
-export declare class RateLimiter {
-    private static instance;
-    private limits;
-    private configs;
-    private cleanupInterval;
-    private constructor();
-    static getInstance(): RateLimiter;
-    /**
-     * Configurações padrão por tipo de operação
-     */
-    private setupDefaultConfigs;
-    /**
-     * Classifica operação por tipo
-     */
-    private classifyOperation;
-    /**
-     * Gera chave única para rate limiting
-     */
-    private generateKey;
-    /**
-     * Verifica se request está dentro dos limites
-     */
-    checkLimit(toolName: string, args: any): {
-        allowed: boolean;
-        remaining: number;
-        resetTime: number;
-    };
-    /**
-     * Configura limites personalizados para ferramenta específica
-     */
-    setCustomLimit(toolName: string, config: RateLimitConfig): void;
-    /**
-     * Remove limites para ferramenta específica
-     */
-    removeCustomLimit(toolName: string): void;
-    /**
-     * Obtém estatísticas de uso
-     */
-    getStats(): {
-        totalKeys: number;
-        configs: Map<string, RateLimitConfig>;
-        activeLimits: Array<{
-            key: string;
-            entry: RateLimitEntry;
-            config: RateLimitConfig;
-        }>;
-    };
-    /**
-     * Limpa entradas antigas
-     */
-    private startCleanup;
-    /**
-     * Para o cleanup automático
-     */
-    stopCleanup(): void;
-    /**
-     * Limpa todos os limites
-     */
-    clear(): void;
-}
-/**
- * Middleware de rate limiting para integração com ferramentas
- */
-export declare function withRateLimit(toolName: string, customConfig?: RateLimitConfig): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
-/**
- * Helper functions para rate limiting
- */
-export declare const rateLimitHelpers: {
-    /**
-     * Verifica limite antes de executar operação
-     */
-    checkLimit(toolName: string, args: any): {
-        allowed: boolean;
-        remaining: number;
-        resetTime: number;
-    };
-    /**
-     * Configura limite personalizado
-     */
-    setCustomLimit(toolName: string, maxRequests: number, windowMs: number, burst?: number): void;
-    /**
-     * Obtém estatísticas
-     */
-    getStats(): {
-        totalKeys: number;
-        configs: Map<string, RateLimitConfig>;
-        activeLimits: Array<{
-            key: string;
-            entry: RateLimitEntry;
-            config: RateLimitConfig;
-        }>;
-    };
-    /**
-     * Limpa todos os limites
-     */
-    clear(): void;
-};

package/dist/utils/rateLimiter.js

@@ -1,257 +0,0 @@
-/**
- * Sistema de rate limiting para proteção contra abuso
- * Implementa algoritmo token bucket com diferentes limites por tipo de operação
- */
-export class RateLimiter {
-    constructor() {
-        this.cleanupInterval = null;
-        this.limits = new Map();
-        this.configs = new Map();
-        this.setupDefaultConfigs();
-        this.startCleanup();
-    }
-    static getInstance() {
-        if (!RateLimiter.instance) {
-            RateLimiter.instance = new RateLimiter();
-        }
-        return RateLimiter.instance;
-    }
-    /**
-     * Configurações padrão por tipo de operação
-     */
-    setupDefaultConfigs() {
-        // Operações de leitura - limite mais alto
-        this.configs.set('read', {
-            maxRequests: 100,
-            windowMs: 60000, // 1 minuto
-            burst: 10,
-        });
-        // Operações de escrita - limite médio
-        this.configs.set('write', {
-            maxRequests: 30,
-            windowMs: 60000, // 1 minuto
-            burst: 5,
-        });
-        // Operações destrutivas - limite baixo
-        this.configs.set('destructive', {
-            maxRequests: 10,
-            windowMs: 60000, // 1 minuto
-            burst: 2,
-        });
-        // Operações de upload - limite especial
-        this.configs.set('upload', {
-            maxRequests: 20,
-            windowMs: 60000, // 1 minuto
-            burst: 3,
-        });
-        // Default para operações não categorizadas
-        this.configs.set('default', {
-            maxRequests: 50,
-            windowMs: 60000, // 1 minuto
-            burst: 5,
-        });
-    }
-    /**
-     * Classifica operação por tipo
-     */
-    classifyOperation(toolName) {
-        const destructiveOps = ['reset', 'force', 'delete', 'destroy', 'clean'];
-        const uploadOps = ['upload', 'push', 'commit'];
-        const writeOps = ['create', 'update', 'edit', 'modify', 'add', 'remove'];
-        const toolLower = toolName.toLowerCase();
-        if (destructiveOps.some(op => toolLower.includes(op))) {
-            return 'destructive';
-        }
-        if (uploadOps.some(op => toolLower.includes(op))) {
-            return 'upload';
-        }
-        if (writeOps.some(op => toolLower.includes(op))) {
-            return 'write';
-        }
-        if (toolLower.includes('read') || toolLower.includes('get') || toolLower.includes('list')) {
-            return 'read';
-        }
-        return 'default';
-    }
-    /**
-     * Gera chave única para rate limiting
-     */
-    generateKey(toolName, args) {
-        // Usar projectPath como identificador principal, fallback para toolName
-        const projectPath = args?.projectPath || 'global';
-        const operationType = this.classifyOperation(toolName);
-        return `rate_limit:${operationType}:${projectPath}:${toolName}`;
-    }
-    /**
-     * Verifica se request está dentro dos limites
-     */
-    checkLimit(toolName, args) {
-        const operationType = this.classifyOperation(toolName);
-        const config = this.configs.get(operationType) || this.configs.get('default');
-        const key = config.keyGenerator ? config.keyGenerator(toolName, args) : this.generateKey(toolName, args);
-        const now = Date.now();
-        let entry = this.limits.get(key);
-        if (!entry) {
-            entry = {
-                tokens: config.maxRequests,
-                lastRefill: now,
-                requestCount: 0,
-                windowStart: now,
-            };
-            this.limits.set(key, entry);
-        }
-        // Refill tokens baseado no tempo decorrido
-        const timePassed = now - entry.lastRefill;
-        const tokensToAdd = Math.floor(timePassed / (config.windowMs / config.maxRequests));
-        if (tokensToAdd > 0) {
-            entry.tokens = Math.min(config.maxRequests, entry.tokens + tokensToAdd);
-            entry.lastRefill = now;
-        }
-        // Verificar janela de tempo
-        if (now - entry.windowStart > config.windowMs) {
-            entry.requestCount = 0;
-            entry.windowStart = now;
-        }
-        // Verificar burst limit
-        const burstLimit = config.burst || config.maxRequests;
-        if (entry.requestCount >= burstLimit) {
-            return {
-                allowed: false,
-                remaining: 0,
-                resetTime: entry.windowStart + config.windowMs,
-            };
-        }
-        // Verificar token bucket
-        if (entry.tokens <= 0) {
-            return {
-                allowed: false,
-                remaining: 0,
-                resetTime: entry.lastRefill + (config.windowMs / config.maxRequests),
-            };
-        }
-        // Consumir token e registrar request
-        entry.tokens--;
-        entry.requestCount++;
-        return {
-            allowed: true,
-            remaining: entry.tokens,
-            resetTime: entry.lastRefill + (config.windowMs / config.maxRequests),
-        };
-    }
-    /**
-     * Configura limites personalizados para ferramenta específica
-     */
-    setCustomLimit(toolName, config) {
-        this.configs.set(toolName, config);
-    }
-    /**
-     * Remove limites para ferramenta específica
-     */
-    removeCustomLimit(toolName) {
-        this.configs.delete(toolName);
-    }
-    /**
-     * Obtém estatísticas de uso
-     */
-    getStats() {
-        const activeLimits = [];
-        for (const [key, entry] of this.limits.entries()) {
-            const operationType = key.split(':')[1] || 'default';
-            const config = this.configs.get(operationType) || this.configs.get('default');
-            activeLimits.push({ key, entry, config });
-        }
-        return {
-            totalKeys: this.limits.size,
-            configs: new Map(this.configs),
-            activeLimits,
-        };
-    }
-    /**
-     * Limpa entradas antigas
-     */
-    startCleanup() {
-        // Limpar a cada 5 minutos
-        this.cleanupInterval = setInterval(() => {
-            const now = Date.now();
-            const maxAge = 10 * 60 * 1000; // 10 minutos
-            for (const [key, entry] of this.limits.entries()) {
-                if (now - entry.lastRefill > maxAge) {
-                    this.limits.delete(key);
-                }
-            }
-        }, 5 * 60 * 1000);
-    }
-    /**
-     * Para o cleanup automático
-     */
-    stopCleanup() {
-        if (this.cleanupInterval) {
-            clearInterval(this.cleanupInterval);
-            this.cleanupInterval = null;
-        }
-    }
-    /**
-     * Limpa todos os limites
-     */
-    clear() {
-        this.limits.clear();
-    }
-}
-/**
- * Middleware de rate limiting para integração com ferramentas
- */
-export function withRateLimit(toolName, customConfig) {
-    const rateLimiter = RateLimiter.getInstance();
-    if (customConfig) {
-        rateLimiter.setCustomLimit(toolName, customConfig);
-    }
-    return function (target, propertyKey, descriptor) {
-        const originalMethod = descriptor.value;
-        descriptor.value = async function (...args) {
-            const argsObj = args[0] || {};
-            const limitResult = rateLimiter.checkLimit(toolName, argsObj);
-            if (!limitResult.allowed) {
-                const error = new Error(`Rate limit exceeded for ${toolName}. Try again in ${Math.ceil((limitResult.resetTime - Date.now()) / 1000)}s`);
-                error.code = 'RATE_LIMIT_EXCEEDED';
-                error.resetTime = limitResult.resetTime;
-                error.remaining = limitResult.remaining;
-                throw error;
-            }
-            return originalMethod.apply(this, args);
-        };
-        return descriptor;
-    };
-}
-/**
- * Helper functions para rate limiting
- */
-export const rateLimitHelpers = {
-    /**
-     * Verifica limite antes de executar operação
-     */
-    checkLimit(toolName, args) {
-        const rateLimiter = RateLimiter.getInstance();
-        return rateLimiter.checkLimit(toolName, args);
-    },
-    /**
-     * Configura limite personalizado
-     */
-    setCustomLimit(toolName, maxRequests, windowMs, burst) {
-        const rateLimiter = RateLimiter.getInstance();
-        rateLimiter.setCustomLimit(toolName, { maxRequests, windowMs, burst });
-    },
-    /**
-     * Obtém estatísticas
-     */
-    getStats() {
-        const rateLimiter = RateLimiter.getInstance();
-        return rateLimiter.getStats();
-    },
-    /**
-     * Limpa todos os limites
-     */
-    clear() {
-        const rateLimiter = RateLimiter.getInstance();
-        rateLimiter.clear();
-    },
-};

package/dist/utils/repoHelpers.d.ts

@@ -1,44 +0,0 @@
-/**
- * Helper functions to extract repository information automatically
- */
-/**
- * Extract repository name from project path
- * Normalizes: spaces to hyphens, lowercase, keeps alphanumeric and hyphens/underscores
- */
-export declare function getRepoNameFromPath(projectPath: string): string;
-/**
- * Get GitHub owner from environment
- */
-export declare function getGitHubOwner(): string | undefined;
-/**
- * Get Gitea owner from environment
- */
-export declare function getGiteaOwner(): string | undefined;
-/**
- * Get Gitea base URL from environment
- */
-export declare function getGiteaUrl(): string | undefined;
-/**
- * Build GitHub repository URL
- */
-export declare function buildGitHubUrl(owner: string, repo: string): string;
-/**
- * Build Gitea repository URL with credentials
- */
-export declare function buildGiteaUrl(owner: string, repo: string): string;
-/**
- * Get repository info from project path and environment
- */
-export declare function getRepoInfo(projectPath: string): {
-    repoName: string;
-    githubOwner: string | undefined;
-    giteaOwner: string | undefined;
-    githubUrl: string | undefined;
-    giteaUrl: string | undefined;
-};
-/**
- * Normalize parameters from different IDEs/agents
- * Maps common Git commands to tool actions
- * Handles both 'action' and 'command' parameters
- */
-export declare function normalizeToolParams(params: Record<string, any>): Record<string, any>;