@andrebuzeli/git-mcp 10.0.3 → 10.0.5

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

@@ -0,0 +1,89 @@
+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

@@ -0,0 +1,335 @@
+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);
+    }
+}

package/dist/tools/gitFiles.d.ts

@@ -62,8 +62,9 @@ export declare class GitFilesTool implements Tool {
         size?: undefined;
         updated?: undefined;
         deleted?: undefined;
-        matches?: undefined;
-        count?: undefined;
+        searchText?: undefined;
+        results?: undefined;
+        totalResults?: undefined;
     } | {
         success: boolean;
         files: string[];
@@ -73,8 +74,9 @@ export declare class GitFilesTool implements Tool {
         size?: undefined;
         updated?: undefined;
         deleted?: undefined;
-        matches?: undefined;
-        count?: undefined;
+        searchText?: undefined;
+        results?: undefined;
+        totalResults?: undefined;
     } | {
         success: boolean;
         created: boolean;
@@ -84,8 +86,9 @@ export declare class GitFilesTool implements Tool {
         files?: undefined;
         updated?: undefined;
         deleted?: undefined;
-        matches?: undefined;
-        count?: undefined;
+        searchText?: undefined;
+        results?: undefined;
+        totalResults?: undefined;
     } | {
         success: boolean;
         updated: boolean;
@@ -95,8 +98,9 @@ export declare class GitFilesTool implements Tool {
         files?: undefined;
         created?: undefined;
         deleted?: undefined;
-        matches?: undefined;
-        count?: undefined;
+        searchText?: undefined;
+        results?: undefined;
+        totalResults?: undefined;
     } | {
         success: boolean;
         deleted: boolean;
@@ -106,15 +110,14 @@ export declare class GitFilesTool implements Tool {
         created?: undefined;
         size?: undefined;
         updated?: undefined;
-        matches?: undefined;
-        count?: undefined;
+        searchText?: undefined;
+        results?: undefined;
+        totalResults?: undefined;
     } | {
         success: boolean;
-        matches: {
-            file: string;
-            snippet: string;
-        }[];
-        count: number;
+        searchText: any;
+        results: any[];
+        totalResults: number;
         path?: undefined;
         content?: undefined;
         files?: undefined;

package/dist/tools/gitFiles.js

@@ -146,29 +146,68 @@ export class GitFilesTool {
             }
             catch (error) {
                 if (error.code === 'ENOENT') {
-                    throw new MCPError('FILE_NOT_FOUND', 'File does not exist');
+                    throw new MCPError('FILE_NOT_FOUND', `File not found: ${filePath}`);
                 }
                 throw new MCPError('FILE_ERROR', `Failed to delete file: ${error.message}`);
             }
         }
         if (action === 'search') {
-            // Simple string search within files in projectPath (non-recursive)
-            const searchPath = params.searchPath ? path.join(projectPath, params.searchPath) : projectPath;
-            const files = await fs.readdir(searchPath);
-            const q = params.searchText ?? params.query ?? '';
-            const matches = [];
-            for (const f of files) {
+            const searchText = params.searchText || params.query;
+            if (!searchText)
+                throw new MCPError('VALIDATION_ERROR', 'searchText or query is required');
+            const searchPath = params.searchPath || projectPath;
+            const searchDir = path.join(projectPath, searchPath);
+            // Security: ensure search path is within projectPath
+            if (!searchDir.startsWith(path.resolve(projectPath))) {
+                throw new MCPError('SECURITY_ERROR', 'Search path must be within project directory');
+            }
+            const results = [];
+            const searchInDirectory = async (dir) => {
                 try {
-                    const txt = await fs.readFile(path.join(searchPath, f), 'utf8');
-                    if (txt.includes(q))
-                        matches.push({ file: f, snippet: txt.substring(txt.indexOf(q), txt.indexOf(q) + 200) });
+                    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('.')) {
+                            await searchInDirectory(fullPath);
+                        }
+                        else if (entry.isFile()) {
+                            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) {
+                                // Ignore files that can't be read (binary, etc.)
+                            }
+                        }
+                    }
                 }
-                catch (e) {
-                    // ignore binary/unreadable
+                catch (error) {
+                    // Ignore directories that can't be accessed
                 }
-            }
-            return { success: true, matches, count: matches.length };
+            };
+            await searchInDirectory(searchDir);
+            return {
+                success: true,
+                searchText,
+                results: results.slice(0, 50), // Limit results for performance
+                totalResults: results.length,
+            };
+            return {
+                success: true,
+                searchText,
+                results: results.slice(0, 50), // Limit results for performance
+                totalResults: results.length,
+            };
         }
-        throw new MCPError('VALIDATION_ERROR', `Unsupported action: ${action}`);
+        throw new MCPError('VALIDATION_ERROR', `Unknown action: ${action}`);
     }
 }

package/dist/tools/gitFix.js

@@ -2,6 +2,7 @@ import simpleGit from 'simple-git';
 import path from 'path';
 import fs from 'fs/promises';
 import { existsSync } from 'fs';
+import { buildGitHubUrl, buildGiteaUrl } from '../utils/repoHelpers.js';
 export async function handleGitFix(args) {
     try {
         const { projectPath, githubRepo, giteaRepo, autoDetect = true } = args;
@@ -106,16 +107,15 @@ export async function handleGitFix(args) {
             }
         }
         // Adicionar novos remotes no padrão dual
-        const giteaUrl = process.env.GITEA_URL || 'http://nas-ubuntu:9999';
-        const githubUrl = `https://github.com/${finalGithubRepo}.git`;
-        const giteaRepoUrl = `${giteaUrl}/${finalGiteaRepo}.git`;
+        const githubUrl = buildGitHubUrl(finalGithubRepo.split('/')[0], finalGithubRepo.split('/')[1]);
+        const giteaUrlFull = buildGiteaUrl(finalGiteaRepo.split('/')[0], finalGiteaRepo.split('/')[1]);
         await git.addRemote('github', githubUrl);
-        result.fixed.push(`✅ Adicionado remote GitHub: ${githubUrl}`);
-        await git.addRemote('gitea', giteaRepoUrl);
-        result.fixed.push(`✅ Adicionado remote Gitea: ${giteaRepoUrl}`);
+        result.fixed.push(`✅ Adicionado remote GitHub: ${githubUrl.replace(/oauth2:[^@]+@/, 'oauth2:***@')}`);
+        await git.addRemote('gitea', giteaUrlFull);
+        result.fixed.push(`✅ Adicionado remote Gitea: ${giteaUrlFull.replace(/:[^:]+@/, ':***@')}`);
         // Configurar origin como push múltiplo
         await git.addRemote('origin', githubUrl);
-        await git.addConfig('remote.origin.pushurl', giteaRepoUrl, false, 'local');
+        await git.addConfig('remote.origin.pushurl', giteaUrlFull, false, 'local');
         result.fixed.push(`✅ Configurado origin para push dual (GitHub + Gitea)`);
         // Capturar remotes depois
         const remotesAfter = await git.getRemotes(true);

package/dist/tools/gitFix.tool.js

@@ -67,19 +67,19 @@ export class GitFixTool {
             properties: {
                 projectPath: {
                     type: "string",
-                    description: "Absolute path to the Git repository (REQUIRED)"
+                    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."
                 },
                 githubRepo: {
                     type: "string",
-                    description: "GitHub repo in format 'owner/repo' (optional, auto-detected)"
+                    description: "GitHub repo in format \"owner/repo\" (auto-detected if not provided)"
                 },
                 giteaRepo: {
                     type: "string",
-                    description: "Gitea repo in format 'owner/repo' (optional, auto-detected)"
+                    description: "Gitea repo in format \"owner/repo\" (auto-detected if not provided)"
                 },
                 autoDetect: {
                     type: "boolean",
-                    description: "Auto-detect repos from existing remotes (optional, default: true)"
+                    description: "Auto-detect repos from existing remotes (default: true)"
                 }
             },
             required: ["projectPath"],

package/dist/tools/gitHistory.d.ts

@@ -10,36 +10,13 @@ export declare class GitHistoryTool implements Tool {
     inputSchema: {
         type: "object";
         properties: {
-            action: {
-                type: string;
-                enum: string[];
-                description: string;
-            };
             projectPath: {
                 type: string;
                 description: string;
             };
-            description: {
-                type: string;
-                description: string;
-            };
-            message: {
-                type: string;
-                description: string;
-            };
-            title: {
-                type: string;
-                description: string;
-            };
-            tags: {
-                type: string;
-                items: {
-                    type: string;
-                };
-                description: string;
-            };
-            category: {
+            action: {
                 type: string;
+                enum: string[];
                 description: string;
             };
             owner: {