@andrebuzeli/git-mcp 5.0.4 → 5.0.6

package/dist/tools/git-files.js

@@ -1,237 +1,697 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.gitFilesTool = void 0;
-const auto_detection_js_1 = require("../utils/auto-detection.js");
-const configuration_validator_js_1 = require("../utils/configuration-validator.js");
-const index_js_1 = require("../providers/index.js");
 /**
- * Git Files Tool - Gerenciamento de Arquivos Remotos
+ * Git Files Tool
+ *
+ * File management tool providing CRUD operations for repository files.
+ * Supports both local Git operations and remote provider operations.
  *
- * Implementa operações de arquivo em repositórios remotos via API:
- * - read: Ler conteúdo de arquivo do repositório remoto
- * - create: Criar novo arquivo no repositório remoto
- * - update: Atualizar arquivo existente no repositório remoto
- * - delete: Remover arquivo do repositório remoto
- * - search: Buscar conteúdo em arquivos do repositório remoto
- * - list: Listar arquivos do repositório remoto
+ * Operations: read, create, update, delete, search, backup
  */
-const inputSchema = {
-    type: 'object',
-    properties: {
-        action: {
-            type: 'string',
-            enum: ['read', 'create', 'list'],
-            description: 'Ação de arquivo a executar'
-        },
-        projectPath: {
-            type: 'string',
-            description: 'Caminho do projeto (obrigatório)'
-        },
-        provider: {
-            type: 'string',
-            enum: ['github', 'gitea', 'both'],
-            description: 'Provider para operações remotas (obrigatório)'
-        },
-        owner: {
-            type: 'string',
-            description: 'Proprietário do repositório (auto-detectado se não fornecido)'
-        },
-        repo: {
-            type: 'string',
-            description: 'Nome do repositório (auto-detectado se não fornecido)'
-        },
-        filePath: {
-            type: 'string',
-            description: 'Caminho do arquivo no repositório'
-        },
-        content: {
-            type: 'string',
-            description: 'Conteúdo do arquivo (para create/update)'
-        },
-        message: {
-            type: 'string',
-            description: 'Mensagem de commit (para create/update/delete)'
-        },
-        branch: {
-            type: 'string',
-            description: 'Branch para operação (padrão: main)'
-        },
-        sha: {
-            type: 'string',
-            description: 'SHA do arquivo (obrigatório para update/delete)'
-        },
-        searchTerm: {
-            type: 'string',
-            description: 'Termo de busca (para search)'
-        },
-        path: {
-            type: 'string',
-            description: 'Caminho do diretório para listar (para list)'
-        }
-    },
-    required: ['action', 'projectPath', 'provider']
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
 };
-exports.gitFilesTool = {
-    name: 'git-files',
-    description: '📁 GERENCIAMENTO DE ARQUIVOS - Operações de arquivo em repositórios remotos',
-    inputSchema,
-    async handler(input) {
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GitFilesTool = void 0;
+const git_command_executor_js_1 = require("../utils/git-command-executor.js");
+const parameter_validator_js_1 = require("../utils/parameter-validator.js");
+const operation_error_handler_js_1 = require("../utils/operation-error-handler.js");
+const provider_operation_handler_js_1 = require("../providers/provider-operation-handler.js");
+const terminal_controller_js_1 = require("../utils/terminal-controller.js");
+const path_1 = __importDefault(require("path"));
+const promises_1 = __importDefault(require("fs/promises"));
+class GitFilesTool {
+    gitExecutor;
+    terminalController;
+    providerHandler;
+    constructor(providerConfig) {
+        this.gitExecutor = new git_command_executor_js_1.GitCommandExecutor();
+        this.terminalController = new terminal_controller_js_1.TerminalController();
+        if (providerConfig) {
+            this.providerHandler = new provider_operation_handler_js_1.ProviderOperationHandler(providerConfig);
+        }
+    }
+    /**
+     * Execute git-files operation
+     */
+    async execute(params) {
+        const startTime = Date.now();
         try {
-            const { action, projectPath, provider, owner, repo, filePath, content, message, branch, sha, searchTerm, path } = input;
-            const detection = (0, auto_detection_js_1.autoDetect)(projectPath);
-            // Validar provider obrigatório
-            if (!provider) {
-                throw new Error('Provider é obrigatório. Use: github, gitea, ou both');
-            }
-            // Validar provider
-            const providerValidation = configuration_validator_js_1.ConfigurationValidator.validateProvider(provider);
-            if (!providerValidation.valid) {
-                return (0, auto_detection_js_1.createUniversalResponse)(false, action, providerValidation.error.message, detection, 'git-files', undefined, {
-                    code: providerValidation.error.code,
-                    message: providerValidation.error.message,
-                    cause: 'Invalid provider parameter',
-                    suggestion: providerValidation.error.suggestion
-                });
+            // Validate basic parameters
+            const validation = parameter_validator_js_1.ParameterValidator.validateToolParams('git-files', params);
+            if (!validation.isValid) {
+                return operation_error_handler_js_1.OperationErrorHandler.createToolError('VALIDATION_ERROR', `Parameter validation failed: ${validation.errors.join(', ')}`, params.action, { validationErrors: validation.errors }, validation.suggestions);
             }
-            // Auto-detectar owner e repo se não fornecidos
-            const targetOwner = owner || detection.owner || '';
-            const targetRepo = repo || detection.repoName || '';
-            if (!targetOwner || !targetRepo) {
-                throw new Error('Owner e repo são obrigatórios. Forneça-os ou execute em um repositório Git válido.');
-            }
-            // Executar operações baseadas no provider
-            let result;
-            switch (action) {
-                case 'read':
-                    if (!filePath)
-                        throw new Error('filePath é obrigatório para read');
-                    if (provider === 'both') {
-                        const results = { github: null, gitea: null };
-                        // Tentar GitHub
-                        try {
-                            const githubProvider = index_js_1.globalProviderFactory.getProvider('github');
-                            if (githubProvider) {
-                                const fileData = await githubProvider.getFile(targetOwner, targetRepo, filePath, branch);
-                                results.github = {
-                                    success: true,
-                                    data: {
-                                        filePath,
-                                        content: fileData.content ? Buffer.from(fileData.content, 'base64').toString('utf8') : '',
-                                        sha: fileData.sha,
-                                        size: fileData.size,
-                                        encoding: fileData.encoding,
-                                        url: fileData.url,
-                                        html_url: fileData.html_url
-                                    }
-                                };
-                            }
-                        }
-                        catch (error) {
-                            results.github = {
-                                success: false,
-                                error: error instanceof Error ? error.message : String(error)
-                            };
-                        }
-                        // Tentar Gitea
-                        try {
-                            const giteaProvider = index_js_1.globalProviderFactory.getProvider('gitea');
-                            if (giteaProvider) {
-                                const fileData = await giteaProvider.getFile(targetOwner, targetRepo, filePath, branch);
-                                results.gitea = {
-                                    success: true,
-                                    data: {
-                                        filePath,
-                                        content: fileData.content ? Buffer.from(fileData.content, 'base64').toString('utf8') : '',
-                                        sha: fileData.sha,
-                                        size: fileData.size,
-                                        encoding: fileData.encoding,
-                                        url: fileData.url,
-                                        html_url: fileData.html_url
-                                    }
-                                };
-                            }
-                        }
-                        catch (error) {
-                            results.gitea = {
-                                success: false,
-                                error: error instanceof Error ? error.message : String(error)
-                            };
-                        }
-                        return (0, auto_detection_js_1.createUniversalResponse)(true, action, `Arquivo ${filePath} lido de ambos os providers`, detection, 'git-files', {
-                            provider: 'both',
-                            results
-                        });
-                    }
-                    else {
-                        // Provider único
-                        const providerInstance = index_js_1.globalProviderFactory.getProvider(provider);
-                        if (!providerInstance) {
-                            throw new Error(`Provider ${provider} não configurado`);
-                        }
-                        const fileData = await providerInstance.getFile(targetOwner, targetRepo, filePath, branch);
-                        return (0, auto_detection_js_1.createUniversalResponse)(true, action, `Arquivo ${filePath} lido com sucesso`, detection, 'git-files', {
-                            filePath,
-                            content: fileData.content ? Buffer.from(fileData.content, 'base64').toString('utf8') : '',
-                            sha: fileData.sha,
-                            size: fileData.size,
-                            encoding: fileData.encoding,
-                            url: fileData.url,
-                            html_url: fileData.html_url,
-                            provider
-                        });
-                    }
-                case 'create':
-                    if (!filePath)
-                        throw new Error('filePath é obrigatório para create');
-                    if (!content)
-                        throw new Error('content é obrigatório para create');
-                    if (!message)
-                        throw new Error('message é obrigatório para create');
-                    const providerInstance = index_js_1.globalProviderFactory.getProvider(provider === 'both' ? 'github' : provider);
-                    if (!providerInstance) {
-                        throw new Error(`Provider ${provider} não configurado`);
+            // Validate operation-specific parameters
+            const operationValidation = parameter_validator_js_1.ParameterValidator.validateOperationParams('git-files', params.action, params);
+            if (!operationValidation.isValid) {
+                return operation_error_handler_js_1.OperationErrorHandler.createToolError('VALIDATION_ERROR', `Operation validation failed: ${operationValidation.errors.join(', ')}`, params.action, { validationErrors: operationValidation.errors }, operationValidation.suggestions);
+            }
+            // Route to appropriate handler
+            // File operations are local by default, remote only when provider is explicitly specified
+            const isRemoteOperation = params.provider && this.isRemoteOperation(params.action);
+            if (isRemoteOperation) {
+                return await this.executeRemoteOperation(params, startTime);
+            }
+            else {
+                return await this.executeLocalOperation(params, startTime);
+            }
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            return operation_error_handler_js_1.OperationErrorHandler.createToolError('EXECUTION_ERROR', `Failed to execute ${params.action}: ${errorMessage}`, params.action, { error: errorMessage }, ['Check the error details and try again']);
+        }
+    }
+    /**
+     * Execute local file operations
+     */
+    async executeLocalOperation(params, startTime) {
+        switch (params.action) {
+            case 'list':
+                return await this.handleLocalList(params, startTime);
+            case 'read':
+                return await this.handleLocalRead(params, startTime);
+            case 'create':
+                return await this.handleLocalCreate(params, startTime);
+            case 'update':
+                return await this.handleLocalUpdate(params, startTime);
+            case 'delete':
+                return await this.handleLocalDelete(params, startTime);
+            case 'search':
+                return await this.handleLocalSearch(params, startTime);
+            case 'backup':
+                return await this.handleLocalBackup(params, startTime);
+            default:
+                return operation_error_handler_js_1.OperationErrorHandler.createToolError('UNSUPPORTED_OPERATION', `Local operation '${params.action}' is not supported`, params.action, {}, ['Use one of: read, create, update, delete, search, backup']);
+        }
+    }
+    /**
+     * Execute remote provider operations
+     */
+    async executeRemoteOperation(params, startTime) {
+        if (!this.providerHandler) {
+            return operation_error_handler_js_1.OperationErrorHandler.createToolError('PROVIDER_NOT_CONFIGURED', 'Provider handler is not configured for remote operations', params.action, {}, ['Configure GitHub or Gitea provider to use remote operations']);
+        }
+        if (!params.provider) {
+            return operation_error_handler_js_1.OperationErrorHandler.createToolError('PROVIDER_REQUIRED', 'Provider parameter is required for remote operations', params.action, {}, ['Specify provider as: github, gitea, or both']);
+        }
+        const operation = {
+            provider: params.provider,
+            operation: this.mapActionToProviderOperation(params.action),
+            parameters: this.extractRemoteParameters(params),
+            requiresAuth: true,
+            isRemoteOperation: true
+        };
+        try {
+            const result = await this.providerHandler.executeOperation(operation);
+            return {
+                success: result.success,
+                data: result.partialFailure ? result : result.results[0]?.data,
+                error: result.success ? undefined : {
+                    code: result.errors[0]?.error?.code || 'REMOTE_OPERATION_ERROR',
+                    message: result.errors[0]?.error?.message || 'Remote operation failed',
+                    details: result.errors,
+                    suggestions: ['Check provider configuration and credentials']
+                },
+                metadata: {
+                    provider: params.provider,
+                    operation: params.action,
+                    timestamp: new Date().toISOString(),
+                    executionTime: Date.now() - startTime
+                }
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            return operation_error_handler_js_1.OperationErrorHandler.createToolError('REMOTE_OPERATION_ERROR', `Remote operation failed: ${errorMessage}`, params.action, { error: errorMessage }, ['Check provider configuration and network connectivity']);
+        }
+    }
+    /**
+     * Handle local file read operation
+     */
+    async handleLocalRead(params, startTime) {
+        try {
+            if (!params.filePath) {
+                return operation_error_handler_js_1.OperationErrorHandler.createToolError('MISSING_PARAMETER', 'File path is required for read operation', 'read', {}, ['Provide a filePath parameter with the relative path to the file']);
+            }
+            const fullPath = path_1.default.join(params.projectPath, params.filePath);
+            // Check if file exists
+            try {
+                await promises_1.default.access(fullPath);
+            }
+            catch {
+                return operation_error_handler_js_1.OperationErrorHandler.createToolError('FILE_NOT_FOUND', `File not found: ${params.filePath}`, 'read', { filePath: params.filePath, fullPath }, ['Check that the file path is correct and the file exists']);
+            }
+            // Read file content
+            const encoding = params.encoding || 'utf8';
+            let content;
+            if (encoding === 'binary') {
+                content = await promises_1.default.readFile(fullPath);
+            }
+            else {
+                content = await promises_1.default.readFile(fullPath, encoding);
+            }
+            // Get file stats
+            const stats = await promises_1.default.stat(fullPath);
+            return {
+                success: true,
+                data: {
+                    filePath: params.filePath,
+                    content: encoding === 'binary' ? content.toString('base64') : content,
+                    encoding,
+                    size: stats.size,
+                    modified: stats.mtime.toISOString(),
+                    created: stats.birthtime.toISOString(),
+                    isDirectory: stats.isDirectory(),
+                    permissions: stats.mode.toString(8)
+                },
+                metadata: {
+                    operation: 'read',
+                    timestamp: new Date().toISOString(),
+                    executionTime: Date.now() - startTime
+                }
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            return operation_error_handler_js_1.OperationErrorHandler.createToolError('READ_ERROR', `Failed to read file: ${errorMessage}`, 'read', { error: errorMessage, filePath: params.filePath });
+        }
+    }
+    /**
+     * Handle local file create operation
+     */
+    async handleLocalCreate(params, startTime) {
+        try {
+            if (!params.filePath) {
+                return operation_error_handler_js_1.OperationErrorHandler.createToolError('MISSING_PARAMETER', 'File path is required for create operation', 'create', {}, ['Provide a filePath parameter with the relative path for the new file']);
+            }
+            if (params.content === undefined) {
+                return operation_error_handler_js_1.OperationErrorHandler.createToolError('MISSING_PARAMETER', 'Content is required for create operation', 'create', {}, ['Provide content parameter with the file content']);
+            }
+            const fullPath = path_1.default.join(params.projectPath, params.filePath);
+            // Check if file already exists
+            try {
+                await promises_1.default.access(fullPath);
+                return operation_error_handler_js_1.OperationErrorHandler.createToolError('FILE_EXISTS', `File already exists: ${params.filePath}`, 'create', { filePath: params.filePath }, ['Use update operation to modify existing files, or choose a different file path']);
+            }
+            catch {
+                // File doesn't exist, which is what we want for create
+            }
+            // Ensure directory exists
+            const dirPath = path_1.default.dirname(fullPath);
+            await promises_1.default.mkdir(dirPath, { recursive: true });
+            // Write file content
+            const encoding = params.encoding || 'utf8';
+            let contentToWrite = params.content;
+            if (encoding === 'base64') {
+                contentToWrite = Buffer.from(params.content, 'base64');
+            }
+            else if (encoding === 'binary') {
+                contentToWrite = Buffer.from(params.content, 'binary');
+            }
+            await promises_1.default.writeFile(fullPath, contentToWrite, encoding === 'utf8' ? 'utf8' : undefined);
+            // Get file stats
+            const stats = await promises_1.default.stat(fullPath);
+            return {
+                success: true,
+                data: {
+                    message: 'File created successfully',
+                    filePath: params.filePath,
+                    size: stats.size,
+                    created: stats.birthtime.toISOString(),
+                    encoding
+                },
+                metadata: {
+                    operation: 'create',
+                    timestamp: new Date().toISOString(),
+                    executionTime: Date.now() - startTime
+                }
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            return operation_error_handler_js_1.OperationErrorHandler.createToolError('CREATE_ERROR', `Failed to create file: ${errorMessage}`, 'create', { error: errorMessage, filePath: params.filePath });
+        }
+    }
+    /**
+     * Handle local file update operation
+     */
+    async handleLocalUpdate(params, startTime) {
+        try {
+            if (!params.filePath) {
+                return operation_error_handler_js_1.OperationErrorHandler.createToolError('MISSING_PARAMETER', 'File path is required for update operation', 'update', {}, ['Provide a filePath parameter with the relative path to the file']);
+            }
+            if (params.content === undefined) {
+                return operation_error_handler_js_1.OperationErrorHandler.createToolError('MISSING_PARAMETER', 'Content is required for update operation', 'update', {}, ['Provide content parameter with the new file content']);
+            }
+            const fullPath = path_1.default.join(params.projectPath, params.filePath);
+            // Check if file exists
+            try {
+                await promises_1.default.access(fullPath);
+            }
+            catch {
+                return operation_error_handler_js_1.OperationErrorHandler.createToolError('FILE_NOT_FOUND', `File not found: ${params.filePath}`, 'update', { filePath: params.filePath }, ['Use create operation for new files, or check that the file path is correct']);
+            }
+            // Get original file stats for comparison
+            const originalStats = await promises_1.default.stat(fullPath);
+            // Write updated content
+            const encoding = params.encoding || 'utf8';
+            let contentToWrite = params.content;
+            if (encoding === 'base64') {
+                contentToWrite = Buffer.from(params.content, 'base64');
+            }
+            else if (encoding === 'binary') {
+                contentToWrite = Buffer.from(params.content, 'binary');
+            }
+            await promises_1.default.writeFile(fullPath, contentToWrite, encoding === 'utf8' ? 'utf8' : undefined);
+            // Get updated file stats
+            const updatedStats = await promises_1.default.stat(fullPath);
+            return {
+                success: true,
+                data: {
+                    message: 'File updated successfully',
+                    filePath: params.filePath,
+                    originalSize: originalStats.size,
+                    newSize: updatedStats.size,
+                    modified: updatedStats.mtime.toISOString(),
+                    encoding
+                },
+                metadata: {
+                    operation: 'update',
+                    timestamp: new Date().toISOString(),
+                    executionTime: Date.now() - startTime
+                }
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            return operation_error_handler_js_1.OperationErrorHandler.createToolError('UPDATE_ERROR', `Failed to update file: ${errorMessage}`, 'update', { error: errorMessage, filePath: params.filePath });
+        }
+    }
+    /**
+     * Handle local file delete operation
+     */
+    async handleLocalDelete(params, startTime) {
+        try {
+            if (!params.filePath) {
+                return operation_error_handler_js_1.OperationErrorHandler.createToolError('MISSING_PARAMETER', 'File path is required for delete operation', 'delete', {}, ['Provide a filePath parameter with the relative path to the file']);
+            }
+            const fullPath = path_1.default.join(params.projectPath, params.filePath);
+            // Check if file exists and get stats
+            let stats;
+            try {
+                stats = await promises_1.default.stat(fullPath);
+            }
+            catch {
+                return operation_error_handler_js_1.OperationErrorHandler.createToolError('FILE_NOT_FOUND', `File not found: ${params.filePath}`, 'delete', { filePath: params.filePath }, ['Check that the file path is correct and the file exists']);
+            }
+            // Delete the file
+            await promises_1.default.unlink(fullPath);
+            return {
+                success: true,
+                data: {
+                    message: 'File deleted successfully',
+                    filePath: params.filePath,
+                    deletedSize: stats.size,
+                    wasDirectory: stats.isDirectory()
+                },
+                metadata: {
+                    operation: 'delete',
+                    timestamp: new Date().toISOString(),
+                    executionTime: Date.now() - startTime
+                }
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            return operation_error_handler_js_1.OperationErrorHandler.createToolError('DELETE_ERROR', `Failed to delete file: ${errorMessage}`, 'delete', { error: errorMessage, filePath: params.filePath });
+        }
+    }
+    /**
+     * Handle local file search operation
+     */
+    async handleLocalSearch(params, startTime) {
+        try {
+            if (!params.query) {
+                return operation_error_handler_js_1.OperationErrorHandler.createToolError('MISSING_PARAMETER', 'Query is required for search operation', 'search', {}, ['Provide a query parameter with the text to search for']);
+            }
+            const searchOptions = {
+                caseSensitive: params.caseSensitive || false,
+                filePattern: params.filePattern || '*',
+                maxResults: 100
+            };
+            // Use terminal controller to search for content
+            const searchResult = await this.terminalController.searchInFiles(params.projectPath, params.query, searchOptions);
+            if (!searchResult.success) {
+                return operation_error_handler_js_1.OperationErrorHandler.createToolError('SEARCH_ERROR', `Search failed: ${searchResult.stderr}`, 'search', { error: searchResult.stderr }, ['Check the search query and try again']);
+            }
+            // Parse search results
+            const matches = this.parseSearchResults(searchResult.stdout);
+            return {
+                success: true,
+                data: {
+                    query: params.query,
+                    matches,
+                    totalMatches: matches.length,
+                    searchOptions
+                },
+                metadata: {
+                    operation: 'search',
+                    timestamp: new Date().toISOString(),
+                    executionTime: Date.now() - startTime
+                }
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            return operation_error_handler_js_1.OperationErrorHandler.createToolError('SEARCH_ERROR', `Failed to search files: ${errorMessage}`, 'search', { error: errorMessage, query: params.query });
+        }
+    }
+    /**
+     * Handle local directory listing
+     */
+    async handleLocalList(params, startTime) {
+        try {
+            const listPath = params.filePath ? path_1.default.join(params.projectPath, params.filePath) : params.projectPath;
+            // Verify path exists
+            try {
+                await promises_1.default.access(listPath);
+            }
+            catch {
+                return operation_error_handler_js_1.OperationErrorHandler.createToolError('PATH_NOT_FOUND', `Path not found: ${listPath}`, 'list', { path: listPath }, ['Provide a valid projectPath/filePath']);
+            }
+            const entries = await promises_1.default.readdir(listPath, { withFileTypes: true });
+            const items = await Promise.all(entries.map(async (entry) => {
+                const entryPath = path_1.default.join(listPath, entry.name);
+                const stats = await promises_1.default.stat(entryPath);
+                return {
+                    name: entry.name,
+                    path: path_1.default.relative(params.projectPath, entryPath).replace(/\\/g, '/'),
+                    isDirectory: entry.isDirectory(),
+                    size: stats.size,
+                    modified: stats.mtime.toISOString()
+                };
+            }));
+            return {
+                success: true,
+                data: {
+                    items,
+                    total: items.length
+                },
+                metadata: {
+                    operation: 'list',
+                    timestamp: new Date().toISOString(),
+                    executionTime: Date.now() - startTime
+                }
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            return operation_error_handler_js_1.OperationErrorHandler.createToolError('LIST_ERROR', `Failed to list path: ${errorMessage}`, 'list', { error: errorMessage });
+        }
+    }
+    /**
+     * Handle local file backup operation
+     */
+    async handleLocalBackup(params, startTime) {
+        try {
+            if (!params.backupPath) {
+                // Generate default backup path
+                const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+                params.backupPath = path_1.default.join(params.projectPath, '..', `files-backup-${timestamp}`);
+            }
+            // Create backup using git archive if in a git repository
+            const isGitRepo = await this.gitExecutor.isGitRepository(params.projectPath);
+            if (isGitRepo) {
+                const result = await this.gitExecutor.createBackup(params.projectPath, params.backupPath, 'tar');
+                if (!result.success) {
+                    return operation_error_handler_js_1.OperationErrorHandler.handleGitError(result.stderr, 'backup', params.projectPath);
+                }
+                return {
+                    success: true,
+                    data: {
+                        message: 'Files backup created successfully using Git archive',
+                        backupPath: `${params.backupPath}.tar.gz`,
+                        method: 'git-archive',
+                        output: result.stdout
+                    },
+                    metadata: {
+                        operation: 'backup',
+                        timestamp: new Date().toISOString(),
+                        executionTime: Date.now() - startTime
                     }
-                    const fileData = await providerInstance.createFile(targetOwner, targetRepo, filePath, content, message, branch);
-                    return (0, auto_detection_js_1.createUniversalResponse)(true, action, `Arquivo ${filePath} criado com sucesso`, detection, 'git-files', {
-                        filePath,
-                        sha: fileData.sha,
-                        size: content.length,
-                        message,
-                        branch: branch || 'main',
-                        provider
-                    });
-                case 'list':
-                    const listPath = path || '';
-                    const listProvider = index_js_1.globalProviderFactory.getProvider(provider === 'both' ? 'github' : provider);
-                    if (!listProvider) {
-                        throw new Error(`Provider ${provider} não configurado`);
+                };
+            }
+            else {
+                // Fallback to manual file copy
+                const backupResult = await this.createManualBackup(params.projectPath, params.backupPath, {
+                    includePattern: params.includePattern,
+                    excludePattern: params.excludePattern
+                });
+                return {
+                    success: true,
+                    data: {
+                        message: 'Files backup created successfully using file copy',
+                        backupPath: params.backupPath,
+                        method: 'file-copy',
+                        filesBackedUp: backupResult.fileCount,
+                        totalSize: backupResult.totalSize
+                    },
+                    metadata: {
+                        operation: 'backup',
+                        timestamp: new Date().toISOString(),
+                        executionTime: Date.now() - startTime
                     }
-                    const files = await listProvider.listFiles(targetOwner, targetRepo, listPath, branch);
-                    return (0, auto_detection_js_1.createUniversalResponse)(true, action, `${files.length} arquivos encontrados em ${listPath || 'raiz'}`, detection, 'git-files', {
-                        path: listPath,
-                        files: files.map((file) => ({
-                            name: file.name,
-                            path: file.path,
-                            type: file.type,
-                            size: file.size,
-                            sha: file.sha
-                        })),
-                        totalFiles: files.length,
-                        provider
-                    });
-                default:
-                    throw new Error(`Ação '${action}' não suportada. Ações disponíveis: read, create, list`);
+                };
             }
         }
         catch (error) {
-            const detection = (0, auto_detection_js_1.autoDetect)(input.projectPath || '');
-            const errorInstance = error instanceof Error ? error : new Error(String(error));
-            return (0, auto_detection_js_1.createUniversalResponse)(false, input.action || 'unknown', `Erro na operação de arquivo: ${errorInstance.message}`, detection, 'git-files', undefined, {
-                code: 'FILE_OPERATION_ERROR',
-                message: errorInstance.message,
-                cause: 'File operation failed'
-            });
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            return operation_error_handler_js_1.OperationErrorHandler.createToolError('BACKUP_ERROR', `Failed to create backup: ${errorMessage}`, 'backup', { error: errorMessage, backupPath: params.backupPath });
         }
     }
-};
+    /**
+     * Create manual backup by copying files
+     */
+    async createManualBackup(sourcePath, backupPath, options) {
+        await promises_1.default.mkdir(backupPath, { recursive: true });
+        let fileCount = 0;
+        let totalSize = 0;
+        const copyRecursive = async (src, dest) => {
+            const stats = await promises_1.default.stat(src);
+            if (stats.isDirectory()) {
+                await promises_1.default.mkdir(dest, { recursive: true });
+                const entries = await promises_1.default.readdir(src);
+                for (const entry of entries) {
+                    const srcPath = path_1.default.join(src, entry);
+                    const destPath = path_1.default.join(dest, entry);
+                    await copyRecursive(srcPath, destPath);
+                }
+            }
+            else {
+                // Apply include/exclude patterns
+                const relativePath = path_1.default.relative(sourcePath, src);
+                if (options.excludePattern && this.matchesPattern(relativePath, options.excludePattern)) {
+                    return;
+                }
+                if (options.includePattern && !this.matchesPattern(relativePath, options.includePattern)) {
+                    return;
+                }
+                await promises_1.default.copyFile(src, dest);
+                fileCount++;
+                totalSize += stats.size;
+            }
+        };
+        await copyRecursive(sourcePath, backupPath);
+        return { fileCount, totalSize };
+    }
+    /**
+     * Check if operation is a remote operation
+     */
+    isRemoteOperation(action) {
+        // All file operations can be remote operations when provider is specified
+        return ['read', 'create', 'update', 'delete', 'search'].includes(action);
+    }
+    /**
+     * Extract parameters for remote operations
+     */
+    extractRemoteParameters(params) {
+        const remoteParams = {
+            projectPath: params.projectPath
+        };
+        // Common parameters
+        if (params.owner)
+            remoteParams.owner = params.owner;
+        if (params.repo)
+            remoteParams.repo = params.repo;
+        if (params.filePath)
+            remoteParams.path = params.filePath;
+        // Operation-specific parameters
+        switch (params.action) {
+            case 'read':
+                if (params.branch)
+                    remoteParams.ref = params.branch;
+                break;
+            case 'create':
+            case 'update':
+                if (params.content) {
+                    // Encode content as base64 for API
+                    remoteParams.content = Buffer.from(params.content).toString('base64');
+                }
+                if (params.message)
+                    remoteParams.message = params.message;
+                if (params.branch)
+                    remoteParams.branch = params.branch;
+                if (params.sha)
+                    remoteParams.sha = params.sha;
+                break;
+            case 'delete':
+                if (params.message)
+                    remoteParams.message = params.message;
+                if (params.sha)
+                    remoteParams.sha = params.sha;
+                if (params.branch)
+                    remoteParams.branch = params.branch;
+                break;
+            case 'search':
+                if (params.query)
+                    remoteParams.query = params.query;
+                break;
+        }
+        return remoteParams;
+    }
+    /**
+     * Map git-files actions to provider operations
+     */
+    mapActionToProviderOperation(action) {
+        const actionMap = {
+            'read': 'file-read',
+            'list': 'listFiles',
+            'create': 'file-create',
+            'update': 'file-update',
+            'delete': 'file-delete',
+            'search': 'file-search'
+        };
+        return actionMap[action] || action;
+    }
+    /**
+     * Parse search results from grep-like output
+     */
+    parseSearchResults(output) {
+        const matches = [];
+        const lines = output.split('\n').filter(line => line.trim());
+        for (const line of lines) {
+            // Parse grep output format: file:line:content
+            const match = line.match(/^([^:]+):(\d+):(.*)$/);
+            if (match) {
+                const [, file, lineNum, content] = match;
+                matches.push({
+                    file,
+                    line: parseInt(lineNum),
+                    content: content.trim(),
+                    match: content.trim()
+                });
+            }
+        }
+        return matches;
+    }
+    /**
+     * Check if path matches pattern (simple glob matching)
+     */
+    matchesPattern(filePath, pattern) {
+        // Convert glob pattern to regex
+        const regexPattern = pattern
+            .replace(/\./g, '\\.')
+            .replace(/\*/g, '.*')
+            .replace(/\?/g, '.');
+        const regex = new RegExp(`^${regexPattern}$`);
+        return regex.test(filePath);
+    }
+    /**
+     * Get tool schema for MCP registration
+     */
+    static getToolSchema() {
+        return {
+            name: 'git-files',
+            description: 'File management tool for repository files. Supports CRUD operations, search, and backup for both local and remote repositories.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    action: {
+                        type: 'string',
+                        enum: ['read', 'create', 'update', 'delete', 'search', 'backup', 'list'],
+                        description: 'The file operation to perform'
+                    },
+                    projectPath: {
+                        type: 'string',
+                        description: 'Absolute path to the project directory'
+                    },
+                    provider: {
+                        type: 'string',
+                        enum: ['github', 'gitea', 'both'],
+                        description: 'Provider for remote operations (optional for local operations)'
+                    },
+                    filePath: {
+                        type: 'string',
+                        description: 'Relative path to the file within the repository (required for read, create, update, delete)'
+                    },
+                    content: {
+                        type: 'string',
+                        description: 'File content (required for create and update operations)'
+                    },
+                    encoding: {
+                        type: 'string',
+                        enum: ['utf8', 'base64', 'binary'],
+                        description: 'Content encoding (default: utf8)'
+                    },
+                    message: {
+                        type: 'string',
+                        description: 'Commit message for remote operations'
+                    },
+                    branch: {
+                        type: 'string',
+                        description: 'Target branch for remote operations'
+                    },
+                    sha: {
+                        type: 'string',
+                        description: 'File SHA for remote update/delete operations'
+                    },
+                    query: {
+                        type: 'string',
+                        description: 'Search query (required for search operation)'
+                    },
+                    filePattern: {
+                        type: 'string',
+                        description: 'File pattern for search (e.g., "*.js")'
+                    },
+                    caseSensitive: {
+                        type: 'boolean',
+                        description: 'Case sensitive search (default: false)'
+                    },
+                    backupPath: {
+                        type: 'string',
+                        description: 'Path for backup (for backup operation)'
+                    },
+                    includePattern: {
+                        type: 'string',
+                        description: 'Pattern for files to include in backup'
+                    },
+                    excludePattern: {
+                        type: 'string',
+                        description: 'Pattern for files to exclude from backup'
+                    },
+                    owner: {
+                        type: 'string',
+                        description: 'Repository owner (for remote operations)'
+                    },
+                    repo: {
+                        type: 'string',
+                        description: 'Repository name (for remote operations)'
+                    }
+                },
+                required: ['action', 'projectPath']
+            }
+        };
+    }
+}
+exports.GitFilesTool = GitFilesTool;
 //# sourceMappingURL=git-files.js.map