@andrebuzeli/git-mcp 10.0.8 → 11.0.0

package/dist/utils/apiHelpers.js

@@ -1,125 +0,0 @@
-// ============================================================================
-// API HELPER UTILITIES
-// Retry logic, validation, and eventual consistency handling
-// ============================================================================
-const DEFAULT_RETRY_CONFIG = {
-    maxRetries: 5,
-    initialDelay: 500,
-    maxDelay: 5000,
-    backoffFactor: 2
-};
-async function exponentialBackoff(attemptNumber, config) {
-    const delay = Math.min(config.initialDelay * Math.pow(config.backoffFactor, attemptNumber), config.maxDelay);
-    await new Promise(resolve => setTimeout(resolve, delay));
-}
-/**
- * Retry wrapper for operations that may have eventual consistency issues.
- * Used for GitHub API list operations after create/update.
- */
-export async function retryUntilFound(operation, validateFn, config = {}) {
-    const finalConfig = { ...DEFAULT_RETRY_CONFIG, ...config };
-    let lastResult = [];
-    for (let attempt = 0; attempt < finalConfig.maxRetries; attempt++) {
-        lastResult = await operation();
-        // Validate result
-        if (validateFn(lastResult)) {
-            return lastResult;
-        }
-        // If not last attempt, wait with exponential backoff
-        if (attempt < finalConfig.maxRetries - 1) {
-            console.log(`Retry ${attempt + 1}/${finalConfig.maxRetries}: ` +
-                `Waiting for consistency...`);
-            await exponentialBackoff(attempt, finalConfig);
-        }
-    }
-    // Return last result even if validation fails
-    console.warn(`Max retries (${finalConfig.maxRetries}) exceeded. ` +
-        `Returning last result with ${lastResult.length} items.`);
-    return lastResult;
-}
-/**
- * Retry a single operation with exponential backoff.
- */
-export async function retryOperation(operation, shouldRetry, config = {}) {
-    const finalConfig = { ...DEFAULT_RETRY_CONFIG, ...config };
-    let lastError = null;
-    for (let attempt = 0; attempt < finalConfig.maxRetries; attempt++) {
-        try {
-            return await operation();
-        }
-        catch (error) {
-            lastError = error;
-            // Check if we should retry
-            if (!shouldRetry(error)) {
-                throw error;
-            }
-            // If not last attempt, wait
-            if (attempt < finalConfig.maxRetries - 1) {
-                console.log(`Retry ${attempt + 1}/${finalConfig.maxRetries}: ` +
-                    `${error.message}`);
-                await exponentialBackoff(attempt, finalConfig);
-            }
-        }
-    }
-    throw lastError || new Error('Max retries exceeded');
-}
-export function validateResponse(data, rules) {
-    for (const rule of rules) {
-        if (!rule.validate(data)) {
-            throw new Error(rule.errorMessage);
-        }
-    }
-}
-/**
- * Validate GitHub/Gitea stats response has required fields.
- */
-export function validateStatsResponse(response) {
-    const data = response.data;
-    // List of required fields
-    const requiredFields = [
-        { field: 'stargazers_count', type: 'number' },
-        { field: 'watchers_count', type: 'number' },
-        { field: 'forks_count', type: 'number' },
-        { field: 'open_issues_count', type: 'number' },
-        { field: 'size', type: 'number' }
-    ];
-    // Check for Gitea field naming (stars_count vs stargazers_count)
-    const giteaFields = [
-        { field: 'stars_count', type: 'number' },
-        { field: 'watchers_count', type: 'number' },
-        { field: 'forks_count', type: 'number' },
-        { field: 'open_issues_count', type: 'number' },
-        { field: 'size', type: 'number' }
-    ];
-    // Validate field by field
-    const missingFields = [];
-    const invalidFields = [];
-    const fieldsToCheck = data.stargazers_count !== undefined ? requiredFields : giteaFields;
-    for (const { field, type } of fieldsToCheck) {
-        if (!(field in data)) {
-            missingFields.push(field);
-        }
-        else if (typeof data[field] !== type) {
-            invalidFields.push(`${field} (expected ${type}, got ${typeof data[field]})`);
-        }
-    }
-    if (missingFields.length > 0) {
-        throw new Error(`Stats validation failed: Missing fields: ${missingFields.join(', ')}`);
-    }
-    if (invalidFields.length > 0) {
-        throw new Error(`Stats validation failed: Invalid fields: ${invalidFields.join(', ')}`);
-    }
-    return data;
-}
-/**
- * Validate contributors response.
- */
-export function validateContributorsResponse(response) {
-    if (!Array.isArray(response.data)) {
-        throw new Error('Contributors validation failed: Expected array');
-    }
-    if (response.data.length === 0) {
-        console.warn('No contributors found (repository may be empty or new)');
-    }
-    return response.data;
-}

package/dist/utils/cache.d.ts

@@ -1,96 +0,0 @@
-/**
- * Sistema de cache inteligente para Git-MCP
- * Otimiza operações frequentes com TTL e invalidação automática
- */
-export interface CacheEntry {
-    data: any;
-    timestamp: number;
-    ttl: number;
-    key: string;
-}
-export declare class SimpleCache {
-    private static instance;
-    private cache;
-    private defaultTTL;
-    private maxEntries;
-    private constructor();
-    static getInstance(): SimpleCache;
-    /**
-     * Gera chave única para cache baseada em parâmetros
-     */
-    private generateKey;
-    /**
-     * Verifica se entrada está expirada
-     */
-    private isExpired;
-    /**
-     * Remove entradas expiradas
-     */
-    private cleanup;
-    /**
-     * Obtém valor do cache
-     */
-    get(key: string): any | null;
-    /**
-     * Define valor no cache
-     */
-    set(key: string, data: any, ttl?: number): void;
-    /**
-     * Remove entrada do cache
-     */
-    delete(key: string): boolean;
-    /**
-     * Limpa todo o cache
-     */
-    clear(): void;
-    /**
-     * Obtém estatísticas do cache
-     */
-    getStats(): {
-        size: number;
-        maxEntries: number;
-        defaultTTL: number;
-        expiredEntries: number;
-    };
-    /**
-     * Cache com função de busca - pattern de memoização
-     */
-    memoize<T>(key: string, fn: () => Promise<T>, ttl?: number): Promise<T>;
-    /**
-     * Cache específico para operações Git
-     */
-    memoizeGitOperation<T>(operation: string, projectPath: string, fn: () => Promise<T>, ttl?: number): Promise<T>;
-}
-/**
- * Decorator para cache automático de métodos
- */
-export declare function Cacheable(ttl?: number, prefix?: string): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
-/**
- * Helper functions para cache de operações comuns
- */
-export declare const cacheHelpers: {
-    /**
-     * Cache para informações de repositório
-     */
-    getRepoInfo(projectPath: string, fn: () => Promise<any>): Promise<any>;
-    /**
-     * Cache para branches
-     */
-    getBranches(projectPath: string, fn: () => Promise<any>): Promise<any>;
-    /**
-     * Cache para commits/histórico
-     */
-    getCommits(projectPath: string, limit: number, fn: () => Promise<any>): Promise<any>;
-    /**
-     * Cache para status do repositório
-     */
-    getStatus(projectPath: string, fn: () => Promise<any>): Promise<any>;
-    /**
-     * Invalida cache específico do repositório
-     */
-    invalidateRepoCache(projectPath: string): void;
-    /**
-     * Limpa todo cache de operações Git
-     */
-    clearGitCache(): void;
-};

package/dist/utils/cache.js

@@ -1,208 +0,0 @@
-/**
- * Sistema de cache inteligente para Git-MCP
- * Otimiza operações frequentes com TTL e invalidação automática
- */
-export class SimpleCache {
-    constructor(defaultTTL = 300000, maxEntries = 1000) {
-        this.cache = new Map();
-        this.defaultTTL = defaultTTL;
-        this.maxEntries = maxEntries;
-    }
-    static getInstance() {
-        if (!SimpleCache.instance) {
-            SimpleCache.instance = new SimpleCache();
-        }
-        return SimpleCache.instance;
-    }
-    /**
-     * Gera chave única para cache baseada em parâmetros
-     */
-    generateKey(prefix, params) {
-        const sortedParams = Object.keys(params)
-            .sort()
-            .reduce((acc, key) => {
-            acc[key] = params[key];
-            return acc;
-        }, {});
-        return `${prefix}:${JSON.stringify(sortedParams)}`;
-    }
-    /**
-     * Verifica se entrada está expirada
-     */
-    isExpired(entry) {
-        return Date.now() - entry.timestamp > entry.ttl;
-    }
-    /**
-     * Remove entradas expiradas
-     */
-    cleanup() {
-        const now = Date.now();
-        for (const [key, entry] of this.cache.entries()) {
-            if (now - entry.timestamp > entry.ttl) {
-                this.cache.delete(key);
-            }
-        }
-        // Remove entradas antigas se exceder limite
-        if (this.cache.size > this.maxEntries) {
-            const entries = Array.from(this.cache.entries());
-            entries.sort((a, b) => a[1].timestamp - b[1].timestamp);
-            const toRemove = entries.slice(0, this.cache.size - this.maxEntries);
-            toRemove.forEach(([key]) => this.cache.delete(key));
-        }
-    }
-    /**
-     * Obtém valor do cache
-     */
-    get(key) {
-        const entry = this.cache.get(key);
-        if (!entry) {
-            return null;
-        }
-        if (this.isExpired(entry)) {
-            this.cache.delete(key);
-            return null;
-        }
-        return entry.data;
-    }
-    /**
-     * Define valor no cache
-     */
-    set(key, data, ttl) {
-        const entry = {
-            data,
-            timestamp: Date.now(),
-            ttl: ttl || this.defaultTTL,
-            key,
-        };
-        this.cache.set(key, entry);
-        // Limpeza periódica
-        if (Math.random() < 0.01) { // 1% de chance
-            this.cleanup();
-        }
-    }
-    /**
-     * Remove entrada do cache
-     */
-    delete(key) {
-        return this.cache.delete(key);
-    }
-    /**
-     * Limpa todo o cache
-     */
-    clear() {
-        this.cache.clear();
-    }
-    /**
-     * Obtém estatísticas do cache
-     */
-    getStats() {
-        const now = Date.now();
-        let expiredCount = 0;
-        for (const entry of this.cache.values()) {
-            if (now - entry.timestamp > entry.ttl) {
-                expiredCount++;
-            }
-        }
-        return {
-            size: this.cache.size,
-            maxEntries: this.maxEntries,
-            defaultTTL: this.defaultTTL,
-            expiredEntries: expiredCount,
-        };
-    }
-    /**
-     * Cache com função de busca - pattern de memoização
-     */
-    async memoize(key, fn, ttl) {
-        const cached = this.get(key);
-        if (cached !== null) {
-            return cached;
-        }
-        const result = await fn();
-        this.set(key, result, ttl);
-        return result;
-    }
-    /**
-     * Cache específico para operações Git
-     */
-    async memoizeGitOperation(operation, projectPath, fn, ttl = 60000 // 1 minuto para operações Git
-    ) {
-        const key = this.generateKey(`git:${operation}`, { projectPath });
-        return this.memoize(key, fn, ttl);
-    }
-}
-/**
- * Decorator para cache automático de métodos
- */
-export function Cacheable(ttl, prefix) {
-    return function (target, propertyKey, descriptor) {
-        const originalMethod = descriptor.value;
-        descriptor.value = async function (...args) {
-            const cache = SimpleCache.getInstance();
-            const keyPrefix = prefix || `${target.constructor.name}:${propertyKey}`;
-            const cacheKey = `${keyPrefix}:${JSON.stringify(args)}`;
-            return cache.memoize(cacheKey, () => originalMethod.apply(this, args), ttl);
-        };
-        return descriptor;
-    };
-}
-/**
- * Helper functions para cache de operações comuns
- */
-export const cacheHelpers = {
-    /**
-     * Cache para informações de repositório
-     */
-    async getRepoInfo(projectPath, fn) {
-        const cache = SimpleCache.getInstance();
-        return cache.memoizeGitOperation('repo_info', projectPath, fn, 300000); // 5 minutos
-    },
-    /**
-     * Cache para branches
-     */
-    async getBranches(projectPath, fn) {
-        const cache = SimpleCache.getInstance();
-        return cache.memoizeGitOperation('branches', projectPath, fn, 120000); // 2 minutos
-    },
-    /**
-     * Cache para commits/histórico
-     */
-    async getCommits(projectPath, limit, fn) {
-        const cache = SimpleCache.getInstance();
-        return cache.memoizeGitOperation('commits', `${projectPath}:${limit}`, fn, 60000); // 1 minuto
-    },
-    /**
-     * Cache para status do repositório
-     */
-    async getStatus(projectPath, fn) {
-        const cache = SimpleCache.getInstance();
-        return cache.memoizeGitOperation('status', projectPath, fn, 30000); // 30 segundos
-    },
-    /**
-     * Invalida cache específico do repositório
-     */
-    invalidateRepoCache(projectPath) {
-        const cache = SimpleCache.getInstance();
-        const operations = ['repo_info', 'branches', 'commits', 'status'];
-        operations.forEach(operation => {
-            const keyPattern = `git:${operation}:${projectPath}`;
-            // Remove todas as entradas que começam com este padrão
-            for (const [key] of cache['cache'].entries()) {
-                if (key.startsWith(keyPattern)) {
-                    cache.delete(key);
-                }
-            }
-        });
-    },
-    /**
-     * Limpa todo cache de operações Git
-     */
-    clearGitCache() {
-        const cache = SimpleCache.getInstance();
-        for (const [key] of cache['cache'].entries()) {
-            if (key.startsWith('git:')) {
-                cache.delete(key);
-            }
-        }
-    },
-};

package/dist/utils/contextDetector.js

@@ -1 +0,0 @@
-"use strict";

package/dist/utils/errors.d.ts

@@ -1,13 +0,0 @@
-export declare function createErrorResponse(code: string, message: string, suggestions?: string[]): {
-    success: boolean;
-    error: {
-        code: string;
-        message: string;
-        suggestions: string[];
-    };
-};
-export declare class MCPError extends Error {
-    code: string;
-    suggestions?: string[];
-    constructor(code: string, message: string, suggestions?: string[]);
-}

package/dist/utils/errors.js

@@ -1,17 +0,0 @@
-export function createErrorResponse(code, message, suggestions) {
-    return {
-        success: false,
-        error: {
-            code,
-            message,
-            suggestions: suggestions ?? [],
-        },
-    };
-}
-export class MCPError extends Error {
-    constructor(code, message, suggestions) {
-        super(message);
-        this.code = code;
-        this.suggestions = suggestions;
-    }
-}

package/dist/utils/gitAdapter.d.ts

@@ -1,224 +0,0 @@
-import { ProviderManager } from '../providers/providerManager.js';
-export interface Author {
-    name: string;
-    email: string;
-    timestamp?: number;
-    timezoneOffset?: number;
-}
-export interface StatusResult {
-    modified: string[];
-    created: string[];
-    deleted: string[];
-    renamed: string[];
-    not_added: string[];
-    staged: string[];
-    conflicted: string[];
-    current: string;
-    tracking: string | null;
-    ahead: number;
-    behind: number;
-    isClean: boolean;
-    files: Array<{
-        path: string;
-        index?: string;
-        working_dir: string;
-    }>;
-}
-export interface CommitResult {
-    commit: string;
-    summary: {
-        changes: number;
-        insertions: number;
-        deletions: number;
-    };
-    author: Author;
-    branch: string;
-}
-export interface BranchInfo {
-    name: string;
-    current: boolean;
-    commit: string;
-    label?: string;
-}
-export interface RemoteInfo {
-    name: string;
-    remote: string;
-    url: string;
-    fetch?: string;
-}
-export interface TagInfo {
-    name: string;
-    commit: string;
-    date?: Date;
-    message?: string;
-    taggerName?: string;
-    taggerEmail?: string;
-}
-export interface LogEntry {
-    hash: string;
-    date: string;
-    message: string;
-    author_name: string;
-    author_email: string;
-    refs?: string;
-}
-export interface MergeResult {
-    success: boolean;
-    conflicts?: string[];
-    message?: string;
-}
-export interface DiffResult {
-    files: Array<{
-        path: string;
-        additions: number;
-        deletions: number;
-        changes: number;
-    }>;
-    summary: {
-        additions: number;
-        deletions: number;
-        changes: number;
-    };
-}
-export interface StashEntry {
-    index: number;
-    message: string;
-    date: Date;
-    ref: string;
-}
-export interface GitAdapter {
-    init(dir: string, defaultBranch?: string): Promise<void>;
-    status(dir: string): Promise<StatusResult>;
-    add(dir: string, files: string[]): Promise<void>;
-    remove(dir: string, files: string[]): Promise<void>;
-    commit(dir: string, message: string, author?: Author): Promise<string>;
-    listBranches(dir: string, remote?: boolean): Promise<string[]>;
-    createBranch(dir: string, branchName: string, startPoint?: string): Promise<void>;
-    deleteBranch(dir: string, branchName: string, force?: boolean): Promise<void>;
-    checkout(dir: string, ref: string): Promise<void>;
-    getCurrentBranch(dir: string): Promise<string>;
-    addRemote(dir: string, name: string, url: string): Promise<void>;
-    removeRemote(dir: string, name: string): Promise<void>;
-    listRemotes(dir: string): Promise<RemoteInfo[]>;
-    fetch(dir: string, remote: string, ref?: string): Promise<void>;
-    pull(dir: string, remote: string, branch: string): Promise<void>;
-    push(dir: string, remote: string, branch: string, force?: boolean, setUpstream?: boolean): Promise<void>;
-    merge(dir: string, theirBranch: string, author?: Author): Promise<MergeResult>;
-    listTags(dir: string): Promise<string[]>;
-    createTag(dir: string, tagName: string, ref?: string, message?: string): Promise<void>;
-    deleteTag(dir: string, tagName: string): Promise<void>;
-    pushTag(dir: string, remote: string, tagName: string): Promise<void>;
-    log(dir: string, options?: {
-        maxCount?: number;
-        ref?: string;
-    }): Promise<LogEntry[]>;
-    diff(dir: string, ref1?: string, ref2?: string): Promise<DiffResult>;
-    reset(dir: string, ref: string, mode: 'soft' | 'mixed' | 'hard'): Promise<void>;
-    saveStash(dir: string, message?: string, includeUntracked?: boolean): Promise<void>;
-    listStash(dir: string): Promise<StashEntry[]>;
-    applyStash(dir: string, stashRef?: string): Promise<void>;
-    popStash(dir: string, stashRef?: string): Promise<void>;
-    dropStash(dir: string, stashRef?: string): Promise<void>;
-    clearStash(dir: string): Promise<void>;
-    getConfig(dir: string, key: string, scope?: 'local' | 'global' | 'system'): Promise<string | undefined>;
-    setConfig(dir: string, key: string, value: string, scope?: 'local' | 'global' | 'system'): Promise<void>;
-    listConfig(dir: string, scope?: 'local' | 'global' | 'system'): Promise<Record<string, string>>;
-    unsetConfig(dir: string, key: string, scope?: 'local' | 'global' | 'system'): Promise<void>;
-}
-export declare class IsomorphicGitAdapter implements GitAdapter {
-    private providerManager;
-    constructor(providerManager: ProviderManager);
-    /**
-     * Get authentication callback for HTTP operations
-     */
-    private getAuthCallback;
-    /**
-     * Get author information from provider or fallback to config/default
-     * Auto-configures local git config if provider returns user info but config is missing
-     */
-    private getAuthor;
-    /**
-     * Convert isomorphic-git status matrix to StatusResult format
-     */
-    private convertStatusMatrix;
-    init(dir: string, defaultBranch?: string): Promise<void>;
-    status(dir: string): Promise<StatusResult>;
-    add(dir: string, files: string[]): Promise<void>;
-    remove(dir: string, files: string[]): Promise<void>;
-    commit(dir: string, message: string, providedAuthor?: Author): Promise<string>;
-    listBranches(dir: string, remote?: boolean): Promise<string[]>;
-    createBranch(dir: string, branchName: string, startPoint?: string): Promise<void>;
-    deleteBranch(dir: string, branchName: string, force?: boolean): Promise<void>;
-    renameBranch(dir: string, oldName: string, newName: string): Promise<void>;
-    checkout(dir: string, ref: string): Promise<void>;
-    getCurrentBranch(dir: string): Promise<string>;
-    addRemote(dir: string, name: string, url: string): Promise<void>;
-    removeRemote(dir: string, name: string): Promise<void>;
-    listRemotes(dir: string): Promise<RemoteInfo[]>;
-    fetch(dir: string, remote: string, ref?: string): Promise<void>;
-    pull(dir: string, remote: string, branch: string): Promise<void>;
-    push(dir: string, remote: string, branch: string, force?: boolean, setUpstream?: boolean): Promise<void>;
-    merge(dir: string, theirBranch: string, author?: Author): Promise<MergeResult>;
-    listTags(dir: string): Promise<string[]>;
-    createTag(dir: string, tagName: string, ref?: string, message?: string): Promise<void>;
-    deleteTag(dir: string, tagName: string): Promise<void>;
-    pushTag(dir: string, remote: string, tagName: string): Promise<void>;
-    log(dir: string, options?: {
-        maxCount?: number;
-        ref?: string;
-    }): Promise<LogEntry[]>;
-    diff(dir: string, ref1?: string, ref2?: string): Promise<DiffResult>;
-    reset(dir: string, ref: string, mode: 'soft' | 'mixed' | 'hard'): Promise<void>;
-    /**
-     * Get stash reflog path
-     */
-    private getStashReflogPath;
-    /**
-     * Get stash ref path
-     */
-    private getStashRefPath;
-    /**
-     * Read stash reflog entries
-     */
-    private readStashReflog;
-    /**
-     * Write stash reflog entry
-     */
-    private writeStashReflogEntry;
-    saveStash(dir: string, message?: string, includeUntracked?: boolean): Promise<void>;
-    listStash(dir: string): Promise<StashEntry[]>;
-    applyStash(dir: string, stashRef?: string): Promise<void>;
-    popStash(dir: string, stashRef?: string): Promise<void>;
-    dropStash(dir: string, stashRef?: string): Promise<void>;
-    clearStash(dir: string): Promise<void>;
-    /**
-     * Get global Git config path (~/.gitconfig)
-     */
-    private getGlobalConfigPath;
-    /**
-     * Get system Git config path
-     */
-    private getSystemConfigPath;
-    /**
-     * Parse INI-style Git config file
-     */
-    private parseGitConfig;
-    /**
-     * Write INI-style Git config file
-     */
-    private writeGitConfig;
-    getConfig(dir: string, key: string, scope?: 'local' | 'global' | 'system'): Promise<string | undefined>;
-    setConfig(dir: string, key: string, value: string, scope?: 'local' | 'global' | 'system'): Promise<void>;
-    listConfig(dir: string, scope?: 'local' | 'global' | 'system'): Promise<Record<string, string>>;
-    getAllConfig(dir: string, scope?: 'local' | 'global' | 'system'): Promise<Record<string, string>>;
-    unsetConfig(dir: string, key: string, scope?: 'local' | 'global' | 'system'): Promise<void>;
-    resetSoft(dir: string, ref: string): Promise<void>;
-    resetMixed(dir: string, ref: string): Promise<void>;
-    resetHard(dir: string, ref: string): Promise<void>;
-    createGitignore(dir: string, patterns: string[]): Promise<void>;
-    addToGitignore(dir: string, patterns: string[]): Promise<void>;
-    removeFromGitignore(dir: string, patterns: string[]): Promise<void>;
-    listGitignore(dir: string): Promise<string[]>;
-    readFile(dir: string, filepath: string, ref?: string): Promise<string>;
-    listFiles(dir: string, ref?: string): Promise<string[]>;
-}