@andrebuzeli/git-mcp 10.0.7 → 10.0.9

package/dist/tools/gitFiles-new.d.ts

@@ -1,89 +0,0 @@
-import { Tool } from '../types.js';
-export declare class GitFilesTool implements Tool {
-    name: string;
-    description: string;
-    inputSchema: {
-        type: "object";
-        properties: {
-            action: {
-                type: string;
-                enum: string[];
-                description: string;
-            };
-            projectPath: {
-                type: string;
-                description: string;
-            };
-            filePath: {
-                type: string;
-                description: string;
-            };
-            directoryPath: {
-                type: string;
-                description: string;
-            };
-            content: {
-                type: string;
-                description: string;
-            };
-            comment: {
-                type: string;
-                description: string;
-            };
-            patterns: {
-                type: string;
-                items: {
-                    type: string;
-                };
-                description: string;
-            };
-            searchText: {
-                type: string;
-                description: string;
-            };
-            query: {
-                type: string;
-                description: string;
-            };
-            searchPath: {
-                type: string;
-                description: string;
-            };
-        };
-        required: string[];
-        additionalProperties: boolean;
-    };
-    handle(params: Record<string, any>): Promise<any>;
-    /**
-     * Lê arquivo com cache
-     */
-    private handleRead;
-    /**
-     * Lista diretório com cache
-     */
-    private handleList;
-    /**
-     * Cria arquivo com validação de segurança
-     */
-    private handleCreate;
-    /**
-     * Atualiza arquivo com validação de segurança
-     */
-    private handleUpdate;
-    /**
-     * Deleta arquivo com validação de segurança
-     */
-    private handleDelete;
-    /**
-     * Busca texto em arquivos com cache
-     */
-    private handleSearch;
-    /**
-     * Busca recursivamente em diretórios
-     */
-    private searchInDirectory;
-    /**
-     * Verifica se arquivo é buscável
-     */
-    private isSearchableFile;
-}

package/dist/tools/gitFiles-new.js

@@ -1,335 +0,0 @@
-import fs from 'fs/promises';
-import path from 'path';
-import { MCPError } from '../utils/errors.js';
-import { cacheHelpers } from '../utils/cache.js';
-import { Logger } from '../utils/logger.js';
-export class GitFilesTool {
-    constructor() {
-        this.name = 'git-files';
-        this.description = 'Read-only file operations for repositories - local operations only with caching and rate limiting';
-        this.inputSchema = {
-            type: "object",
-            properties: {
-                action: {
-                    type: "string",
-                    enum: ["read", "list", "create", "update", "delete", "search"],
-                    description: "File operation to perform"
-                },
-                projectPath: {
-                    type: "string",
-                    description: "Absolute path to the project directory (REQUIRED)"
-                },
-                filePath: {
-                    type: "string",
-                    description: "Relative path to the file within projectPath - required for read, create, update, delete"
-                },
-                directoryPath: {
-                    type: "string",
-                    description: "Relative path to directory for listing - optional, defaults to projectPath root"
-                },
-                content: {
-                    type: "string",
-                    description: "File content to write - required for create and update actions"
-                },
-                comment: {
-                    type: "string",
-                    description: "Comment to add when appending patterns to .gitignore - optional for add action"
-                },
-                patterns: {
-                    type: "array",
-                    items: { type: "string" },
-                    description: "Array of file patterns - required for add and remove actions"
-                },
-                searchText: {
-                    type: "string",
-                    description: "Text to search for in files - required for search action"
-                },
-                query: {
-                    type: "string",
-                    description: "Alternative name for searchText - required for search action"
-                },
-                searchPath: {
-                    type: "string",
-                    description: "Relative path to search within - optional for search, defaults to projectPath root"
-                }
-            },
-            required: ["projectPath", "action"],
-            additionalProperties: true
-        };
-    }
-    async handle(params) {
-        const logger = Logger.getInstance();
-        const startTime = Date.now();
-        try {
-            const action = params.action;
-            const projectPath = params.projectPath;
-            if (!action || !projectPath) {
-                throw new MCPError('VALIDATION_ERROR', 'action and projectPath are required');
-            }
-            logger.debug(`Executing git-files:${action}`, { projectPath, filePath: params.filePath });
-            let result;
-            switch (action) {
-                case 'read':
-                    result = await this.handleRead(projectPath, params.filePath);
-                    break;
-                case 'list':
-                    result = await this.handleList(projectPath, params.directoryPath);
-                    break;
-                case 'create':
-                    result = await this.handleCreate(projectPath, params.filePath, params.content || '');
-                    // Invalidar cache após modificação
-                    cacheHelpers.invalidateRepoCache(projectPath);
-                    break;
-                case 'update':
-                    result = await this.handleUpdate(projectPath, params.filePath, params.content);
-                    // Invalidar cache após modificação
-                    cacheHelpers.invalidateRepoCache(projectPath);
-                    break;
-                case 'delete':
-                    result = await this.handleDelete(projectPath, params.filePath);
-                    // Invalidar cache após modificação
-                    cacheHelpers.invalidateRepoCache(projectPath);
-                    break;
-                case 'search':
-                    result = await this.handleSearch(projectPath, params.searchText || params.query, params.searchPath);
-                    break;
-                default:
-                    throw new MCPError('VALIDATION_ERROR', `Unknown action: ${action}`);
-            }
-            const duration = Date.now() - startTime;
-            logger.debug(`git-files:${action} completed in ${duration}ms`);
-            return result;
-        }
-        catch (error) {
-            const duration = Date.now() - startTime;
-            logger.error(`git-files operation failed`, {
-                action: params.action,
-                projectPath: params.projectPath,
-                duration,
-                error: error.message
-            });
-            throw error;
-        }
-    }
-    /**
-     * Lê arquivo com cache
-     */
-    async handleRead(projectPath, filePath) {
-        if (!filePath) {
-            throw new MCPError('VALIDATION_ERROR', 'filePath is required for read action');
-        }
-        const fullPath = path.resolve(projectPath, filePath);
-        // Verificar segurança: path traversal
-        if (!fullPath.startsWith(path.resolve(projectPath))) {
-            throw new MCPError('SECURITY_ERROR', 'File path must be within project directory');
-        }
-        // Leitura de arquivo sem cache por enquanto
-        try {
-            const content = await fs.readFile(fullPath, 'utf8');
-            return { success: true, path: fullPath, content, size: content.length };
-        }
-        catch (error) {
-            if (error.code === 'ENOENT') {
-                throw new MCPError('FILE_NOT_FOUND', `File not found: ${filePath}`);
-            }
-            throw new MCPError('FILE_ERROR', `Failed to read file: ${error.message}`);
-        }
-    }
-    /**
-     * Lista diretório com cache
-     */
-    async handleList(projectPath, directoryPath) {
-        const dirPath = directoryPath ? path.join(projectPath, directoryPath) : projectPath;
-        // Verificar segurança: path traversal
-        if (!dirPath.startsWith(path.resolve(projectPath))) {
-            throw new MCPError('SECURITY_ERROR', 'Directory path must be within project directory');
-        }
-        // Usar cache para listagem de diretórios
-        // Listar diretório sem cache por enquanto
-        try {
-            const files = await fs.readdir(dirPath, { withFileTypes: true });
-            return {
-                success: true,
-                files: files.map(entry => ({
-                    name: entry.name,
-                    isDirectory: entry.isDirectory(),
-                    isFile: entry.isFile(),
-                    path: path.join(directoryPath || '', entry.name)
-                }))
-            };
-        }
-        catch (error) {
-            if (error.code === 'ENOENT') {
-                throw new MCPError('DIRECTORY_NOT_FOUND', `Directory not found: ${directoryPath || 'root'}`);
-            }
-            throw new MCPError('DIRECTORY_ERROR', `Failed to list directory: ${error.message}`);
-        }
-    }
-    /**
-     * Cria arquivo com validação de segurança
-     */
-    async handleCreate(projectPath, filePath, content = '') {
-        if (!filePath) {
-            throw new MCPError('VALIDATION_ERROR', 'filePath is required for create action');
-        }
-        const targetPath = path.resolve(projectPath, filePath);
-        // Verificar segurança: path traversal
-        if (!targetPath.startsWith(path.resolve(projectPath))) {
-            throw new MCPError('SECURITY_ERROR', 'File path must be within project directory');
-        }
-        try {
-            // Criar diretório se necessário
-            const dir = path.dirname(targetPath);
-            await fs.mkdir(dir, { recursive: true });
-            await fs.writeFile(targetPath, content, 'utf-8');
-            return {
-                success: true,
-                created: true,
-                path: targetPath,
-                size: content.length,
-            };
-        }
-        catch (error) {
-            throw new MCPError('FILE_ERROR', `Failed to create file: ${error.message}`);
-        }
-    }
-    /**
-     * Atualiza arquivo com validação de segurança
-     */
-    async handleUpdate(projectPath, filePath, content) {
-        if (!filePath) {
-            throw new MCPError('VALIDATION_ERROR', 'filePath is required for update action');
-        }
-        if (content === undefined) {
-            throw new MCPError('VALIDATION_ERROR', 'content is required for update action');
-        }
-        const targetPath = path.resolve(projectPath, filePath);
-        // Verificar segurança: path traversal
-        if (!targetPath.startsWith(path.resolve(projectPath))) {
-            throw new MCPError('SECURITY_ERROR', 'File path must be within project directory');
-        }
-        try {
-            // Verificar se arquivo existe
-            await fs.access(targetPath);
-            await fs.writeFile(targetPath, content, 'utf-8');
-            return {
-                success: true,
-                updated: true,
-                path: targetPath,
-                size: content.length,
-            };
-        }
-        catch (error) {
-            if (error.code === 'ENOENT') {
-                throw new MCPError('FILE_NOT_FOUND', 'File does not exist. Use create action.');
-            }
-            throw new MCPError('FILE_ERROR', `Failed to update file: ${error.message}`);
-        }
-    }
-    /**
-     * Deleta arquivo com validação de segurança
-     */
-    async handleDelete(projectPath, filePath) {
-        if (!filePath) {
-            throw new MCPError('VALIDATION_ERROR', 'filePath is required for delete action');
-        }
-        const targetPath = path.resolve(projectPath, filePath);
-        // Verificar segurança: path traversal
-        if (!targetPath.startsWith(path.resolve(projectPath))) {
-            throw new MCPError('SECURITY_ERROR', 'File path must be within project directory');
-        }
-        try {
-            await fs.unlink(targetPath);
-            return {
-                success: true,
-                deleted: true,
-                path: targetPath,
-            };
-        }
-        catch (error) {
-            if (error.code === 'ENOENT') {
-                throw new MCPError('FILE_NOT_FOUND', `File not found: ${filePath}`);
-            }
-            throw new MCPError('FILE_ERROR', `Failed to delete file: ${error.message}`);
-        }
-    }
-    /**
-     * Busca texto em arquivos com cache
-     */
-    async handleSearch(projectPath, searchText, searchPath) {
-        if (!searchText) {
-            throw new MCPError('VALIDATION_ERROR', 'searchText or query is required for search action');
-        }
-        const searchDir = searchPath ? path.join(projectPath, searchPath) : projectPath;
-        // Verificar segurança: path traversal
-        if (!searchDir.startsWith(path.resolve(projectPath))) {
-            throw new MCPError('SECURITY_ERROR', 'Search path must be within project directory');
-        }
-        // Busca sem cache por enquanto
-        try {
-            const results = await this.searchInDirectory(searchDir, searchText);
-            return {
-                success: true,
-                searchText,
-                searchPath: searchPath || 'root',
-                results: results.slice(0, 50), // Limitar resultados para performance
-                totalResults: results.length,
-            };
-        }
-        catch (error) {
-            throw new MCPError('SEARCH_ERROR', `Failed to search files: ${error.message}`);
-        }
-    }
-    /**
-     * Busca recursivamente em diretórios
-     */
-    async searchInDirectory(dir, searchText) {
-        const results = [];
-        try {
-            const entries = await fs.readdir(dir, { withFileTypes: true });
-            for (const entry of entries) {
-                const fullPath = path.join(dir, entry.name);
-                if (entry.isDirectory() && !entry.name.startsWith('.') && entry.name !== 'node_modules') {
-                    // Recursivamente buscar em subdiretórios
-                    const subResults = await this.searchInDirectory(fullPath, searchText);
-                    results.push(...subResults);
-                }
-                else if (entry.isFile() && this.isSearchableFile(entry.name)) {
-                    // Buscar em arquivos
-                    try {
-                        const content = await fs.readFile(fullPath, 'utf8');
-                        const lines = content.split('\n');
-                        lines.forEach((line, index) => {
-                            if (line.toLowerCase().includes(searchText.toLowerCase())) {
-                                results.push({
-                                    file: fullPath,
-                                    line: index + 1,
-                                    text: line.trim(),
-                                });
-                            }
-                        });
-                    }
-                    catch (error) {
-                        // Ignorar erros de leitura (arquivos binários, etc.)
-                    }
-                }
-            }
-        }
-        catch (error) {
-            // Ignorar erros de acesso
-        }
-        return results;
-    }
-    /**
-     * Verifica se arquivo é buscável
-     */
-    isSearchableFile(filename) {
-        const searchableExtensions = [
-            '.js', '.ts', '.jsx', '.tsx', '.json', '.md', '.txt', '.yml', '.yaml',
-            '.html', '.css', '.scss', '.sass', '.less', '.xml', '.sh', '.bat',
-            '.py', '.java', '.cpp', '.c', '.h', '.php', '.rb', '.go', '.rs'
-        ];
-        const ext = path.extname(filename).toLowerCase();
-        return searchableExtensions.includes(ext);
-    }
-}