@andrebuzeli/git-mcp 4.0.21 → 5.0.0

package/dist/tools/git-workflow.js

@@ -2,6 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.gitWorkflowTool = void 0;
 const auto_detection_js_1 = require("../utils/auto-detection.js");
+const configuration_validator_js_1 = require("../utils/configuration-validator.js");
+const provider_operation_handler_js_1 = require("../utils/provider-operation-handler.js");
+const operation_error_handler_js_1 = require("../utils/operation-error-handler.js");
 const terminal_controller_js_1 = require("../utils/terminal-controller.js");
 /**
  * Git Workflow Tool - Ferramenta Principal
@@ -18,13 +21,18 @@ const inputSchema = {
     properties: {
         action: {
             type: 'string',
-            enum: ['init', 'commit', 'sync', 'status', 'backup'],
+            enum: ['init', 'commit', 'sync', 'status', 'backup', 'create', 'list', 'get', 'update', 'delete', 'fork', 'search'],
             description: 'Ação do workflow 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 para create, list, get, update, delete, fork, search)'
+        },
         message: {
             type: 'string',
             description: 'Mensagem de commit (para commit/sync)'
@@ -36,9 +44,61 @@ const inputSchema = {
         remote: {
             type: 'string',
             description: 'Remote para operações (padrão: origin)'
+        },
+        // Parâmetros para gerenciamento de repositórios
+        repoName: {
+            type: 'string',
+            description: 'Nome do repositório (para create/get/update/delete/fork)'
+        },
+        description: {
+            type: 'string',
+            description: 'Descrição do repositório (para create/update)'
+        },
+        private: {
+            type: 'boolean',
+            description: 'Repositório privado (para create/update)'
+        },
+        sourceRepo: {
+            type: 'string',
+            description: 'Repositório de origem (para fork)'
+        },
+        searchQuery: {
+            type: 'string',
+            description: 'Termo de busca (para search)'
+        },
+        language: {
+            type: 'string',
+            description: 'Filtrar por linguagem (para search)'
+        },
+        sort: {
+            type: 'string',
+            description: 'Ordenar por: stars, updated, created (padrão: stars)'
+        },
+        order: {
+            type: 'string',
+            description: 'Ordem: asc, desc (padrão: desc)'
+        },
+        page: {
+            type: 'number',
+            description: 'Página para paginação (padrão: 1)'
+        },
+        perPage: {
+            type: 'number',
+            description: 'Itens por página (padrão: 30)'
         }
     },
-    required: ['action', 'projectPath']
+    required: ['action', 'projectPath'],
+    // Provider é obrigatório para operações remotas
+    if: {
+        properties: {
+            action: {
+                enum: ['create', 'list', 'get', 'update', 'delete', 'fork', 'search']
+            }
+        }
+    },
+    then: {
+        required: ['action', 'projectPath', 'provider']
+    }
 };
 async function handleInit(projectPath, detection) {
     try {
@@ -279,19 +339,559 @@ async function handleBackup(projectPath, detection) {
         throw new Error(`Falha ao criar backup: ${error instanceof Error ? error.message : String(error)}`);
     }
 }
+// Funções para gerenciamento de repositórios remotos
+async function handleCreateRepo(repoName, description, isPrivate, detection, projectPath, provider) {
+    try {
+        // Execute both local and remote operations simultaneously
+        const results = await Promise.allSettled([
+            // Local operation: initialize Git repository
+            handleInit(projectPath, detection),
+            // Remote operation: create repository on specified provider(s)
+            provider_operation_handler_js_1.ProviderOperationHandler.executeOperation(provider, (providerInstance) => providerInstance.createRepository(repoName, description || `Repositório ${repoName}`, isPrivate || false))
+        ]);
+        const localResult = results[0];
+        const remoteResult = results[1];
+        // Format results
+        const localData = localResult.status === 'fulfilled' ? localResult.value : null;
+        const localError = localResult.status === 'rejected' ? localResult.reason.message : null;
+        const remoteData = remoteResult.status === 'fulfilled' ? remoteResult.value : null;
+        const remoteError = remoteResult.status === 'rejected' ? remoteResult.reason.message : null;
+        // Determine overall success and message
+        const localSuccess = localResult.status === 'fulfilled';
+        const remoteSuccess = remoteResult.status === 'fulfilled' && remoteData?.success;
+        let message;
+        if (localSuccess && remoteSuccess) {
+            message = `Repositório '${repoName}' criado com sucesso (local e remoto)`;
+        }
+        else if (localSuccess && !remoteSuccess) {
+            message = `Repositório '${repoName}' criado localmente, falha na criação remota`;
+        }
+        else if (!localSuccess && remoteSuccess) {
+            message = `Repositório '${repoName}' criado remotamente, falha na inicialização local`;
+        }
+        else {
+            message = `Falha ao criar repositório '${repoName}' (local e remoto)`;
+        }
+        return {
+            success: localSuccess || remoteSuccess, // Success if at least one operation succeeded
+            action: 'create',
+            message,
+            data: {
+                repoName,
+                description: description || `Repositório ${repoName}`,
+                private: isPrivate || false,
+                local: {
+                    success: localSuccess,
+                    data: localData,
+                    error: localError
+                },
+                remote: remoteData || {
+                    success: false,
+                    error: remoteError || 'Unknown remote operation error'
+                }
+            }
+        };
+    }
+    catch (error) {
+        throw new Error(`Falha ao criar repositório: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+async function handleListRepos(detection, page = 1, perPage = 30, sort = 'updated', provider) {
+    try {
+        // Execute operation on specified provider(s)
+        const result = await provider_operation_handler_js_1.ProviderOperationHandler.executeOperation(provider, (providerInstance) => providerInstance.listRepositories(detection.owner, page, perPage));
+        if (!result.success) {
+            const errorMessage = 'message' in result
+                ? result.message
+                : ('error' in result ? result.error || 'Failed to list repositories' : 'Unknown error');
+            throw new Error(errorMessage);
+        }
+        // Handle single provider result
+        if ('provider' in result && result.data) {
+            const repositories = result.data;
+            return {
+                success: true,
+                action: 'list',
+                message: `${repositories.length} repositórios encontrados no ${result.provider}`,
+                data: {
+                    repositories,
+                    total: repositories.length,
+                    page,
+                    perPage,
+                    sort,
+                    owner: detection.owner,
+                    provider: result.provider
+                }
+            };
+        }
+        // Handle multi-provider result
+        if ('message' in result && typeof result.data === 'object') {
+            const multiData = result.data;
+            const allRepositories = [];
+            const providerResults = {};
+            // Collect repositories from all successful providers
+            if (multiData.github?.success && multiData.github.data) {
+                allRepositories.push(...multiData.github.data);
+                providerResults.github = {
+                    success: true,
+                    count: multiData.github.data.length,
+                    repositories: multiData.github.data
+                };
+            }
+            else if (multiData.github) {
+                providerResults.github = {
+                    success: false,
+                    error: multiData.github.error
+                };
+            }
+            if (multiData.gitea?.success && multiData.gitea.data) {
+                allRepositories.push(...multiData.gitea.data);
+                providerResults.gitea = {
+                    success: true,
+                    count: multiData.gitea.data.length,
+                    repositories: multiData.gitea.data
+                };
+            }
+            else if (multiData.gitea) {
+                providerResults.gitea = {
+                    success: false,
+                    error: multiData.gitea.error
+                };
+            }
+            return {
+                success: true,
+                action: 'list',
+                message: result.message,
+                data: {
+                    repositories: allRepositories,
+                    total: allRepositories.length,
+                    page,
+                    perPage,
+                    sort,
+                    owner: detection.owner,
+                    provider: 'both',
+                    providerResults,
+                    warnings: result.warnings
+                }
+            };
+        }
+        throw new Error('Unexpected result format from provider operation');
+    }
+    catch (error) {
+        throw new Error(`Falha ao listar repositórios: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+async function handleGetRepo(repoName, detection, provider) {
+    try {
+        // Execute operation on specified provider(s)
+        const result = await provider_operation_handler_js_1.ProviderOperationHandler.executeOperation(provider, (providerInstance) => providerInstance.getRepository(detection.owner, repoName));
+        if (!result.success) {
+            const errorMessage = 'message' in result
+                ? result.message
+                : ('error' in result ? result.error || 'Failed to get repository' : 'Unknown error');
+            throw new Error(errorMessage);
+        }
+        // Handle single provider result
+        if ('provider' in result && result.data) {
+            return {
+                success: true,
+                action: 'get',
+                message: `Detalhes do repositório '${repoName}' obtidos do ${result.provider}`,
+                data: {
+                    repository: result.data,
+                    provider: result.provider
+                }
+            };
+        }
+        // Handle multi-provider result
+        if ('message' in result && typeof result.data === 'object') {
+            const multiData = result.data;
+            const repositories = {};
+            if (multiData.github?.success && multiData.github.data) {
+                repositories.github = multiData.github.data;
+            }
+            if (multiData.gitea?.success && multiData.gitea.data) {
+                repositories.gitea = multiData.gitea.data;
+            }
+            return {
+                success: true,
+                action: 'get',
+                message: result.message,
+                data: {
+                    repositories,
+                    provider: 'both',
+                    providerResults: {
+                        github: multiData.github ? {
+                            success: multiData.github.success,
+                            error: multiData.github.error
+                        } : undefined,
+                        gitea: multiData.gitea ? {
+                            success: multiData.gitea.success,
+                            error: multiData.gitea.error
+                        } : undefined
+                    },
+                    warnings: 'warnings' in result ? result.warnings : undefined
+                }
+            };
+        }
+        throw new Error('Unexpected result format from provider operation');
+    }
+    catch (error) {
+        throw new Error(`Falha ao obter repositório: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+async function handleSearchRepos(searchQuery, detection, provider, language, sort = 'stars', order = 'desc') {
+    try {
+        // Execute operation on specified provider(s)
+        const result = await provider_operation_handler_js_1.ProviderOperationHandler.executeOperation(provider, (providerInstance) => providerInstance.searchRepositories(searchQuery));
+        if (!result.success) {
+            const errorMessage = 'message' in result
+                ? result.message
+                : ('error' in result ? result.error || 'Failed to search repositories' : 'Unknown error');
+            throw new Error(errorMessage);
+        }
+        // Handle single provider result
+        if ('provider' in result && result.data) {
+            const searchResults = result.data;
+            return {
+                success: true,
+                action: 'search',
+                message: `${searchResults.length} repositórios encontrados para '${searchQuery}' no ${result.provider}`,
+                data: {
+                    query: searchQuery,
+                    language,
+                    sort,
+                    order,
+                    results: searchResults,
+                    total: searchResults.length,
+                    provider: result.provider
+                }
+            };
+        }
+        // Handle multi-provider result
+        if ('message' in result && typeof result.data === 'object') {
+            const multiData = result.data;
+            const allResults = [];
+            const providerResults = {};
+            // Collect results from all successful providers
+            if (multiData.github?.success && multiData.github.data) {
+                const githubResults = multiData.github.data.map((repo) => ({
+                    ...repo,
+                    source: 'github'
+                }));
+                allResults.push(...githubResults);
+                providerResults.github = {
+                    success: true,
+                    count: multiData.github.data.length,
+                    results: multiData.github.data
+                };
+            }
+            else if (multiData.github) {
+                providerResults.github = {
+                    success: false,
+                    error: multiData.github.error
+                };
+            }
+            if (multiData.gitea?.success && multiData.gitea.data) {
+                const giteaResults = multiData.gitea.data.map((repo) => ({
+                    ...repo,
+                    source: 'gitea'
+                }));
+                allResults.push(...giteaResults);
+                providerResults.gitea = {
+                    success: true,
+                    count: multiData.gitea.data.length,
+                    results: multiData.gitea.data
+                };
+            }
+            else if (multiData.gitea) {
+                providerResults.gitea = {
+                    success: false,
+                    error: multiData.gitea.error
+                };
+            }
+            return {
+                success: true,
+                action: 'search',
+                message: result.message,
+                data: {
+                    query: searchQuery,
+                    language,
+                    sort,
+                    order,
+                    results: allResults,
+                    total: allResults.length,
+                    provider: 'both',
+                    providerResults,
+                    warnings: 'warnings' in result ? result.warnings : undefined
+                }
+            };
+        }
+        throw new Error('Unexpected result format from provider operation');
+    }
+    catch (error) {
+        throw new Error(`Falha na busca: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+async function handleUpdateRepo(repoName, detection, provider, description, isPrivate) {
+    try {
+        // Prepare update data
+        const updateData = {};
+        if (description !== undefined)
+            updateData.description = description;
+        if (isPrivate !== undefined)
+            updateData.private = isPrivate;
+        // Execute operation on specified provider(s)
+        const result = await provider_operation_handler_js_1.ProviderOperationHandler.executeOperation(provider, (providerInstance) => providerInstance.updateRepository(detection.owner, repoName, updateData));
+        if (!result.success) {
+            const errorMessage = 'message' in result
+                ? result.message
+                : ('error' in result ? result.error || 'Failed to update repository' : 'Unknown error');
+            throw new Error(errorMessage);
+        }
+        // Handle single provider result
+        if ('provider' in result && result.data) {
+            return {
+                success: true,
+                action: 'update',
+                message: `Repositório '${repoName}' atualizado com sucesso no ${result.provider}`,
+                data: {
+                    repoUpdated: true,
+                    repository: result.data,
+                    provider: result.provider
+                }
+            };
+        }
+        // Handle multi-provider result
+        if ('message' in result && typeof result.data === 'object') {
+            const multiData = result.data;
+            const updatedRepositories = {};
+            if (multiData.github?.success && multiData.github.data) {
+                updatedRepositories.github = multiData.github.data;
+            }
+            if (multiData.gitea?.success && multiData.gitea.data) {
+                updatedRepositories.gitea = multiData.gitea.data;
+            }
+            return {
+                success: true,
+                action: 'update',
+                message: result.message,
+                data: {
+                    repoUpdated: true,
+                    repositories: updatedRepositories,
+                    provider: 'both',
+                    providerResults: {
+                        github: multiData.github ? {
+                            success: multiData.github.success,
+                            error: multiData.github.error
+                        } : undefined,
+                        gitea: multiData.gitea ? {
+                            success: multiData.gitea.success,
+                            error: multiData.gitea.error
+                        } : undefined
+                    },
+                    warnings: 'warnings' in result ? result.warnings : undefined
+                }
+            };
+        }
+        throw new Error('Unexpected result format from provider operation');
+    }
+    catch (error) {
+        throw new Error(`Falha ao atualizar repositório: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+async function handleDeleteRepo(repoName, detection, provider) {
+    try {
+        // Execute operation on specified provider(s)
+        const result = await provider_operation_handler_js_1.ProviderOperationHandler.executeOperation(provider, (providerInstance) => providerInstance.deleteRepository(detection.owner, repoName));
+        if (!result.success) {
+            const errorMessage = 'message' in result
+                ? result.message
+                : ('error' in result ? result.error || 'Failed to delete repository' : 'Unknown error');
+            throw new Error(errorMessage);
+        }
+        const deletedAt = new Date().toISOString();
+        // Handle single provider result
+        if ('provider' in result) {
+            return {
+                success: true,
+                action: 'delete',
+                message: `Repositório '${repoName}' removido com sucesso do ${result.provider}`,
+                data: {
+                    repoDeleted: true,
+                    repoName,
+                    owner: detection.owner,
+                    provider: result.provider,
+                    deletedAt,
+                    warning: 'Esta ação é irreversível'
+                }
+            };
+        }
+        // Handle multi-provider result
+        if ('data' in result && typeof result.data === 'object') {
+            const multiData = result.data;
+            const deletionResults = {};
+            if (multiData.github) {
+                deletionResults.github = {
+                    success: multiData.github.success,
+                    error: multiData.github.error
+                };
+            }
+            if (multiData.gitea) {
+                deletionResults.gitea = {
+                    success: multiData.gitea.success,
+                    error: multiData.gitea.error
+                };
+            }
+            return {
+                success: true,
+                action: 'delete',
+                message: result.message,
+                data: {
+                    repoDeleted: true,
+                    repoName,
+                    owner: detection.owner,
+                    provider: 'both',
+                    deletionResults,
+                    deletedAt,
+                    warning: 'Esta ação é irreversível',
+                    warnings: 'warnings' in result ? result.warnings : undefined
+                }
+            };
+        }
+        throw new Error('Unexpected result format from provider operation');
+    }
+    catch (error) {
+        throw new Error(`Falha ao remover repositório: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+async function handleForkRepo(sourceRepo, newRepoName, detection, provider) {
+    try {
+        // Parse sourceRepo (format: owner/repo)
+        const [sourceOwner, sourceRepoName] = sourceRepo.split('/');
+        if (!sourceOwner || !sourceRepoName) {
+            throw new Error('sourceRepo deve estar no formato "owner/repo"');
+        }
+        const forkName = newRepoName || sourceRepoName;
+        // Execute operation on specified provider(s)
+        const result = await provider_operation_handler_js_1.ProviderOperationHandler.executeOperation(provider, (providerInstance) => providerInstance.forkRepository(sourceOwner, sourceRepoName));
+        if (!result.success) {
+            const errorMessage = 'message' in result
+                ? result.message
+                : ('error' in result ? result.error || 'Failed to fork repository' : 'Unknown error');
+            throw new Error(errorMessage);
+        }
+        // Handle single provider result
+        if ('provider' in result && result.data) {
+            return {
+                success: true,
+                action: 'fork',
+                message: `Fork '${forkName}' criado com sucesso de '${sourceRepo}' no ${result.provider}`,
+                data: {
+                    repoForked: true,
+                    originalRepo: sourceRepo,
+                    forkName,
+                    repository: result.data,
+                    provider: result.provider
+                }
+            };
+        }
+        // Handle multi-provider result
+        if ('message' in result && typeof result.data === 'object') {
+            const multiData = result.data;
+            const forkedRepositories = {};
+            if (multiData.github?.success && multiData.github.data) {
+                forkedRepositories.github = multiData.github.data;
+            }
+            if (multiData.gitea?.success && multiData.gitea.data) {
+                forkedRepositories.gitea = multiData.gitea.data;
+            }
+            return {
+                success: true,
+                action: 'fork',
+                message: result.message,
+                data: {
+                    repoForked: true,
+                    originalRepo: sourceRepo,
+                    forkName,
+                    repositories: forkedRepositories,
+                    provider: 'both',
+                    providerResults: {
+                        github: multiData.github ? {
+                            success: multiData.github.success,
+                            error: multiData.github.error
+                        } : undefined,
+                        gitea: multiData.gitea ? {
+                            success: multiData.gitea.success,
+                            error: multiData.gitea.error
+                        } : undefined
+                    },
+                    warnings: 'warnings' in result ? result.warnings : undefined
+                }
+            };
+        }
+        throw new Error('Unexpected result format from provider operation');
+    }
+    catch (error) {
+        throw new Error(`Falha ao criar fork: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
 exports.gitWorkflowTool = {
     name: 'git-workflow',
-    description: '🔄 WORKFLOW PRINCIPAL - Operações Git integradas: init, commit, sync, status, backup',
+    description: '🔄 WORKFLOW COMPLETO - Operações Git locais + gerenciamento completo de repositórios remotos: init, commit, sync, status, backup, create, list, get, update, delete, fork, search',
     inputSchema,
     async handler(input) {
         try {
-            const { action, projectPath, message, branch, remote } = input;
+            const { action, projectPath, provider, message, branch, remote, repoName, description, private: isPrivate, sourceRepo, searchQuery, language, sort, order, page, perPage } = input;
             if (!projectPath) {
                 throw new Error('projectPath é obrigatório');
             }
+            // Define remote operations that require provider parameter
+            const remoteOperations = ['create', 'list', 'get', 'update', 'delete', 'fork', 'search'];
+            // Validate provider parameter for remote operations
+            if (remoteOperations.includes(action)) {
+                if (!provider) {
+                    const detection = (0, auto_detection_js_1.autoDetect)(projectPath);
+                    return (0, auto_detection_js_1.createUniversalResponse)(false, action, 'Provider parameter is required for remote operations', detection, 'git-workflow', undefined, {
+                        code: 'MISSING_PROVIDER_PARAMETER',
+                        message: 'Provider parameter is required for remote operations',
+                        cause: 'Provider parameter not provided for remote operation',
+                        suggestion: 'Add provider parameter with one of: github, gitea, both'
+                    });
+                }
+                // Validate provider parameter value
+                const providerValidation = configuration_validator_js_1.ConfigurationValidator.validateProvider(provider);
+                if (!providerValidation.valid) {
+                    const detection = (0, auto_detection_js_1.autoDetect)(projectPath);
+                    return (0, auto_detection_js_1.createUniversalResponse)(false, action, providerValidation.error.message, detection, 'git-workflow', undefined, {
+                        code: providerValidation.error.code,
+                        message: providerValidation.error.message,
+                        cause: 'Invalid provider parameter value',
+                        suggestion: providerValidation.error.suggestion
+                    });
+                }
+                // Validate provider configuration
+                const configValidation = configuration_validator_js_1.ConfigurationValidator.validateProviderConfiguration(provider);
+                if (!configValidation.valid) {
+                    const detection = (0, auto_detection_js_1.autoDetect)(projectPath);
+                    const errorMessage = configuration_validator_js_1.ConfigurationValidator.formatValidationError(configValidation);
+                    // Create comprehensive error response for configuration issues
+                    const configError = configValidation.error.configuration;
+                    const enhancedMessage = configError
+                        ? `${configValidation.error.message}\n\n${configuration_validator_js_1.ConfigurationValidator.formatValidationError(configValidation)}`
+                        : configValidation.error.message;
+                    return (0, auto_detection_js_1.createUniversalResponse)(false, action, enhancedMessage, detection, 'git-workflow', undefined, {
+                        code: configValidation.error.code,
+                        message: errorMessage,
+                        cause: 'Provider configuration validation failed',
+                        suggestion: configValidation.error.suggestion
+                    });
+                }
+            }
             const detection = (0, auto_detection_js_1.autoDetect)(projectPath);
             let result;
             switch (action) {
+                // Operações Git locais
                 case 'init':
                     result = await handleInit(projectPath, detection);
                     break;
@@ -313,16 +913,69 @@ exports.gitWorkflowTool = {
                 case 'backup':
                     result = await handleBackup(projectPath, detection);
                     break;
+                // Gerenciamento de repositórios remotos
+                case 'create':
+                    if (!repoName) {
+                        throw new Error('repoName é obrigatório para create');
+                    }
+                    result = await handleCreateRepo(repoName, description || '', isPrivate || false, detection, projectPath, provider);
+                    break;
+                case 'list':
+                    result = await handleListRepos(detection, page, perPage, sort, provider);
+                    break;
+                case 'get':
+                    if (!repoName) {
+                        throw new Error('repoName é obrigatório para get');
+                    }
+                    result = await handleGetRepo(repoName, detection, provider);
+                    break;
+                case 'search':
+                    if (!searchQuery) {
+                        throw new Error('searchQuery é obrigatório para search');
+                    }
+                    result = await handleSearchRepos(searchQuery, detection, provider, language, sort, order);
+                    break;
+                case 'update':
+                    if (!repoName) {
+                        throw new Error('repoName é obrigatório para update');
+                    }
+                    result = await handleUpdateRepo(repoName, detection, provider, description, isPrivate);
+                    break;
+                case 'delete':
+                    if (!repoName) {
+                        throw new Error('repoName é obrigatório para delete');
+                    }
+                    result = await handleDeleteRepo(repoName, detection, provider);
+                    break;
+                case 'fork':
+                    if (!sourceRepo) {
+                        throw new Error('sourceRepo é obrigatório para fork');
+                    }
+                    result = await handleForkRepo(sourceRepo, repoName, detection, provider);
+                    break;
                 default:
-                    throw new Error(`Ação '${action}' não suportada. Use: init, commit, sync, status, backup`);
+                    throw new Error(`Ação '${action}' não suportada. Use: init, commit, sync, status, backup, create, list, get, update, delete, fork, search`);
             }
             return (0, auto_detection_js_1.createUniversalResponse)(result.success, action, result.message, detection, 'git-workflow', result.data);
         }
         catch (error) {
             const detection = (0, auto_detection_js_1.autoDetect)(input.projectPath || '');
-            return (0, auto_detection_js_1.createUniversalResponse)(false, input.action || 'unknown', error instanceof Error ? error.message : String(error), detection, 'git-workflow', undefined, {
+            const errorInstance = error instanceof Error ? error : new Error(String(error));
+            // For remote operations, provide comprehensive error handling
+            const remoteOperations = ['create', 'list', 'get', 'update', 'delete', 'fork', 'search'];
+            if (remoteOperations.includes(input.action) && input.provider) {
+                const operationError = operation_error_handler_js_1.OperationErrorHandler.analyzeAndHandleError(errorInstance, input.provider, input.action);
+                return (0, auto_detection_js_1.createUniversalResponse)(false, input.action || 'unknown', operationError.message, detection, 'git-workflow', undefined, {
+                    code: operationError.code,
+                    message: operation_error_handler_js_1.OperationErrorHandler.formatErrorMessage(operationError),
+                    cause: operationError.cause,
+                    suggestion: operationError.solution
+                });
+            }
+            // For local operations, provide generic error handling
+            return (0, auto_detection_js_1.createUniversalResponse)(false, input.action || 'unknown', errorInstance.message, detection, 'git-workflow', undefined, {
                 code: 'WORKFLOW_ERROR',
-                message: error instanceof Error ? error.message : String(error),
+                message: errorInstance.message,
                 cause: 'Erro na execução do workflow Git',
                 suggestion: 'Verifique os parâmetros e tente novamente'
             });